从几列中选择最小值的最佳方法是什么？

给定SQL Server 2005中的下表：

ID   Col1   Col2   Col3
--   ----   ----   ----
1       3     34     76  
2      32    976     24
3       7    235      3
4     245      1    792

编写产生以下结果的查询的最佳方法是什么（即产生最后一列的查询-该列包含每一行的Col1，Col2和Col 3中的最小值）？

ID   Col1   Col2   Col3  TheMin
--   ----   ----   ----  ------
1       3     34     76       3
2      32    976     24      24
3       7    235      3       3
4     245      1    792       1

更新：

为了澄清（如我在前面的评论中所述），在实际场景中对数据库进行了适当的规范化。这些“数组”列不在实际表中，而是在报告中所需的结果集中。并且新的要求是报表还需要此MinValue列。我无法更改基础结果集，因此我一直在寻找T-SQL来获得方便的“走出监狱卡”。

我尝试了下面提到的CASE方法，尽管有些麻烦，但它可以工作。它也比答案中说明的还要复杂，因为您需要考虑到同一行中有两个最小值的事实。

无论如何，我认为我应该发布当前的解决方案，考虑到我的限制，该解决方案效果很好。它使用UNPIVOT运算符：

with cte (ID, Col1, Col2, Col3)
as
(
    select ID, Col1, Col2, Col3
    from TestTable
)
select cte.ID, Col1, Col2, Col3, TheMin from cte
join
(
    select
        ID, min(Amount) as TheMin
    from 
        cte 
        UNPIVOT (Amount for AmountCol in (Col1, Col2, Col3)) as unpvt
    group by ID
) as minValues
on cte.ID = minValues.ID

我先要说的是，我不希望它提供最佳的性能，但是在特定情况下（我不能仅针对新的MinValue列要求重新设计所有查询），这是一个非常优雅的“摆脱困境”卡”。

可能有很多方法可以完成此任务。我的建议是使用案例/何时进行。3列，还不错。

Select Id,
       Case When Col1 < Col2 And Col1 < Col3 Then Col1
            When Col2 < Col1 And Col2 < Col3 Then Col2 
            Else Col3
            End As TheMin
From   YourTableNameHere

使用CROSS APPLY：

SELECT ID, Col1, Col2, Col3, MinValue
FROM YourTable
CROSS APPLY (SELECT MIN(d) AS MinValue FROM (VALUES (Col1), (Col2), (Col3)) AS a(d)) A

SQL小提琴

SELECT ID, Col1, Col2, Col3, 
    (SELECT MIN(Col) FROM (VALUES (Col1), (Col2), (Col3)) AS X(Col)) AS TheMin
FROM Table

在MySQL上，使用以下命令：

select least(col1, col2, col3) FROM yourtable

您可以使用“蛮力”方法来扭转：

SELECT CASE
    WHEN Col1 <= Col2 AND Col1 <= Col3 THEN Col1
    WHEN                  Col2 <= Col3 THEN Col2
    ELSE                                    Col3
END AS [Min Value] FROM [Your Table]

当第一个条件失败时，它保证Col1不是最小值，因此您可以从其余条件中消除它。对于后续条件也是如此。对于五列，您的查询变为：

SELECT CASE
    WHEN Col1 <= Col2 AND Col1 <= Col3 AND Col1 <= Col4 AND Col1 <= Col5 THEN Col1
    WHEN                  Col2 <= Col3 AND Col2 <= Col4 AND Col2 <= Col5 THEN Col2
    WHEN                                   Col3 <= Col4 AND Col3 <= Col5 THEN Col3
    WHEN                                                    Col4 <= Col5 THEN Col4
    ELSE                                                                      Col5
END AS [Min Value] FROM [Your Table]

请注意，如果两列或更多列之间存在联系，请<=确保我们CASE尽早退出该语句。

如果列是整数（如您的示例中所示），我将创建一个函数：

create function f_min_int(@a as int, @b as int) 
returns int
as
begin
    return case when @a < @b then @a else coalesce(@b,@a) end
end

然后，当我需要使用它时，我会做：

select col1, col2, col3, dbo.f_min_int(dbo.f_min_int(col1,col2),col3)

如果您有5个专栏，则以上内容变为

select col1, col2, col3, col4, col5,
dbo.f_min_int(dbo.f_min_int(dbo.f_min_int(dbo.f_min_int(col1,col2),col3),col4),col5)

做到这一点的最好方法可能是不这样做-奇怪的是，人们坚持以要求SQL“体操”提取有意义信息的方式存储数据，而如果您只是想获得所需结果的简便得多的方法，更好地组织架构：-)

在正确的做到这一点的方式，在我看来，是下面的表有：

