Muszę zaimplementować następujące zapytanie w 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
)

Ale klauzula WHERE..IN zezwala tylko na 1 kolumnę. Jak mogę porównać 2 lub więcej kolumn z innym wewnętrznym SELECT?

Możesz utworzyć tabelę pochodną z podzapytania i połączyć tabelę table1 z tą tabelą pochodną:

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

Zamiast tego będziesz chciał użyć składni 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)

OSTRZEŻENIE DOTYCZĄCE ROZWIĄZAŃ:

WIELE ISTNIEJĄCYCH ROZWIĄZAŃ DAJE NIEPRAWIDŁOWE WYDAJNOŚĆ, JEŚLI WIERSZE NIE SĄ WYJĄTKOWE

Jeśli jesteś jedyną osobą tworzącą tabele, może to nie mieć znaczenia, ale kilka rozwiązań da inną liczbę wierszy wyjściowych z danego kodu, gdy jedna z tabel może nie zawierać unikalnych wierszy.

OSTRZEŻENIE DOTYCZĄCE PROBLEMU:

W PRZYPADKU WIELU KOLUMN NIE ISTNIEJE, UWAŻNIE PRZEMYŚL, CO CHCESZ

Kiedy widzę wejście z dwiema kolumnami, wyobrażam sobie, że oznacza to dwie rzeczy:

1. Wartości z kolumny a i kolumny b pojawiają się niezależnie w drugiej tabeli
2. Wartości z kolumny a i kolumny b pojawiają się w drugiej tabeli razem w tym samym wierszu

Scenariusz 1 jest dość trywialny, po prostu użyj dwóch instrukcji IN.

Zgodnie z większością istniejących odpowiedzi, niniejszym przedstawiam przegląd wspomnianych i dodatkowych podejść do scenariusza 2 (oraz krótką ocenę):

ISTNIEJE (bezpieczne, zalecane dla SQL Server)

Jak zapewnia @mrdenny, EXISTS brzmi dokładnie tak, jak szukasz, oto jego przykład:

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

LEFT SEMI JOIN (Bezpieczne, zalecane dla dialektów, które go obsługują)

Jest to bardzo zwięzły sposób dołączania, ale niestety większość dialektów SQL, w tym serwer SQL, obecnie go nie obsługuje.

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

Wiele instrukcji IN (bezpieczne, ale uważaj na powielanie kodu)

Jak wspomniał @cataclysm, użycie dwóch instrukcji IN również może załatwić sprawę, być może nawet przewyższy inne rozwiązania. Jednak należy być bardzo ostrożnym przy powielaniu kodu. Jeśli kiedykolwiek zechcesz wybrać z innej tabeli lub zmienić instrukcję where, istnieje zwiększone ryzyko, że stworzysz niespójności w swojej logice.

Podstawowe rozwiązanie

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

Rozwiązanie bez duplikacji kodu (uważam, że to nie działa w zwykłych zapytaniach 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)

WEWNĘTRZNE JOIN (technicznie można to zabezpieczyć, ale często się tego nie robi)

Powodem, dla którego nie polecam używania sprzężenia wewnętrznego jako filtru, jest to, że w praktyce ludzie często pozwalają, aby duplikaty w prawej tabeli powodowały duplikaty w lewej tabeli. Co gorsza, czasami sprawiają, że wynik końcowy jest inny, podczas gdy lewa tabela może nie być unikalna (lub nie jest unikalna w wybranych kolumnach). Co więcej, daje Ci możliwość faktycznego wybrania kolumny, której nie ma w lewej tabeli.

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

Najczęstsze błędy:

1. Łączenie bezpośrednio na T2, bez bezpiecznego podzapytania. Prowadzi to do ryzyka powielania)
2. SELECT * (gwarantowane pobranie kolumn z T2)
3. SELECT c (nie gwarantuje, że Twoja kolumna pochodzi i zawsze będzie pochodzić z T1)
4. Żadnego DISTINCT lub DISTINCT w niewłaściwym miejscu

