Ich muss die folgende Abfrage in SQL Server implementieren:

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
)

Die WHERE..IN-Klausel erlaubt jedoch nur eine Spalte. Wie kann ich 2 oder mehr Spalten mit einem anderen inneren SELECT vergleichen?

Sie können aus der Unterabfrage eine abgeleitete Tabelle erstellen und table1 mit dieser abgeleiteten Tabelle verknüpfen:

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

Sie sollten stattdessen die WHERE EXISTS-Syntax verwenden.

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)

WARNUNG ZU LÖSUNGEN:

VIELE BESTEHENDE LÖSUNGEN GEBEN DIE FALSCHE AUSGABE, WENN REIHEN NICHT EINZIGARTIG SIND

Wenn Sie die einzige Person sind, die Tabellen erstellt, ist dies möglicherweise nicht relevant. Mehrere Lösungen geben jedoch eine andere Anzahl von Ausgabezeilen als der betreffende Code an, wenn eine der Tabellen möglicherweise keine eindeutigen Zeilen enthält.

WARNUNG ÜBER DIE PROBLEMSTELLUNG:

IN MIT MEHREREN SPALTEN GIBT ES NICHT, DENKEN SIE SORGFÄLTIG, WAS SIE WOLLEN

Wenn ich ein In mit zwei Spalten sehe, kann ich mir vorstellen, dass es zwei Dinge bedeutet:

1. Der Wert von Spalte a und Spalte b wird unabhängig voneinander in der anderen Tabelle angezeigt
2. Die Werte von Spalte a und Spalte b werden in der anderen Tabelle zusammen in derselben Zeile angezeigt

Szenario 1 ist ziemlich trivial. Verwenden Sie einfach zwei IN-Anweisungen.

In Übereinstimmung mit den meisten vorhandenen Antworten gebe ich hiermit einen Überblick über die genannten und zusätzlichen Ansätze für Szenario 2 (und eine kurze Beurteilung):

EXISTS (sicher, empfohlen für SQL Server)

Wie von @mrdenny bereitgestellt, klingt EXISTS genau so, wie Sie es suchen. Hier ist sein Beispiel:

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

LEFT SEMI JOIN (Sicher, empfohlen für Dialekte, die dies unterstützen)

Dies ist eine sehr prägnante Art des Beitritts, aber leider unterstützen die meisten SQL-Dialekte, einschließlich SQL Server, dies derzeit nicht.

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

Mehrere IN-Anweisungen (sicher, aber Vorsicht vor Codeduplizierungen)

Wie von @cataclysm erwähnt, kann die Verwendung von zwei IN-Anweisungen ebenfalls den Trick ausführen. Vielleicht übertrifft es sogar die anderen Lösungen. Was Sie jedoch sehr vorsichtig sein sollten, ist die Codeduplizierung. Wenn Sie jemals aus einer anderen Tabelle auswählen oder die where-Anweisung ändern möchten, besteht ein erhöhtes Risiko, dass Sie Inkonsistenzen in Ihrer Logik erzeugen.

Grundlösung

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

Lösung ohne Codeduplizierung (Ich glaube, dies funktioniert nicht in regulären SQL Server-Abfragen)

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)

INNER JOIN (technisch kann es sicher gemacht werden, aber oft wird dies nicht getan)

Der Grund, warum ich die Verwendung eines inneren Joins als Filter nicht empfehle, liegt darin, dass in der Praxis häufig Duplikate in der rechten Tabelle Duplikate in der linken Tabelle verursachen. Und um die Sache noch schlimmer zu machen, wird das Endergebnis manchmal deutlich, während die linke Tabelle möglicherweise nicht eindeutig sein muss (oder in den ausgewählten Spalten nicht eindeutig sein muss). Darüber hinaus haben Sie die Möglichkeit, eine Spalte auszuwählen, die in der linken Tabelle nicht vorhanden ist.

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

Häufigste Fehler:

1. Direkter Beitritt zu T2 ohne sichere Unterabfrage. Dies führt zu einem Risiko der Vervielfältigung.
2. SELECT * (Garantiert, um Spalten von T2 zu erhalten)
3. SELECT c (Garantiert nicht, dass Ihre Spalte von T1 kommt und immer kommt)
4. Kein DISTINCT oder DISTINCT am falschen Ort