ID    Col    Val
--    ---    ---
 1      1      3
 1      2     34
 1      3     76

 2      1     32
 2      2    976
 2      3     24

 3      1      7
 3      2    235
 3      3      3

 4      1    245
 4      2      1
 4      3    792

与ID/Col作为主键（也可能Col作为一个额外的键，根据您的需要）。这样您的查询就变得很简单select min(val) from tbl，您仍然可以通过where col = 2在其他查询中使用单独对待各个“旧列” 。如果“旧列”的数量增加，这也允许轻松扩展。

这使您的查询变得如此简单。一般准则我倾向于使用，如果你曾经有东西，看起来像在一个数据库行的一个数组，你可能做错事，应该考虑重组数据。

但是，如果由于某种原因您无法更改这些列，建议您使用插入和更新触发器，并添加另一列，这些触发器将其设置为on的最小值Col1/2/3。这会将操作的“成本”从选择移到其所属的更新/插入-根据我的经验，大多数数据库表的读取频率远高于写入的频率，因此随着时间的流逝，写入的成本往往会更高。

换句话说，最低为一排，当其他列的一个变化只改变，所以这就是当你在每一次选择时间（如果数据不改变被浪费）来计算它，而不是。然后，您将得到一个像这样的表：

ID   Col1   Col2   Col3   MinVal
--   ----   ----   ----   ------
 1      3     34     76        3
 2     32    976     24       24
 3      7    235      3        3
 4    245      1    792        1

任何其他必须同时做出决定的选项select通常都不是性能上的好主意，因为数据仅在插入/更新时发生更改-添加另一列会占用数据库中的更多空间，并且插入和复制的速度会稍慢更新但可以多为选择快-首选的方法应该取决于你的重点有，但，如上所述，大多数表是只读远远往往比他们写的。

您也可以使用联合查询来执行此操作。随着列数的增加，您将需要修改查询，但至少这将是直接的修改。

Select T.Id, T.Col1, T.Col2, T.Col3, A.TheMin
From   YourTable T
       Inner Join (
         Select A.Id, Min(A.Col1) As TheMin
         From   (
                Select Id, Col1
                From   YourTable

                Union All

                Select Id, Col2
                From   YourTable

                Union All

                Select Id, Col3
                From   YourTable
                ) As A
         Group By A.Id
       ) As A
       On T.Id = A.Id

这是蛮力但有效

 select case when col1 <= col2 and col1 <= col3 then col1
           case when col2 <= col1 and col2 <= col3 then col2
           case when col3 <= col1 and col3 <= col2 then col3
    as 'TheMin'
           end

from Table T

...因为min（）仅作用于一列，而不作用于各列。

无论这个问题， 而这个问题，试图回答这个问题。

回顾一下，Oracle为此提供了一个内置函数，而使用Sql Server，您将无法定义用户定义函数或使用case语句。

对于多列，最好使用CASE语句，但是对于两个数字列i和j，可以使用简单的数学运算：

min（i，j）=（i + j）/ 2-abs（ij）/ 2

该公式可用于获取多列的最小值，但它在2以后确实很混乱，min（i，j，k）将是min（i，min（j，k））

如果您能够创建一个存储过程，则它可以采用一个值数组，而您可以调用它。

select *,
case when column1 < columnl2 And column1 < column3 then column1
when columnl2 < column1 And columnl2 < column3 then columnl2
else column3
end As minValue
from   tbl_example

联合查询有些许错误：

DECLARE @Foo TABLE (ID INT, Col1 INT, Col2 INT, Col3 INT)

INSERT @Foo (ID, Col1, Col2, Col3)
VALUES
(1, 3, 34, 76),
(2, 32, 976, 24),
(3, 7, 235, 3),
(4, 245, 1, 792)

SELECT
    ID,
    Col1,
    Col2,
    Col3,
    (
        SELECT MIN(T.Col)
        FROM
        (
            SELECT Foo.Col1 AS Col UNION ALL
            SELECT Foo.Col2 AS Col UNION ALL
            SELECT Foo.Col3 AS Col 
        ) AS T
    ) AS TheMin
FROM
    @Foo AS Foo

如果使用SQL 2005，则可以执行以下整洁的操作：

;WITH    res
          AS ( SELECT   t.YourID ,
                        CAST(( SELECT   Col1 AS c01 ,
                                        Col2 AS c02 ,
                                        Col3 AS c03 ,
                                        Col4 AS c04 ,
                                        Col5 AS c05
                               FROM     YourTable AS cols
                               WHERE    YourID = t.YourID
                             FOR
                               XML AUTO ,
                                   ELEMENTS
                             ) AS XML) AS colslist
               FROM     YourTable AS t
             )
    SELECT  YourID ,
            colslist.query('for $c in //cols return min(data($c/*))').value('.',
                                            'real') AS YourMin ,
            colslist.query('for $c in //cols return avg(data($c/*))').value('.',
                                            'real') AS YourAvg ,
            colslist.query('for $c in //cols return max(data($c/*))').value('.',
                                            'real') AS YourMax
    FROM    res

