SQL-Query: EXISTS en la Subtabla

Question

Tengo dos tablas tabData y tabDataDetail. Quiero que todos idData (PK) de Padres-Tabla (tabData) que tienen sólo filas de Niño-Tabla (tabDataDetail, FK es fiData) con:

• fiActionCode = 11 solo o
• fiactionCode = 11 y fiActionCode = 34

Cualquier otra combinación no es válida. ¿Cómo conseguirlos?

lo que he intentado sin éxito (lento y me da también filas que tienen única fiActioncode 34):

alt text http://www.bilder-hochladen.net/files/4709-l0.jpg

Gracias por su tiempo.

---

EDITAR: Gracias a todos por sus respuestas. Ahora, desafortunadamente, no tengo tiempo suficiente para verificar cuál es el mejor o funciona en absoluto. Marqué el primero como respuesta.

EDIT2: creo que la respuesta correcta es realmente la solución más eficiente y compacta.

EDIT3: La respuesta de Codesleuth es interesante porque devuelve solo filas que solo tienen un solo fiActionCode = 11. Difícil de ver, porque eso solo es válido para 20 tabDataDetail-rows ot de 41524189 total-rows que tienen dos. De todos modos, eso no era 100% lo que pedí o más bien lo que estaba buscando.

Answer 1

Select ... 
From tabData As T1 
Where Exists (
       Select 1 
       From tabDataDetail As TDD1 
       Where TDD1.fiData = T1.idData 
        And TDD1.fiactionCode = 11 
       ) 
    And Not Exists (
         Select 1 
         From tabDataDetail As TDD1 
         Where TDD1.fiData = T1.idData 
          And TDD1.fiactionCode Not In(11,34) 
        ) 

Para ampliar mi lógica, la primera comprobación (una corrección) es garantizar que exista una fila con fiActionCode = 11. El segundo cheque funciona definiendo primero el conjunto de filas que no queremos. No queremos nada que sea diferente a fiActionCode = 11 o 34. Como ese es el conjunto de elementos que no queremos, buscamos cualquier cosa que no exista en ese conjunto.

Answer 2

Editar: Apols - Veo lo que quiere decir con filas de niños. Esto no es particularmente eficiente. Gracias también a Lieven por los datos.

SELECT idData FROM 
tabData td 
WHERE EXISTS 
(
    SELECT 1 
     FROM tabDataDetail tdd 
     WHERE tdd.fiData = td.idData AND fiActionCode = 11 
) 
AND NOT EXISTS 
(
    SELECT 1 
     FROM tabDataDetail tdd 
     WHERE tdd.fiData = td.idData AND fiActionCode <> 11 
) 
UNION 
SELECT idData 
    FROM tabData td 
    WHERE EXISTS 
    (
     SELECT 1 
      FROM tabDataDetail tdd 
      WHERE tdd.fiData = td.idData AND fiActionCode = 11 
    ) 
    AND EXISTS 
    (
     SELECT 1 
      FROM tabDataDetail tdd 
      WHERE tdd.fiData = td.idData AND fiActionCode = 34 
    ) 
AND NOT EXISTS 
(
    SELECT 1 
     FROM tabDataDetail tdd 
     WHERE tdd.fiData = td.idData AND fiActionCode NOT IN (11, 34) 
) 

Answer 3

Razonamiento

1. LEFT OUTER JOIN excluye todos de idData que tienen un ID diferente de 11 o 34
2. HAVING excluye todos los idData de que solamente tienen un registros 34
3. restantes (debería) satisfacer todas las restricciones

Los datos de prueba

DECLARE @tabData TABLE (idData INTEGER) 
DECLARE @tabDataDetail TABLE (fiData INTEGER, fiActionCode INTEGER) 

INSERT INTO @tabData VALUES (1) 
INSERT INTO @tabData VALUES (2) 
INSERT INTO @tabData VALUES (3) 
INSERT INTO @tabData VALUES (4) 
INSERT INTO @tabData VALUES (5) 

