Necesito implementar la siguiente consulta en SQL Server:

select *
from table1
WHERE  (CM_PLAN_ID,Individual_ID)
IN
(
 Select CM_PLAN_ID, Individual_ID
 From CRM_VCM_CURRENT_LEAD_STATUS
 Where Lead_Key = :_Lead_Key
)

Pero la cláusula WHERE..IN permite solo 1 columna. ¿Cómo puedo comparar 2 o más columnas con otro SELECT interno?

Puede hacer una tabla derivada de la subconsulta y unir table1 a esta tabla derivada:

select * from table1 LEFT JOIN 
(
   Select CM_PLAN_ID, Individual_ID
   From CRM_VCM_CURRENT_LEAD_STATUS
   Where Lead_Key = :_Lead_Key
) table2
ON 
   table1.CM_PLAN_ID=table2.CM_PLAN_ID
   AND table1.Individual=table2.Individual
WHERE table2.CM_PLAN_ID IS NOT NULL

En su lugar, querrá usar la sintaxis WHERE EXISTS.

SELECT *
FROM table1
WHERE EXISTS (SELECT *
              FROM table2
              WHERE Lead_Key = @Lead_Key
                        AND table1.CM_PLAN_ID = table2.CM_PLAN_ID
                        AND table1.Individual_ID = table2.Individual_ID)

ADVERTENCIA SOBRE SOLUCIONES:

MUCHAS SOLUCIONES EXISTENTES PROPORCIONARÁN LA SALIDA INCORRECTA SI LAS FILAS NO SON ÚNICAS

Si usted es la única persona que crea tablas, esto puede no ser relevante, pero varias soluciones le darán un número diferente de filas de salida del código en cuestión, cuando una de las tablas puede no contener filas únicas.

ADVERTENCIA SOBRE LA DECLARACIÓN DEL PROBLEMA:

CON MÚLTIPLES COLUMNAS NO EXISTE, PIENSA CUIDADOSAMENTE LO QUE QUIERES

Cuando veo una entrada con dos columnas, puedo imaginar que significa dos cosas:

1. El valor de la columna a y la columna b aparecen en la otra tabla independientemente
2. Los valores de la columna a y la columna b aparecen juntos en la otra tabla en la misma fila

El escenario 1 es bastante trivial, simplemente use dos declaraciones IN.

En línea con la mayoría de las respuestas existentes, por la presente proporciono una visión general de los enfoques mencionados y adicionales para el Escenario 2 (y un breve juicio):

EXISTE (Seguro, recomendado para SQL Server)

Según lo provisto por @mrdenny, EXISTS suena exactamente como lo que está buscando, aquí está su ejemplo:

SELECT * FROM T1
WHERE EXISTS
(SELECT * FROM T2 
 WHERE T1.a=T2.a and T1.b=T2.b)

IZQUIERDA SEMI UNIR (Seguro, recomendado para dialectos que lo soporten)

Esta es una forma muy concisa de unirse, pero desafortunadamente la mayoría de los dialectos de SQL, incluido el servidor SQL, actualmente no lo admiten.

SELECT * FROM T1
LEFT SEMI JOIN T2 ON T1.a=T2.a and T1.b=T2.b

Múltiples declaraciones IN (seguro, pero tenga cuidado con la duplicación de código)

Como mencionó @cataclysm, usar dos declaraciones IN también puede ser útil, tal vez incluso supere a las otras soluciones. Sin embargo, debe tener mucho cuidado con la duplicación de código. Si alguna vez desea seleccionar de una tabla diferente o cambiar la instrucción where, es un riesgo mayor que cree inconsistencias en su lógica.

Solución básica

SELECT * from T1
WHERE a IN (SELECT a FROM T2 WHERE something)
AND b IN (SELECT b FROM T2 WHERE something)

Solución sin duplicación de código (creo que esto no funciona en consultas regulares de SQL Server)

WITH mytmp AS (SELECT a, b FROM T2 WHERE something);
SELECT * from T1 
WHERE a IN (SELECT a FROM mytmp)
AND b IN (SELECT b FROM mytmp)