这样，您就不会在那么多运算符中迷失方向：)

但是，这可能比其他选择要慢。

这是你的选择...

下面，我使用一个临时表来获取最少的几个日期。第一个临时表查询几个联接的表以获取各种日期（以及查询的其他值），第二个临时表然后使用与日期列一样多的遍历获取各种列和最小日期。

从本质上讲，这类似于联合查询，需要通过的次数相同，但可能会更有效（基于经验，但需要测试）。在这种情况下，效率不是问题（8,000条记录）。一个可以索引等

--==================== this gets minimums and global min
if object_id('tempdb..#temp1') is not null
    drop table #temp1
if object_id('tempdb..#temp2') is not null
    drop table #temp2

select r.recordid ,  r.ReferenceNumber, i.InventionTitle, RecordDate, i.ReceivedDate
, min(fi.uploaddate) [Min File Upload], min(fi.CorrespondenceDate) [Min File Correspondence]
into #temp1
from record r 
join Invention i on i.inventionid = r.recordid
left join LnkRecordFile lrf on lrf.recordid = r.recordid
left join fileinformation fi on fi.fileid = lrf.fileid
where r.recorddate > '2015-05-26'
 group by  r.recordid, recorddate, i.ReceivedDate,
 r.ReferenceNumber, i.InventionTitle



select recordid, recorddate [min date]
into #temp2
from #temp1

update #temp2
set [min date] = ReceivedDate 
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.ReceivedDate < [min date] and  t1.ReceivedDate > '2001-01-01'

update #temp2 
set [min date] = t1.[Min File Upload]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.[Min File Upload] < [min date] and  t1.[Min File Upload] > '2001-01-01'

update #temp2
set [min date] = t1.[Min File Correspondence]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.[Min File Correspondence] < [min date] and t1.[Min File Correspondence] > '2001-01-01'


select t1.*, t2.[min date] [LOWEST DATE]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
order by t1.recordid

SELECT [ID],
            (
                SELECT MIN([value].[MinValue])
                FROM
                (
                    VALUES
                        ([Col1]),
                        ([Col1]),
                        ([Col2]),
                        ([Col3])
                ) AS [value] ([MinValue])
           ) AS [MinValue]
FROM Table;

如果您知道要查找的值（通常是状态码），则以下内容可能会有所帮助：

select case when 0 in (PAGE1STATUS ,PAGE2STATUS ,PAGE3STATUS,
PAGE4STATUS,PAGE5STATUS ,PAGE6STATUS) then 0 else 1 end
FROM CUSTOMERS_FORMS

我知道这个问题很旧，但是我仍然需要答案，并且对其他答案不满意，因此我不得不设计自己的答案，这与@paxdiablo的答案有所不同。

我来自SAP ASE 16.0，只需要看一下IMHO有效存储在单行不同列中的某些数据的统计信息（它们表示不同的时间-计划到达的时间，预期的到达时间）动作开始了，最后才是实际时间。因此，我已经将列转换为临时表的行，并像往常一样对此执行查询。

注意：不是前面的“一刀切”的解决方案！

CREATE TABLE #tempTable (ID int, columnName varchar(20), dataValue int)

INSERT INTO #tempTable 
  SELECT ID, 'Col1', Col1
    FROM sourceTable
   WHERE Col1 IS NOT NULL
INSERT INTO #tempTable 
  SELECT ID, 'Col2', Col2
    FROM sourceTable
   WHERE Col2 IS NOT NULL
INSERT INTO #tempTable 
  SELECT ID, 'Col3', Col3
    FROM sourceTable
   WHERE Col3 IS NOT NULL

SELECT ID
     , min(dataValue) AS 'Min'
     , max(dataValue) AS 'Max'
     , max(dataValue) - min(dataValue) AS 'Diff' 
  FROM #tempTable 
  GROUP BY ID

这在630000行的源集上花费了大约30秒，并且仅使用索引数据，因此不是要在时间紧迫的过程中运行，而是要进行一次性数据检查或日末报告等操作很好（但请与您的同行或上级进行验证！）。这种风格的主要奖金对我来说是，我可以很容易地使用更多/更少列和改变分组，过滤等，特别是一旦数据copyied过来。

其他数据（columnName，maxes，...）是为了帮助我进行搜索，因此您可能不需要它们。我把它们留在这里也许是引起一些想法的:-)。