palabras - ¿Cómo uso la palabra clave Exists de T-SQL?

palabras clave de sql y su significado

Question

Tengo una consulta que quiero ejecutar como una subconsulta que devolverá un conjunto de FK. Con ellos, quiero devolver solo las filas que tengan una clave coincidente.

Subconsulta:

SELECT ID 
FROM tblTenantTransCode 
WHERE
    tblTenantTransCode.CheckbookCode = 
      (SELECT ID FROM tblCheckbookCode WHERE Description = ''Rent Income'')

Eso devolverá todos los códigos de transacción que tengan un código de chequera que coincida con el ingreso de renta

Ahora quiero seleccionar Todas las transacciones donde su código de transacción coincida con una ID devuelta en la subconsulta. He llegado hasta aquí, pero SQL Server se queja de un error de sintaxis. ¿Cómo puedo hacer esto?

Consulta completa:

SELECT * 
FROM tblTransaction
WHERE
    tblTransaction.TransactionCode IN 
      (SELECT ID FROM tblTenantTransCode 
       WHERE tblTenantTransCode.CheckbookCode = 
           (SELECT ID FROM tblCheckbookCode WHERE Description = ''Rent Income''))

Mesas:

tblCheckbookCode ID Description Other Info tblTenantTransCode ID CheckbookCode <-- fk we''re looking for in the tblCheckbookCode. We''re selecting only checkbook codes that have the Description ''Rent Income'' Other Info tblTransactions ID TransactionCode <-- fk to tenant transaction code. We''re looking for an ID that is returned in the above query/join

Answer 1

Dada su consulta completa, esta consulta lo llevará a donde necesita ir con una sola unión.

La combinación filtra cualquier transacción que no tenga un código de transacción de ''Ingresos de alquiler''. Tomará todos los registros de la primera tabla, construirá el subconjunto de la segunda tabla (esa cláusula WHERE limita los registros), y luego filtra la primera tabla donde esas tablas calculan la condición de unión.

SELECT 
    t.* 
FROM 
    tblTransaction t
    INNER JOIN tblTenantTransCode c ON
        t.TransactionCode = c.ID
    INNER JOIN tblCheckbookCode chk ON
        c.CheckbookCode = chk.ID
WHERE
    chk.Description = ''Rent Income''

Editar: Otra nota: Evite usar SELECT * - siempre especifique las columnas. Editar Dos: me perdí que había tres tablas. Corregido! Gracias, spencer!

Answer 2

Debes usar la cláusula ''IN'':

select id from tblTenantTransCode
where tblTenantTransCode.CheckbookCode in
    (select id from tblCheckbookCode
     where description = ''rent income'')

una unión interna probablemente sería una mejor solución, aunque ...

select ttc.id from tblTenantTransCode as ttc
inner join tblCheckbookCode as tcc
    on ttc.CheckBookId = tcc.id
where tcc.description = ''rent income''

Answer 3

Para responder a su pregunta sobre el uso de la palabra clave EXISTS , aquí hay una consulta de ejemplo que utiliza un predicado EXISTS, en función de la consulta que se brinda actualmente en su pregunta.

SELECT t.* FROM tblTransaction t WHERE EXISTS ( SELECT 1 FROM tblTenantTransCode ttc JOIN tblCheckbookCode cc ON (cc.ID = ttc.CheckbookCode AND cc.Description=''Rent Income'') WHERE ttc.ID = t.TransactionCode )

Detalles adicionales:

Todos reconocemos que hay una variedad de sentencias SQL que devolverán el conjunto de resultados que cumple con los requisitos especificados. Y es probable que haya diferencias en el rendimiento observado de esas consultas. El rendimiento es particularmente dependiente del DBMS, el modo del optimizador, el plan de consulta y las estadísticas (número de filas y distribución del valor de los datos).

Una ventaja de EXISTS es que deja en claro que no estamos interesados ​​en devolver ninguna expresión de las tablas en la subconsulta. Sirve para separar lógicamente la subconsulta de la consulta externa, de una manera que JOIN no lo hace.

Otra ventaja de usar EXISTS es que evita la devolución de filas duplicadas que se (podrían) devolver si, en cambio, JOIN un JOIN .

Un predicado EXISTS se puede usar para probar la existencia de cualquier fila relacionada en una tabla secundaria, sin requerir una unión. Como ejemplo, la siguiente consulta devuelve un conjunto de todos los pedidos que tienen al menos un elemento de línea asociado:

SELECT o.* FROM order o WHERE EXISTS ( SELECT 1 FROM line_item li WHERE li.order_id = o.id )