KONKATENATION VON SPALTEN MIT SEPARATOR (Nicht sehr sichere, schreckliche Leistung)

Das Funktionsproblem besteht darin, dass es schwierig wird, sicherzustellen, dass das Ergebnis 100% genau ist, wenn Sie ein Trennzeichen verwenden, das in einer Spalte auftreten kann. Das technische Problem besteht darin, dass diese Methode häufig Typkonvertierungen durchführt und Indizes vollständig ignoriert, was zu einer möglicherweise schrecklichen Leistung führt. Trotz dieser Probleme muss ich zugeben, dass ich es manchmal immer noch für Ad-hoc-Abfragen in kleinen Datensätzen verwende.

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

Wenn Ihre Spalten numerisch sind, müssen Sie sie bei einigen SQL-Dialekten zuerst in Zeichenfolgen umwandeln. Ich glaube, SQL Server wird dies automatisch tun.

Zum Abschluss: Wie üblich gibt es in SQL viele Möglichkeiten, dies zu tun. Wenn Sie sichere Entscheidungen treffen, vermeiden Sie Überraschungen und sparen auf lange Sicht Zeit und Kopfzerbrechen.

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

Hinweis:
Oracle ignoriert Zeilen, in denen eine oder mehrere der ausgewählten Spalten NULL sind. In diesen Fällen möchten Sie wahrscheinlich die NVL- Funktion verwenden, um NULL einem speziellen Wert zuzuordnen (der nicht in den Werten enthalten sein sollte).

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

Eine einfache EXISTS-Klausel ist am saubersten

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
)

Wenn Sie mehrere Zeilen in der Korrelation haben, gibt ein JOIN mehrere Zeilen in der Ausgabe an, sodass Sie unterschiedliche Zeilen benötigen. Das macht die EXISTS normalerweise effizienter.

Hinweis SELECT *mit einem JOIN würde auch Spalten aus den Zeilenbegrenzungstabellen enthalten

Warum WHERE EXISTS oder DERIVED TABLES verwenden, wenn Sie nur eine normale innere Verknüpfung durchführen können:

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

Wenn das Paar (CM_PLAN_ID, Individual_ID) in der Statustabelle nicht eindeutig ist, benötigen Sie möglicherweise stattdessen ein SELECT DISTINCT t. *.

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

1.Verwenden mit EXISTS[Durchschnittliche Abfragezeit: 1,42 s]

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.Verwenden mit zwei Zeilen INKlausel [Durchschnittliche Abfragezeit: 0,37 s]

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.Verwenden mit INNNER JOINMuster [Durchschnittliche Abfragezeit: 2,9 s]

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

Also entschied ich mich für die zweite Option.

Abfrage:

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);

Die obige Abfrage hat bei mir in MySQL funktioniert. siehe folgenden Link ->

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

Wenn Sie für eine Tabelle möchten, verwenden Sie die folgende Abfrage

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')

und Tabellendaten wie folgt

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

Dann wie folgt ausgeben

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

Wir können das einfach machen.

   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

Das Verketten der Spalten in irgendeiner Form ist ein "Hack", aber wenn das Produkt keine Semi-Joins für mehr als eine Spalte unterstützt, haben Sie manchmal keine Wahl.

Beispiel dafür, wo eine innere / äußere Verbindungslösung nicht funktionieren würde:

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

Wenn die Abfragen nicht trivialer Natur sind, haben Sie manchmal keinen Zugriff auf die Basistabelle, um regelmäßige innere / äußere Verknüpfungen durchzuführen.

Wenn Sie diesen "Hack" verwenden, müssen Sie beim Kombinieren von Feldern genügend Trennzeichen dazwischen einfügen, um Fehlinterpretationen zu vermeiden, z ColA + ":-:" + ColB

Ich habe auf diese Weise leichter gegründet

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 
) 

Ich hoffe das hilft :)

Ein einfacher und falscher Weg wäre, zwei Spalten mit + zu kombinieren oder zu verketten und eine Spalte zu erstellen.

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

Das wäre natürlich ziemlich langsam. Kann nicht in der Programmierung verwendet werden, aber wenn Sie nur nach einer Überprüfung fragen, kann etwas verwendet werden.