Disclaimer: Por favor, tenha paciência comigo como alguém que usa apenas bancos de dados uma pequena fração do seu tempo de trabalho. (Na maioria das vezes, faço programação C ++ no meu trabalho, mas todos os meses ímpares preciso pesquisar / corrigir / adicionar algo em um banco de dados Oracle.)
Eu precisei repetidamente escrever consultas SQL complexas, tanto para consultas ad-hoc quanto para consultas embutidas em aplicativos, onde grandes partes das consultas apenas repetiam "código".
Escrever essas abominações em uma linguagem de programação tradicional causaria muitos problemas, mas eu ( muitos I ) ainda não consegui encontrar nenhuma técnica decente para impedir a repetição do código de consulta SQL.
Edit: 1º, quero agradecer aos respondentes que forneceram excelentes melhorias no meu exemplo original . No entanto, esta questão não é sobre o meu exemplo. É sobre repetitividade em consultas SQL. Como tal, as respostas ( JackP , Leigh ) até agora fazem um ótimo trabalho ao mostrar que você pode reduzir a repetitividade escrevendo melhores consultas . No entanto, mesmo assim, você enfrenta alguma repetitividade que aparentemente não pode ser removida: isso sempre me incomodou com o SQL. Nas linguagens de programação "tradicionais", posso refatorar bastante para minimizar a repetitividade no código, mas com o SQL parece que não existem ferramentas (?) Que permitam isso, exceto para escrever uma instrução menos repetitiva para começar.
Observe que removi a tag Oracle novamente, pois estaria realmente interessado se não há banco de dados ou linguagem de script que permita algo mais.
Aqui está uma dessas pedras preciosas que juntei hoje. Ele basicamente relata a diferença em um conjunto de colunas de uma única tabela. Percorra o código a seguir, esp. a consulta grande no final. Eu continuarei abaixo.
--
-- Create Table to test queries
--
CREATE TABLE TEST_ATTRIBS (
id NUMBER PRIMARY KEY,
name VARCHAR2(300) UNIQUE,
attr1 VARCHAR2(2000),
attr2 VARCHAR2(2000),
attr3 INTEGER,
attr4 NUMBER,
attr5 VARCHAR2(2000)
);
--
-- insert some test data
--
insert into TEST_ATTRIBS values ( 1, 'Alfred', 'a', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 2, 'Batman', 'b', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 3, 'Chris', 'c', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 4, 'Dorothee', 'd', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 5, 'Emilia', 'e', 'Barfoo', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 6, 'Francis', 'f', 'Barfoo', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 7, 'Gustav', 'g', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 8, 'Homer', 'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 9, 'Ingrid', 'i', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (10, 'Jason', 'j', 'Bob', 33, 44, 'e');
insert into TEST_ATTRIBS values (12, 'Konrad', 'k', 'Bob', 66, 44, 'e');
insert into TEST_ATTRIBS values (13, 'Lucas', 'l', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (14, 'DUP_Alfred', 'a', 'FOOBAR', 33, 44, 'e');
insert into TEST_ATTRIBS values (15, 'DUP_Chris', 'c', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (16, 'DUP_Dorothee', 'd', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (17, 'DUP_Gustav', 'X', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values (18, 'DUP_Homer', 'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (19, 'DUP_Ingrid', 'Y', 'foo', 99, 44, 'e');
insert into TEST_ATTRIBS values (20, 'Martha', 'm', 'Bob', 33, 88, 'f');
-- Create comparison view
CREATE OR REPLACE VIEW TA_SELFCMP as
select
t1.id as id_1, t2.id as id_2, t1.name as name, t2.name as name_dup,
t1.attr1 as attr1_1, t1.attr2 as attr2_1, t1.attr3 as attr3_1, t1.attr4 as attr4_1, t1.attr5 as attr5_1,
t2.attr1 as attr1_2, t2.attr2 as attr2_2, t2.attr3 as attr3_2, t2.attr4 as attr4_2, t2.attr5 as attr5_2
from TEST_ATTRIBS t1, TEST_ATTRIBS t2
where t1.id <> t2.id
and t1.name <> t2.name
and t1.name = REPLACE(t2.name, 'DUP_', '')
;
-- NOTE THIS PIECE OF HORRIBLE CODE REPETITION --
-- Create comparison report
-- compare 1st attribute
select 'attr1' as Different,
id_1, id_2, name, name_dup,
CAST(attr1_1 AS VARCHAR2(2000)) as Val1, CAST(attr1_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr1_1 <> attr1_2
or (attr1_1 is null and attr1_2 is not null)
or (attr1_1 is not null and attr1_2 is null)
union
-- compare 2nd attribute
select 'attr2' as Different,
id_1, id_2, name, name_dup,
CAST(attr2_1 AS VARCHAR2(2000)) as Val1, CAST(attr2_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr2_1 <> attr2_2
or (attr2_1 is null and attr2_2 is not null)
or (attr2_1 is not null and attr2_2 is null)
union
-- compare 3rd attribute
select 'attr3' as Different,
id_1, id_2, name, name_dup,
CAST(attr3_1 AS VARCHAR2(2000)) as Val1, CAST(attr3_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr3_1 <> attr3_2
or (attr3_1 is null and attr3_2 is not null)
or (attr3_1 is not null and attr3_2 is null)
union
-- compare 4th attribute
select 'attr4' as Different,
id_1, id_2, name, name_dup,
CAST(attr4_1 AS VARCHAR2(2000)) as Val1, CAST(attr4_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr4_1 <> attr4_2
or (attr4_1 is null and attr4_2 is not null)
or (attr4_1 is not null and attr4_2 is null)
union
-- compare 5th attribute
select 'attr5' as Different,
id_1, id_2, name, name_dup,
CAST(attr5_1 AS VARCHAR2(2000)) as Val1, CAST(attr5_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr5_1 <> attr5_2
or (attr5_1 is null and attr5_2 is not null)
or (attr5_1 is not null and attr5_2 is null)
;
Como você pode ver, a consulta para gerar um "relatório de diferenças" usa o mesmo bloco SQL SELECT 5 vezes (pode ser facilmente 42 vezes!). Isso me parece absolutamente com morte cerebral (posso dizer isso depois de tudo que escrevi o código), mas não consegui encontrar nenhuma boa solução para isso.
Se isso fosse uma consulta em algum código de aplicativo real, eu poderia escrever uma função que agrupasse essa consulta como uma string e depois executaria a consulta como uma sequência.
- -> Construir strings é horrível e horrível para testar e manter. Se o "código do aplicativo" for escrito em uma linguagem como PL / SQL, parecerá tão errado que dói.
Como alternativa, se usado a partir de PL / SQL ou similar, eu acho que existem alguns procedimentos para tornar essa consulta mais sustentável.
- -> Desenrolar algo que pode ser expresso em uma única consulta em etapas processuais, apenas para evitar que a repetição de código também pareça errada.
Se essa consulta fosse necessária como uma exibição no banco de dados, então - pelo que entendi - não haveria outra maneira senão manter a definição da exibição, como postado acima. (!!?)
- -> Na verdade, tive que fazer alguma manutenção em uma definição de visualização de 2 páginas, uma vez que não estava muito acima da declaração. Obviamente, alterar qualquer coisa nessa visualização exigia uma pesquisa de texto regexp sobre a definição de visualização para saber se a mesma sub-instrução havia sido usada em outra linha e se precisava mudar lá.
Então, como diz o título - que técnicas existem para evitar a necessidade de escrever essas abominações?
fonte
UNION ALL
. Muitas vezesUNION
, semALL
geralmente resulta em um carretel de armazenamento temporário para a operação de classificação exigida (como 'união' é efetivamenteUNION ALL
seguidoDISTINCT
pelo que implica uma espécie) para que, em alguns casos a diferença de desempenho pode ser enorme.Aqui está uma alternativa à visualização test_attribs_unpivot fornecida por JackPDouglas (+1) que funciona em versões anteriores ao 11g e faz menos varreduras completas na tabela:
Sua consulta final pode ser usada inalterada com essa visualização.
fonte
SELECT rownum MyRow FROM test_attribs where rownum<=5
usarselect level MyRow from dual connect by level <= 5
. Você não deseja que todas essas lógicas sejam apenas para criar 5 linhas.Costumo encontrar o problema semelhante para comparar duas versões de uma tabela para linhas novas, excluídas ou alteradas. Há um mês, publiquei uma solução para o SQL Server usando o PowerShell aqui .
Para adaptá-lo ao seu problema, primeiro criei duas visualizações para separar o original das linhas duplicadas
e depois verifico as alterações com
A partir daqui, posso encontrar seus IDs originais
BTW: MINUS e UNION e GROUP BY tratam NULL diferentes como iguais. O uso dessas operações torna as consultas mais elegantes.
Dica para usuários do SQL Server: MINUS é nomeado EXCEPT, mas funciona de maneira semelhante.
fonte