Descargo de responsabilidad: Tenga paciencia conmigo como alguien que solo utiliza bases de datos una pequeña fracción de su tiempo de trabajo. (La mayoría de las veces hago programación C ++ en mi trabajo, pero cada mes extraño necesito buscar / arreglar / agregar algo en una base de datos Oracle).
En repetidas ocasiones he necesitado escribir consultas SQL complejas, tanto para consultas ad-hoc como para consultas integradas en aplicaciones, donde grandes partes de las consultas solo repetían "código".
Escribir tales abominaciones en un lenguaje de programación tradicional lo metería en serios problemas, sin embargo, yo ( I ) aún no he podido encontrar ninguna técnica decente para evitar la repetición del código de consulta SQL.
Editar: primero, quiero agradecer a los que respondieron que proporcionaron excelentes mejoras a mi ejemplo original . Sin embargo, esta pregunta no se trata de mi ejemplo. Se trata de la repetitividad en las consultas SQL. Como tal, las respuestas ( JackP , Leigh ) hasta ahora hacen un gran trabajo al mostrar que puede reducir la repetición escribiendo mejores consultas . Sin embargo, incluso entonces te enfrentas a una repetición que aparentemente no se puede eliminar: esto siempre me fastidiaba con SQL. En los lenguajes de programación "tradicionales" puedo refactorizar mucho para minimizar la repetición en el código, pero con SQL parece que no hay herramientas (?) Que permitan esto, excepto para escribir una declaración menos repetitiva para empezar.
Tenga en cuenta que he eliminado la etiqueta de Oracle nuevamente, ya que estaría realmente interesado si no hay una base de datos o lenguaje de script que permita algo más.
Aquí hay una de esas gemas que improvisé hoy. Básicamente informa la diferencia en un conjunto de columnas de una sola tabla. Lea el siguiente código, especialmente. La consulta grande al final. Continuaré abajo.
--
-- 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 puede ver, la consulta para generar un "informe de diferencia" usa el mismo bloque SQL SELECT 5 veces (¡podría ser 42 veces fácilmente!). Esto me parece absolutamente mortal (se me permite decir esto, después de todo, escribí el código), pero no he podido encontrar ninguna buena solución para esto.
Si esto fuera una consulta en algún código de aplicación real, podría escribir una función que combine esta consulta como una cadena y luego ejecutaría la consulta como una cadena.
- -> Construir cadenas es horrible y horrible de probar y mantener. Si el "código de la aplicación" está escrito en un lenguaje como PL / SQL, se siente tan mal que duele.
Alternativamente, si se usa desde PL / SQL o similar, supongo que hay algunos medios de procedimiento para hacer que esta consulta sea más fácil de mantener.
- -> Desenrollar algo que se puede expresar en una sola consulta en pasos de procedimiento solo para evitar la repetición del código también se siente mal.
Si esta consulta fuera necesaria como una vista en la base de datos, entonces, por lo que yo entiendo, no habría otra forma que no sea mantener la definición de la vista tal como la publiqué anteriormente. (!!?)
- -> Realmente tuve que hacer algo de mantenimiento en una definición de vista de 2 páginas una vez que no estaba muy lejos de la declaración anterior. Obviamente, cambiar cualquier cosa en esta vista requería una búsqueda de texto regexp sobre la definición de vista para ver si la misma subdeclaración se había utilizado en otra línea y si era necesario cambiarla allí.
Entonces, como dice el título, ¿qué técnicas existen para evitar tener que escribir tales abominaciones?
UNION ALL
. A menudo,UNION
sin queALL
normalmente se produzca un spool para el almacenamiento temporal para la operación de clasificación requerida (ya que 'UNION' esUNION ALL
seguido efectivamente por loDISTINCT
que implica una clasificación), en algunos casos la diferencia de rendimiento puede ser enorme.