Tenga en cuenta que la subconsulta no necesita encontrar TODAS las líneas de pedido coincidentes, solo necesita encontrar una fila para satisfacer la condición. (Si tuviéramos que escribir esta consulta como JOIN , devolveríamos filas duplicadas siempre que una orden tuviera más de una línea de pedido).

Un predicado NOT EXISTS también es útil, por ejemplo, para devolver un conjunto de órdenes que no tienen ningún line_items asociado.

SELECT o.* FROM order o WHERE NOT EXISTS ( SELECT 1 FROM line_item li WHERE li.order_id = o.id )

Por supuesto, NOT EXISTS es solo una alternativa. Se podría obtener un conjunto de resultados equivalente usando una combinación OUTER y una prueba IS NULL (suponiendo que tenemos al menos una expresión disponible de la tabla line_item que NO ES NULL)

SELECT o.* FROM order o LEFT JOIN line_item li ON (li.order_id = o.id) WHERE li.id IS NULL

Parece haber mucha discusión (relacionada con las respuestas a la pregunta original) sobre la necesidad de usar un predicado IN , o la necesidad de usar un JOIN .

Esos constructos son alternativas, pero no son necesarios. El conjunto de resultados requerido puede ser devuelto por una consulta sin usar una IN y sin usar un JOIN . El conjunto de resultados se puede devolver con una consulta que usa un predicado EXISTS . (Tenga en cuenta que el título de la pregunta OP preguntó sobre cómo usar la palabra clave EXISTS ).

Aquí hay otra consulta alternativa (esta no es mi primera opción), pero el conjunto de resultados devuelto satisface los requisitos especificados:

SELECT t.* FROM tblTransaction t WHERE EXISTS ( SELECT 1 FROM tblTenantTransCode ttc WHERE ttc.ID = t.TransactionCode AND EXISTS ( SELECT 1 FROM tblCheckbookCode cc WHERE cc.ID = ttc.CheckbookCode AND cc.Description = ''Rent Income'' ) )

De importancia primordial, la consulta debe devolver un conjunto de resultados correctos, uno que satisfaga los requisitos especificados, dados todos los conjuntos posibles de condiciones.

Algunas de las consultas presentadas aquí como respuestas NO devuelven el conjunto de resultados solicitado, o si lo hacen, lo hacen por accidente. Algunas de las consultas funcionarán si presuponemos algo sobre los datos, de forma que algunas columnas sean UNIQUE y NOT NULL .

Diferencias de rendimiento

A veces, una consulta con un predicado EXISTS no funcionará tan bien como una consulta con un predicado JOIN o IN . En algunos casos, puede tener un mejor rendimiento. (Con el predicado EXISTS , la subconsulta solo tiene que encontrar una fila que satisfaga la condición, en lugar de encontrar TODAS las filas coincidentes, como lo requeriría un JOIN ).

El rendimiento de varias opciones de consulta se mide mejor mediante la observación.

Answer 4

Prueba esto:

SELECT
    tblTenantTransCode.ID 
    FROM tblCheckbookCode 
        INNER JOIN tblTenantTransCode ON tblCheckbookCode.ID=tblTenantTransCode.CheckbookCode
    WHERE tblCheckbookCode.Description = ''Rent Income''

Asegúrese de indexar tblCheckbookCode.Description .

Answer 5

Usted está describiendo una unión interna.

select tc.id 
from tblTenantTransCode tc 
   inner join tblCheckbookCode cc on tc.CheckbookCode = cc.CheckbookCode

EDITAR: Sigue siendo una unión interna. No veo ningún motivo para usar la cláusula IN.

select *
from tblTransaction t
   inner join tblTenantTransCode tc on tc.id = t.TransactionCode
   inner join tblCheckbookCode cc on cc.id = tc.CheckbookCode
where cc.description = ''Rent Income''

EDITAR: si debe usar el predicado EXISTS para resolver este problema, consulte la respuesta de @ spencer7953. Sin embargo, por lo que estoy viendo, la solución anterior es más simple y hay suposiciones de singularidad basadas en el hecho de que "Subquery" funciona para usted (no sería el 100% del tiempo si no hubiera unicidad en esa tabla ) También me estoy dirigiendo

Ahora quiero seleccionar Todas las transacciones donde su código de transacción coincide con una ID devuelta en la subconsulta

en mi respuesta. Si la solicitud fue algo en las líneas de esto:

Ahora quiero seleccionar All Transcations cuando cualquier código de transacción coincida con una ID devuelta en la subconsulta.

Utilizaría EXISTS para ver si existía algún código de transacción en la tabla secundaria y devolvería cada fila o ninguna según corresponda.