UNIÓN INTERNA (técnicamente se puede hacer seguro, pero a menudo esto no se hace)

La razón por la que no recomiendo usar una unión interna como filtro es porque, en la práctica, las personas a menudo permiten que los duplicados en la tabla derecha causen duplicados en la tabla izquierda. Y para empeorar las cosas, a veces hacen que el resultado final sea distinto, mientras que la tabla de la izquierda en realidad puede no necesitar ser única (o no única en las columnas que seleccione). Además, le da la oportunidad de seleccionar realmente una columna que no existe en la tabla de la izquierda.

SELECT T1.* FROM T1
INNER JOIN 
(SELECT DISTINCT a, b FROM T2) AS T2sub
ON T1.a=T2sub.a AND T1.b=T2sub.b

Errores más comunes:

1. Unirse directamente en T2, sin una subconsulta segura. Resultando en el riesgo de duplicación)
2. SELECT * (Guaranateed para obtener columnas de T2)
3. SELECCIONAR c (no garantiza que su columna venga y siempre venga de T1)
4. No DISTINCT o DISTINCT en el lugar equivocado

CONCATENACIÓN DE COLUMNAS CON SEPARADOR (No muy seguro, rendimiento horrible)

El problema funcional es que si usa un separador que puede aparecer en una columna, se vuelve difícil asegurarse de que el resultado sea 100% exacto. El problema técnico es que este método a menudo incurre en conversiones de tipos e ignora completamente los índices, lo que resulta en un rendimiento posiblemente horrible. A pesar de estos problemas, tengo que admitir que a veces todavía lo uso para consultas ad-hoc en pequeños conjuntos de datos.

SELECT * FROM T1
WHERE CONCAT(a,"_",b) IN 
(SELECT CONCAT(a,"_",b) FROM T2)

Tenga en cuenta que si sus columnas son numéricas, algunos dialectos SQL requerirán que los convierta primero en cadenas. Creo que el servidor SQL hará esto automáticamente.

Para concluir: Como es habitual, hay muchas maneras de hacer esto en SQL, usar opciones seguras evitará sorpresas y le ahorrará tiempo y dolores de cabeza a largo plazo.

select * from tab1 where (col1,col2) in (select col1,col2 from tab2)

Nota:
Oracle ignora las filas donde una o más de las columnas seleccionadas son NULL. En estos casos, es probable que desee hacer uso de la NVL -Funktion para asignar NULL a un valor especial (que no debería ser en los valores);

