All perguntas(dba)

Imagine que você tenha duas tabelas/consultas diferentes que deveriam ter/retornar dados idênticos. Você deseja verificar isso. Qual é uma maneira fácil de mostrar todas as linhas não correspondentes de cada tabela, como no exemplo abaixo, comparando todas as colunas? Suponha que haja 30 colunas nas tabelas, muitas das quais são NULLable.

Quando não há PK ou pode haver duplicatas por PK, juntar apenas colunas PK não é suficiente, e seria um desastre ter que fazer um FULL JOIN com 30 condições de junção que lidam adequadamente com NULLs, além de uma desagradável condição WHERE para excluir as linhas correspondentes.

Normalmente, é quando estou escrevendo uma nova consulta contra dados não apagados ou não totalmente compreendidos que o problema é pior e a probabilidade de um PK estar logicamente disponível é extremamente baixa. Eu crio duas maneiras diferentes de resolver o problema e depois comparo seus resultados, as diferenças destacando casos especiais nos dados que eu desconhecia.

O resultado precisa ficar assim:

Which   Col1   Col2   Col3   ... Col30
------  ------ ------ ------     ------
TableA  Cat    27     86               -- mismatch
TableB  Cat    27     105              -- mismatch
TableB  Cat    27     87               -- mismatch 2
TableA  Cat    128    92               -- no corresponding row
TableB  Lizard 83     NULL             -- no corresponding row

Se [Col1, Col2]acontecer de ser uma chave composta e ordenarmos por elas em nosso resultado final, podemos ver facilmente que A e B têm uma linha diferente que deve ser a mesma, e cada uma tem uma linha que não está na outra.

No exemplo acima, não é desejável ver a primeira linha duas vezes.

Aqui está DDL e DML para configurar tabelas e dados de amostra:

CREATE TABLE dbo.TableA (
   Col1 varchar(10),
   Col2 int,
   Col3 int,
   Col4 varchar(10),
   Col5 varchar(10),
   Col6 varchar(10),
   Col7 varchar(10),
   Col8 varchar(10),
   Col9 varchar(10),
   Col10 varchar(10),
   Col11 varchar(10),
   Col12 varchar(10),
   Col13 varchar(10),
   Col14 varchar(10),
   Col15 varchar(10),
   Col16 varchar(10),
   Col17 varchar(10),
   Col18 varchar(10),
   Col19 varchar(10),
   Col20 varchar(10),
   Col21 varchar(10),
   Col22 varchar(10),
   Col23 varchar(10),
   Col24 varchar(10),
   Col25 varchar(10),
   Col26 varchar(10),
   Col27 varchar(10),
   Col28 varchar(10),
   Col29 varchar(10),
   Col30 varchar(10)
);

CREATE TABLE dbo.TableB (
   Col1 varchar(10),
   Col2 int,
   Col3 int,
   Col4 varchar(10),
   Col5 varchar(10),
   Col6 varchar(10),
   Col7 varchar(10),
   Col8 varchar(10),
   Col9 varchar(10),
   Col10 varchar(10),
   Col11 varchar(10),
   Col12 varchar(10),
   Col13 varchar(10),
   Col14 varchar(10),
   Col15 varchar(10),
   Col16 varchar(10),
   Col17 varchar(10),
   Col18 varchar(10),
   Col19 varchar(10),
   Col20 varchar(10),
   Col21 varchar(10),
   Col22 varchar(10),
   Col23 varchar(10),
   Col24 varchar(10),
   Col25 varchar(10),
   Col26 varchar(10),
   Col27 varchar(10),
   Col28 varchar(10),
   Col29 varchar(10),
   Col30 varchar(10)
);

INSERT dbo.TableA (Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9, Col10, Col11, Col12, Col13, Col14, Col15, Col16, Col17, Col18, Col19, Col20, Col21, Col22, Col23, Col24, Col25, Col26, Col27, Col28, Col29, Col30)
VALUES
   ('Cat', 27, 86, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Cat', 128, 92, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Porcupine', NULL, 42, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Tapir', NULL, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0')
;