ZŁĄCZENIE KOLUMN Z SEPARATOREM (Niezbyt bezpieczne, straszne wykonanie)

Problem funkcjonalny polega na tym, że jeśli użyjesz separatora, który może wystąpić w kolumnie, trudno jest upewnić się, że wynik jest w 100% dokładny. Problem techniczny polega na tym, że ta metoda często powoduje konwersję typów i całkowicie ignoruje indeksy, co skutkuje prawdopodobnie okropną wydajnością. Mimo tych problemów muszę przyznać, że czasami nadal używam go do zapytań ad-hoc na małych zbiorach danych.

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

Zwróć uwagę, że jeśli kolumny są numeryczne, niektóre dialekty SQL będą wymagały najpierw rzutowania ich na łańcuchy. Uważam, że serwer SQL zrobi to automatycznie.

Podsumowując: jak zwykle w SQL jest wiele sposobów, aby to zrobić, używanie bezpiecznych wyborów pozwoli uniknąć niespodzianek i zaoszczędzić czas i na dłuższą metę.

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

Uwaga:
Oracle ignoruje wiersze, w których co najmniej jedna z wybranych kolumn ma wartość NULL. W takich przypadkach prawdopodobnie będziesz chciał użyć NVL -Funktion do odwzorowania NULL na specjalną wartość (która nie powinna znajdować się w wartościach);

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

Prosta klauzula EXISTS jest najczystsza

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
)

Jeśli masz wiele wierszy w korelacji, wówczas JOIN daje wiele wierszy w wyniku, więc potrzebujesz różnych. Co zwykle sprawia, że ​​ISTNIEJE bardziej wydajne.

Uwaga SELECT *z JOIN obejmowałaby również kolumny z tabel ograniczających wiersze

Po co używać GDZIE ISTNIEJE lub POCHODZONE TABELE, skoro można po prostu wykonać zwykłe sprzężenie wewnętrzne:

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

Jeśli para (CM_PLAN_ID, Individual_ID) nie jest unikalna w tabeli statusów, możesz potrzebować zamiast tego SELECT DISTINCT t. *.

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

1.Używanie z EXISTS[Średni czas zapytania: 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. Używanie z dwoma wierszami INKlauzula [średni czas zapytania: 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.Używanie z INNNER JOINwzorcem [średni czas zapytania: 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

Więc wybrałem drugą opcję.

Pytanie:

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

powyższe zapytanie działało dla mnie w mysql. zobacz poniższy link ->

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

Jeśli chcesz dla jednej tabeli, użyj następującego zapytania

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

i dane w tabeli, jak następuje

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

Następnie wypisz w następujący sposób

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

Możemy to po prostu zrobić.

   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

Łączenie kolumn ze sobą w jakiejś formie to „hack”, ale jeśli produkt nie obsługuje łączeń połowicznych dla więcej niż jednej kolumny, czasami nie masz wyboru.

Przykład sytuacji, w której połączenie wewnętrzne / zewnętrzne nie zadziała:

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

Gdy zapytania nie są z natury trywialne, czasami nie masz dostępu do tabeli podstawowej ustawionej na wykonywanie zwykłych sprzężeń wewnętrznych / zewnętrznych.

Jeśli korzystasz z tego „hackowania”, podczas łączenia pól po prostu upewnij się, że dodałeś wystarczająco dużo separatora między nimi, aby uniknąć błędnych interpretacji, np. ColA + ":-:" + ColB

W ten sposób założyłem łatwiej

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 
) 

Mam nadzieję, że to pomoże :)

Prostym i złym sposobem byłoby połączenie dwóch kolumn za pomocą + lub konkatenacja i utworzenie jednej kolumny.

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

To byłoby całkiem powolne. Nie może być używany w programowaniu, ale jeśli pytasz tylko o weryfikację, może być użyty.