SQL WHERE .. IN子句多列

时间：2009-07-16 07:39:47

标签： sql-server

我需要在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
)

但WHERE..IN子句只允许1列。如何将2个或更多列与另一个内部SELECT进行比较？

13 个答案:

答案 0 :(得分：114)

您将要使用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)

答案 1 :(得分：101)

您可以从子查询中创建派生表，并将table1连接到此派生表：

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

答案 2 :(得分：12)

简单的EXISTS条款是最简洁的

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
)

如果相关中有多行，则JOIN会在输出中显示多行，因此您需要使用不同的行。这通常会使EXISTS更有效率。

注意带有JOIN的“SELECT”*还包括行限制表中的列

答案 3 :(得分：7)

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

注意：
Oracle忽略其中一个或多个所选列为NULL的行。在这些情况下，您可能希望使用NVL - Funktion将NULL映射到特殊值（不应该在值中）; 

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

答案 4 :(得分：4)

关于解决方案的警告：

如果行不是唯一的，许多现有解决方案将提供错误的输出结果

如果您是唯一创建表的人，那么这可能无关紧要，但是当其中一个表可能不包含唯一行时，几种解决方案将提供与所讨论代码不同数量的输出行。

关于问题陈述的警告：

不存在多个列，请仔细考虑您想要的内容

当我看到包含两列的in时，我可以想象它意味着两件事：

  1. a列和b列的值独立出现在另一个表中
  2. a列和b列的值一起出现在另一个表的同一行中

方案1相当简单，只需使用两个IN语句即可。

与大多数现有答案一致，我在此概述方案2（以及简要判断）中提到的方法和其他方法：

EXISTS（安全，建议用于SQL Server）

@mrdenny提供的EXISTS听起来完全符合您的要求，这是他的示例：

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

左半联接（安全，建议使用支持它的方言）

这是一种非常简洁的连接方式，但是不幸的是，大多数SQL方言，包括SQL Server，目前都不支持它。

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

多个IN语句（安全，但是要注意代码重复）

正如@cataclysm所提到的，使用两个IN语句也可以解决问题，也许它甚至会胜过其他解决方案。但是，您应该非常小心的是代码重复。如果您想从其他表中进行选择，或者更改where语句，则可能会增加逻辑上不一致的风险。

基本解决方案 

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

没有代码重复的解决方案（我相信这在常规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)

INNER JOIN（从技术上讲可以保证安全，但通常这样做没有做到）

我不建议使用内部联接作为过滤器的原因是，在实践中，人们经常让右表中的重复项导致左表中的重复项。然后使情况更糟的是，它们有时会使最终结果与众不同，而实际上左表可能不需要唯一（或在您选择的列中不是唯一的）。此外，它还使您有机会实际选择左表中不存在的列。

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

最常见的错误：

  1. 直接加入T2，无需安全的子查询。导致重复的风险）
  2. SELECT *（保证从T2中获取列）
  3. SELECT c（不保证您的列始终来自T1）
  4. 没有DISTINCT或DISTINCT在错误的地方

使用分隔符对列进行填充（不是很安全，性能很差）

功能上的问题是，如果使用可能在列中出现的分隔符，则很难确保结果是100％准确的。技术上的问题是此方法通常会导致类型转换，并且会完全忽略索引，从而可能导致可怕的性能。 尽管存在这些问题，但我不得不承认，有时我仍将其用于小型数据集的临时查询。

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

请注意，如果您的列是数字列，则某些SQL方言将要求您首先将它们转换为字符串。我相信SQL Server会自动执行此操作。

总结一下：像往常一样，在SQL中有很多方法可以做到这一点，使用安全的选择可以避免意外情况，从长远来看可以节省时间和麻烦。

答案 5 :(得分：2)

为什么在可以进行正常的内连接时使用WHERE EXISTS或DERIVED TABLES：

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

如果状态表中的（CM_PLAN_ID，Individual_ID）对不唯一，则可能需要SELECT DISTINCT t。*。

答案 6 :(得分：0)

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

1。与EXISTS一起使用[平均查询时间：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。使用两行IN子句[平均查询时间：0.37秒] 

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。使用INNNER JOIN模式[平均查询时间：2.9秒] 

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

所以，我选择了第二个选项。

答案 7 :(得分：-1)

如果您想要一张桌子，请使用以下查询

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

和表格数据如下

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

然后输出如下

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

答案 8 :(得分：-1)

查询：

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

上面的查询在mysql中为我工作。 请参阅以下链接 - ＆gt;

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

答案 9 :(得分：-1)

以某种形式将列连接在一起是“黑客”，但是当产品不支持多个列的半连接时，有时您别无选择。

内/外连接解决方​​案不起作用的示例：

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

当查询本质上不是微不足道的时候，有时您无法访问基表集来执行常规的内/外连接。

如果你使用这个“黑客”，当你组合字段时，一定要在它们之间添加足够的分隔符以避免误解，例如： ColA + ":-:" + ColB

答案 10 :(得分：-2)

我们可以简单地这样做。 

   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

答案 11 :(得分：-3)

我用这种方式创建了

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 
)

希望这有帮助：）

答案 12 :(得分：-4)

简单和错误的方法是使用+或连接组合两列并创建一列。

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

这将是非常缓慢的。不能用于编程，但如果您只是查询验证可能会使用的东西。

相关问题
最新问题