INSERT dbo.TableB (Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9, Col10, Col11, Col12, Col13, Col14, Col15, Col16, Col17, Col18, Col19, Col20, Col21, Col22, Col23, Col24, Col25, Col26, Col27, Col28, Col29, Col30)
VALUES
   ('Cat', 27, 105, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Cat', 27, 87, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Lizard', 83, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Porcupine', NULL, 42, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Tapir', NULL, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0');

Muitas questões

• A entrada do Escravo permaneceria até que houvesse uma inserção/atualização/exclusão na tabela do Mestre que pudesse afetar o Escravo?

• Caso contrário, como posso garantir que o Escravo esteja sincronizado com o Mestre daqui para frente (excluindo a entrada do Escravo ou copiando essa entrada para o Mestre manualmente)?

• Mais importante, como detecto que as tabelas estão fora de sincronia?

Por que é que quando temos um valor NULL em uma coluna e ordenamos pelo valor crescente, os NULLs são classificados primeiro?

select 1 as test
union all
select 2
union all
select NULL
union all
select 3
union all
select 4
order by test

resulta em

NULL
1
2
3
4

Eu continuo pensando que NULL significava "Indeterminante" ou possível "Desconhecido". Se isso for verdade, eles não classificariam por último, já que o valor pode ser maior que todos os outros valores? (Ou esta é uma opção de classificação em algum lugar?)

Estou no SQL Server 2008R2, mas suspeito que isso seja verdade em todos os SQL Servers e provavelmente em todos os RDBMSs.

Recentemente, vi a pergunta "onde 1 = 1 instrução" ; uma construção SQL que usei frequentemente na construção de SQL dinâmico em um esforço para escrever um código mais limpo (da perspectiva da linguagem do host).

De um modo geral, essa adição a uma instrução SQL afeta negativamente o desempenho da consulta? Não estou procurando uma resposta em relação a um sistema de banco de dados específico (porque o usei em DB2, SQL Server, MS-Access e mysql) - a menos que seja impossível responder sem entrar em detalhes.

Existe uma consulta simples que levaria > 2 segundos para que eu possa testar o registrador de consulta lenta?

Estou procurando algo como uma instrução recursiva ou iterativa genérica.

Esta é uma pergunta de acompanhamento de: https://stackoverflow.com/questions/7684477/is-it-possible-to-set-transaction-isolation-level-snapshot-automatically

Ainda estou tendo situações de impasse/tempo limite no aplicativo ASP.NET ao executar grandes relatórios simultaneamente, embora READ_COMMITTED_SNAPSHOT ON.

Então eu tenho duas perguntas:

1. Como posso verificar se o Instantâneo do Nível de Isolamento da Transação está funcionando conforme o esperado?
2. Estou assumindo que as chaves estrangeiras (nas tabelas da Web-Application para as tabelas-relatório) são as responsáveis ​​pelos deadlocks. Achei este artigo interessante :

Observação SQL Server adquire bloqueios compartilhados ao validar chaves estrangeiras, mesmo se a transação estiver usando instantâneo de leitura confirmada (leitura confirmada usando controle de versão de linha) ou nível de isolamento de instantâneo. Lembre-se disso ao examinar gráficos de deadlock de transações quando esses níveis de isolamento de transação são usados. Se você vir bloqueios compartilhados, verifique se os bloqueios são obtidos em um objeto referenciado por uma chave estrangeira.

Como posso verificar se o FK é realmente responsável pelas situações de Deadlock/Timeout, isso significa que eu poderia excluir essas chaves estrangeiras para evitar deadlocks (o que seria um esforço aceitável)?

Nota : Estou apenas lendo as tabelas que causam impasses.

Quaisquer pensamentos sobre este tópico são muito apreciados.

Editar Aqui está um Gráfico de Deadlock . Talvez alguém possa me ajudar a entender o que causa o impasse. Parece que ocorreu sem nenhum relatório em execução causado apenas pelo aplicativo da web, quando duas transações desejam gravar a mesma tabela (uma atualização e uma inserção, a inserção é como procedimento armazenado). Por que ele adquire bloqueios de página e como habilitar apenas os bloqueios de linha? A Insert-SP já usa TRANSACTION ISOLATION LEVEL REPEATABLE READ.

Tenho uma forte suspeita de que dois gatilhos (um update e um insert) são os responsáveis ​​pelos impasses. Aqui está o gatilho de inserção:

CREATE TRIGGER [dbo].[CreateRMAFiDates] 
   ON  [dbo].[RMA] 
   AFTER INSERT
AS 
BEGIN
    SET NOCOUNT ON;

    UPDATE RMA 
    SET [fiCreationDate]=(SELECT idDate FROM tdefDate 
        WHERE CONVERT(VARCHAR, INSERTED.Creation_Date, 112) = tdefDate.Text),
        [fiPopDate]=(SELECT idDate FROM tdefDate 
        WHERE CONVERT(VARCHAR, INSERTED.POP_Date, 112) = tdefDate.Text),
        [fiManufactureDate]=(SELECT idDate FROM tdefDate 
        WHERE CONVERT(VARCHAR, INSERTED.Manufacture_Date, 112) = tdefDate.Text)
    FROM INSERTED;
END

Portanto, esse gatilho atualiza a RMA-Table, o que faz com que o gatilho de atualização seja acionado (o que é semelhante). O gráfico de impasse confirma minha suposição? Acho que vou deletar esses gatilhos e criar um SP que está sendo executado uma vez por dia, o que seria perfeitamente suficiente, porque essas colunas são apenas para um SSAS-Cube (Molap).

Editar : A propósito, não houve mais impasse desde que excluí esses gatilhos :)

É verdade que os sistemas RDBMS são otimizados para COMMIToperações? Quão mais lentas/rápidas são ROLLBACKas operações e por quê?

Gostaria da opinião de alguns especialistas sobre as práticas recomendadas quando se trata de nomenclatura de coluna .

O pano de fundo é que , de acordo com a Wikipedia , a seguinte sintaxe,

SELECT ... FROM Employees JOIN Timesheets USING (EmployeeID);

é mais eficiente do que

SELECT ... FROM Employees JOIN Timesheets ON (Employees.EmployeeID = Timesheets.EmployeeID);

No entanto, a JOIN ... USINGsintaxe só funciona se todas as colunas de chave primária tiverem nomes globalmente exclusivos . Assim, eu me pergunto se isso é considerado a coisa certa a fazer.

Pessoalmente, sempre criei tabelas com coluna PK ide coluna de chave estrangeira othertable_id. Mas dessa forma não é possível usar USINGou NATURAL JOIN.

Quaisquer links para estilos de design ou guias de práticas recomendadas para design de tabelas também serão apreciados!

Ao migrar tabelas provenientes de outros SGBDs para Oracle, uma das tarefas padrão é substituir todos os VARCHAR(n)campos por VARCHAR2(n)campos (desde que n <= 4000).

Por que o Oracle chama esse tipo de dados VARCHAR2e não apenas VARCHARcomo outros SGBDs?

Comecei a aprender o pgAdmin III para gerenciar um banco de dados PostgreSQL. Mas não era um aplicativo fácil de usar.

Se eu criar ou tiver criado uma tabela com o pgAdmin III, como posso adicionar a funcionalidade "incremento automático" em um id de coluna que tem o tipo integer?