/* Only idData 1 & 2 should be returned */ 
INSERT INTO @tabDataDetail VALUES (1, 11) 
INSERT INTO @tabDataDetail VALUES (2, 11) 
INSERT INTO @tabDataDetail VALUES (2, 34) 
INSERT INTO @tabDataDetail VALUES (3, 99) 
INSERT INTO @tabDataDetail VALUES (4, 11) 
INSERT INTO @tabDataDetail VALUES (4, 99) 
INSERT INTO @tabDataDetail VALUES (5, 34) 

consulta

SELECT * 
FROM @tabData d 
     INNER JOIN @tabDataDetail dd ON dd.fiData = d.idData 
     INNER JOIN (
      SELECT idData 
      FROM @tabData d 
        INNER JOIN @tabDataDetail dd ON dd.fiData = d.idData 
        LEFT OUTER JOIN (
        SELECT fiData 
        FROM @tabDataDetail 
        WHERE fiActionCode NOT IN (11, 34) 
       ) exclude ON exclude.fiData = d.idData 
      WHERE exclude.fiData IS NULL     
      GROUP BY 
        idData 
      HAVING MIN(fiActionCode) = 11   
     ) include ON include.idData = d.idData 

Answer 4

Editado mi respuesta sobre la base de aclaraciones dadas en los comentarios sobre otras respuestas.

select td.idData 
from tabData td 
    left join tabDataDetail tdd 
    on td.idData = tdd.fiData 
    and tdd.fiActionCode = 11 
    left join tabDataDetail tdd2 
    on td.idData = tdd2.fiData 
    and tdd2.fiActionCode = 34 
    left join tabDataDetail tdd3 
    on td.idData = tdd3.fiData 
    and tdd3.fiActionCode not in (11,34) 
where (tdd.fiData is not null 
    or (tdd.fiData is not null and tdd2.fiData is not null)) 
    and tdd3.fiData is null 
group by td.idData 

Answer 5

Gracias @Lieven para el código de datos para probar esta:

DECLARE @tabData TABLE (idData INTEGER) 
DECLARE @tabDataDetail TABLE (idDataDetail int IDENTITY(1,1), 
    fiData INTEGER, fiActionCode INTEGER) 

INSERT INTO @tabData VALUES (1) 
INSERT INTO @tabData VALUES (2) 
INSERT INTO @tabData VALUES (3) 
INSERT INTO @tabData VALUES (4) 
INSERT INTO @tabData VALUES (5) 

/* Only idData 1 & 2 should be returned */ 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (1, 11) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (2, 11) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (2, 34) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (3, 99) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (4, 11) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (4, 99) 
INSERT INTO @tabDataDetail (fiData,fiActionCode) VALUES (5, 34) 

consulta:

SELECT td.idData 
FROM @tabData td 
     INNER JOIN @tabDataDetail tdd ON td.idData = tdd.fiData 
WHERE tdd.fiActionCode = 11 -- check 11 exists 
     AND NOT EXISTS (SELECT * FROM @tabDataDetail WHERE fiData = td.idData 
          AND idDataDetail <> tdd.idDataDetail) 
      -- ensures *only* 11 exists (0 results from subquery) 
UNION 
SELECT td.idData 
FROM @tabData td 
     INNER JOIN @tabDataDetail tdd1 ON td.idData = tdd1.fiData 
     INNER JOIN @tabDataDetail tdd2 ON td.idData = tdd2.fiData 
WHERE tdd1.fiActionCode = 11 -- check 11 exists 
     AND tdd2.fiActionCode = 34 -- check 34 exists 

devuelve:

idData 
----------- 
1 
2 

(2 row(s) affected)

Con sólo 1 subconsulta aquí (y siendo un COUNT en lugar de un muy lento NOT EXISTS) esto crea un plan de ejecución muy ordenado que debería ayudar si tiene problemas con la velocidad.

Answer 6

Esto lo hace con una pasada a través de los datos, creo.

Depende de la distribución de los datos, sea o no preferible hacer 2 búsquedas separadas.

WITH matches AS 
(
SELECT fiData 
FROM tabDataDetail 
GROUP BY fiData 
HAVING COUNT(CASE WHEN fiactionCode = 11 THEN 1 END) > 0 
AND COUNT(CASE WHEN fiactionCode NOT IN (11,34) THEN 1 END) = 0 
) 
SELECT ... 
FROM idData i 
JOIN matches m 
ON m.fiData = i.idData