select * from tab1
where (col1, NVL(col2, '---') in (select col1, NVL(col2, '---') from tab2)

Una simple cláusula EXISTS es más limpia

select *
from table1 t1
WHERE
EXISTS
(
 Select * --or 1. No difference...
 From CRM_VCM_CURRENT_LEAD_STATUS Ex
 Where Lead_Key = :_Lead_Key
-- correlation here...
AND
t1.CM_PLAN_ID = Ex.CM_PLAN_ID AND t1.CM_PLAN_ID =  Ex.Individual_ID
)

Si tiene varias filas en la correlación, entonces JOIN proporciona varias filas en la salida, por lo que necesitaría distintas. Lo que generalmente hace que los EXISTS sean más eficientes.

La nota SELECT *con JOIN también incluiría columnas de las tablas de limitación de filas

¿Por qué usar WHERE EXISTS o DERIVED TABLES cuando puedes hacer una unión interna normal?

SELECT t.*
FROM table1 t
INNER JOIN CRM_VCM_CURRENT_LEAD_STATUS s
    ON t.CM_PLAN_ID = s.CM_PLAN_ID
    AND t.Individual_ID = s.Individual_ID
WHERE s.Lead_Key = :_Lead_Key

Si el par de (CM_PLAN_ID, Individual_ID) no es único en la tabla de estado, es posible que necesite un SELECT DISTINCT t. * En su lugar.

Postgres SQL  : version 9.6
Total records on tables : mjr_agent = 145, mjr_transaction_item = 91800

1.Uso con EXISTS[Tiempo promedio de consulta: 1.42s]

SELECT count(txi.id) 
FROM 
mjr_transaction_item txi
WHERE 
EXISTS ( SELECT 1 FROM mjr_agent agnt WHERE agnt.agent_group = 0 AND (txi.src_id = agnt.code OR txi.dest_id = agnt.code) ) 

2.Uso con dos líneas INCláusula [Tiempo promedio de consulta: 0.37s]

SELECT count(txi.id) FROM mjr_transaction_item txi
WHERE 
txi.src_id IN ( SELECT agnt.code FROM mjr_agent agnt WHERE agnt.agent_group = 0 ) 
OR txi.dest_id IN ( SELECT agnt.code FROM mjr_agent agnt WHERE agnt.agent_group = 0 )

3.Utilizando con INNNER JOINpatrón [Tiempo promedio de consulta: 2.9s]

SELECT count(DISTINCT(txi.id)) FROM mjr_transaction_item txi
INNER JOIN mjr_agent agnt ON agnt.code = txi.src_id OR agnt.code = txi.dest_id
WHERE 
agnt.agent_group = 0

Entonces, elegí la segunda opción.

Consulta:

select ord_num, agent_code, ord_date, ord_amount
from orders
where (agent_code, ord_amount) IN
(SELECT agent_code, MIN(ord_amount)
FROM orders 
GROUP BY agent_code);

la consulta anterior funcionó para mí en mysql. consulte el siguiente enlace ->

https://www.w3resource.com/sql/subqueries/multiplee-row-column-subqueries.php

Si desea una tabla, use la siguiente consulta

SELECT S.* 
FROM Student_info S
  INNER JOIN Student_info UT
    ON S.id = UT.id
    AND S.studentName = UT.studentName
where S.id in (1,2) and S.studentName in ('a','b')

y datos de la tabla de la siguiente manera

id|name|adde|city
1   a   ad  ca
2   b   bd  bd
3   a   ad  ad
4   b   bd  bd
5   c   cd  cd

Luego salida como sigue

id|name|adde|city
1   a   ad  ca
2   b   bd  bd

Simplemente podemos hacer esto.

   select *
   from 
    table1 t, CRM_VCM_CURRENT_LEAD_STATUS c
    WHERE  t.CM_PLAN_ID = c.CRM_VCM_CURRENT_LEAD_STATUS
    and t.Individual_ID = c.Individual_ID

Concatenar las columnas juntas de alguna forma es un "truco", pero cuando el producto no admite semiuniones para más de una columna, a veces no tiene otra opción.

Ejemplo de dónde la solución de unión interna / externa no funcionaría:

select * from T1 
 where <boolean expression>
   and (<boolean expression> OR (ColA, ColB) in (select A, B ...))
   and <boolean expression>
   ...

Cuando las consultas no son triviales por naturaleza, a veces no tiene acceso a la tabla base configurada para realizar uniones internas / externas regulares.

Si utiliza este "pirateo", cuando combine campos, asegúrese de agregar suficiente delimitador entre ellos para evitar interpretaciones erróneas, p. Ej. ColA + ":-:" + ColB

Funcioné más fácil de esta manera

Select * 
from table1 
WHERE  (convert(VARCHAR,CM_PLAN_ID) + convert(VARCHAR,Individual_ID)) 
IN 
(
 Select convert(VARCHAR,CM_PLAN_ID) + convert(VARCHAR,Individual_ID)
 From CRM_VCM_CURRENT_LEAD_STATUS 
 Where Lead_Key = :_Lead_Key 
) 

Espero que esto ayude :)

La forma simple e incorrecta sería combinar dos columnas usando + o concatenar y hacer una columna.

Select *
from XX
where col1+col2 in (Select col1+col2 from YY)

Esto sería, por supuesto, bastante lento. No se puede usar en la programación, pero si está en el caso de que solo esté buscando verificar, se puede usar algo.