基于 SQL 集的范围答案

【问题标题】：SQL set-based range基于 SQL 集的范围
【发布时间】：2010-09-08 16:13:16
【问题描述】：

如何让 SQL 重复一些基于集合的操作任意次数而不循环？如何让 SQL 对一系列数字执行操作？我基本上是在寻找一种方法来执行基于集合的 for 循环。

我知道我可以创建一个包含整数的小表，比如从 1 到 1000，然后将其用于该范围内的范围操作。

例如，如果我有那个表，我可以像这样进行选择以查找数字 100-200 的总和：

select sum(n) from numbers where n between 100 and 200

有什么想法吗？我有点在寻找适用于 T-SQL 的东西，但任何平台都可以。

[编辑] 我有自己的解决方案，使用 SQL CLR，它适用于 MS SQL 2005 或 2008。See below.

【问题讨论】：

您在这里有很多有趣的答案，但我仍然停留在同一个问题上……您为什么要这样做？如果您需要这种功能，我的猜测是您的目标或系统设计存在错误。（没有苛刻的意思，我真的很想看到一个真正需要使用 sql 的示例）。

标签： sql sql-server

【解决方案1】：

我认为对您的问题的简短回答是使用 WITH 子句生成您自己的子句。

不幸的是，数据库中的大牌并没有内置的可查询数字范围伪表。或者，更一般地说，简单的纯 SQL 数据生成功能。就个人而言，我认为这是一个巨大的失败，因为如果他们这样做了，就有可能移动当前锁定在过程脚本（T-SQL、PL/SQL 等）中的大量代码。 ) 转换为纯 SQL，这对性能和代码复杂性有很多好处。

所以无论如何，从一般意义上来说，您需要的是动态生成数据的能力。

Oracle 和 T-SQL 都支持可用于执行此操作的 WITH 子句。它们在不同的 DBMS 中的工作方式略有不同，MS 称它们为“通用表表达式”，但它们在形式上非常相似。将这些与递归结合使用，您可以相当轻松地生成一系列数字或文本值。这可能是它的样子......

在 Oracle SQL 中：

WITH
  digits AS  -- Limit recursion by just using it for digits.
    (SELECT
      LEVEL - 1 AS num
    FROM
      DUAL
    WHERE
      LEVEL < 10
    CONNECT BY
      num = (PRIOR num) + 1),
  numrange AS
    (SELECT
      ones.num
        + (tens.num * 10)
        + (hundreds.num * 100)
        AS num
    FROM
      digits ones
      CROSS JOIN
        digits tens
      CROSS JOIN
        digits hundreds
    WHERE
      hundreds.num in (1, 2)) -- Use the WHERE clause to restrict each digit as needed.
SELECT
  -- Some columns and operations
FROM
  numrange
  -- Join to other data if needed

这无疑是相当冗长的。 Oracle 的递归功能是有限的。语法很笨拙，性能不佳，并且仅限于 500 个（我认为）嵌套级别。这就是为什么我选择只对前 10 位数字使用递归，然后交叉（笛卡尔）连接将它们组合成实际数字。

我自己没有使用过 SQL Server 的公用表表达式，但由于它们允许自引用，因此递归比 Oracle 中的要简单得多。性能是否具有可比性，以及嵌套限制是什么，我不知道。

无论如何，递归和 WITH 子句在创建需要即时生成的数据集的查询时都是非常有用的工具。然后通过查询这个数据集，对值进行操作，就可以得到各种不同类型的生成数据。聚合、复制、组合、排列等等。您甚至可以使用此类生成的数据来帮助汇总或深入了解其他数据。

更新：我只想补充一点，一旦您开始以这种方式处理数据，您就会对 SQL 的新思维方式敞开心扉。它不仅仅是一种脚本语言。这是一个相当强大的数据驱动declarative language。有时使用起来很痛苦，因为多年来它一直缺乏增强功能来帮助减少复杂操作所需的冗余。但尽管如此，它还是非常强大，并且是一种将数据集作为算法的目标和驱动程序的相当直观的方式。

【讨论】：

我同意这是一个巨大的失败。我发现自己多次需要这种类型的东西并使用循环。

【解决方案2】：

我创建了一个非常适合此目的的 SQL CLR 表值函数。

SELECT n FROM dbo.Range(1, 11, 2) -- returns odd integers 1 to 11
SELECT n FROM dbo.RangeF(3.1, 3.5, 0.1) -- returns 3.1, 3.2, 3.3 and 3.4, but not 3.5 because of float inprecision. !fault(this)

代码如下：

using System;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Collections;

[assembly: CLSCompliant(true)]
namespace Range {
    public static partial class UserDefinedFunctions {
        [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.None, IsDeterministic = true, SystemDataAccess = SystemDataAccessKind.None, IsPrecise = true, FillRowMethodName = "FillRow", TableDefinition = "n bigint")]
        public static IEnumerable Range(SqlInt64 start, SqlInt64 end, SqlInt64 incr) {
            return new Ranger(start.Value, end.Value, incr.Value);
        }

        [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.None, IsDeterministic = true, SystemDataAccess = SystemDataAccessKind.None, IsPrecise = true, FillRowMethodName = "FillRowF", TableDefinition = "n float")]
        public static IEnumerable RangeF(SqlDouble start, SqlDouble end, SqlDouble incr) {
            return new RangerF(start.Value, end.Value, incr.Value);
        }

        public static void FillRow(object row, out SqlInt64 n) {
            n =  new SqlInt64((long)row);
        }

        public static void FillRowF(object row, out SqlDouble n) {
            n = new SqlDouble((double)row);
        }
    }

    internal class Ranger : IEnumerable {
        Int64 _start, _end, _incr;

        public Ranger(Int64 start, Int64 end, Int64 incr) {
            _start = start; _end = end; _incr = incr;
        }

        public IEnumerator GetEnumerator() {
            return new RangerEnum(_start, _end, _incr);
        }
    }

    internal class RangerF : IEnumerable {
        double _start, _end, _incr;

        public RangerF(double start, double end, double incr) {
            _start = start; _end = end; _incr = incr;
        }

        public IEnumerator GetEnumerator() {
            return new RangerFEnum(_start, _end, _incr);
        }
    }

    internal class RangerEnum : IEnumerator {
        Int64 _cur, _start, _end, _incr;
        bool hasFetched = false;

        public RangerEnum(Int64 start, Int64 end, Int64 incr) {
            _start = _cur = start; _end = end; _incr = incr;
            if ((_start < _end ^ _incr > 0) || _incr == 0)
                throw new ArgumentException("Will never reach end!");
        }

        public long Current {
            get { hasFetched = true; return _cur; }
        }

        object IEnumerator.Current {
            get { hasFetched = true; return _cur; }
        }

        public bool MoveNext() {
            if (hasFetched) _cur += _incr;
            return (_cur > _end ^ _incr > 0);
        }

        public void Reset() {
            _cur = _start; hasFetched = false;
        }
    }

    internal class RangerFEnum : IEnumerator {
        double _cur, _start, _end, _incr;
        bool hasFetched = false;

        public RangerFEnum(double start, double end, double incr) {
            _start = _cur = start; _end = end; _incr = incr;
            if ((_start < _end ^ _incr > 0) || _incr == 0)
                throw new ArgumentException("Will never reach end!");
        }

        public double Current {
            get { hasFetched = true; return _cur; }
        }

        object IEnumerator.Current {
            get { hasFetched = true; return _cur; }
        }

        public bool MoveNext() {
            if (hasFetched) _cur += _incr;
            return (_cur > _end ^ _incr > 0);
        }

        public void Reset() {
            _cur = _start; hasFetched = false;
        }
    }
}

我是这样部署的：

create assembly Range from 'Range.dll' with permission_set=safe -- mod path to point to actual dll location on disk.
go
create function dbo.Range(@start bigint, @end bigint, @incr bigint)
  returns table(n bigint)
  as external name [Range].[Range.UserDefinedFunctions].[Range]
go
create function dbo.RangeF(@start float, @end float, @incr float)
  returns table(n float)
  as external name [Range].[Range.UserDefinedFunctions].[RangeF]
go

【讨论】：

太棒了......我会做的一件事是在你的逻辑中测试我们是否会完成，你真的应该这样做： if (Math.Sign(_end - _start) ！ = Math.Sign(_incr)) throw new ArgumentException(""永远不会结束！");
另外，您可能对所有基本数字类型（字节、整数等）使用泛型
在 C# 3,5 中这是一个单行：for (var i = start.Value; i < end.Value; i += incr.Value) yield return i;

【解决方案3】：

这基本上是表明 SQL 不够理想的事情之一。我在想也许正确的方法是构建一个创建范围的函数。（或发电机。）

我相信您问题的正确答案基本上是“您不能”。（对不起。）

【讨论】：

我明白为什么要修改它了。这是正确的，但不是特别有用。（除非你和我一样认为快速失败是个好主意。）

【解决方案4】：

您可以在 SQL2005+ 中使用公用表表达式来执行此操作。

WITH CTE AS
(
    SELECT 100 AS n
    UNION ALL
    SELECT n + 1 AS n FROM CTE WHERE n + 1 <= 200
)
SELECT n FROM CTE

【讨论】：

不错的答案！不幸的是，它不适用于任何大于 100 的数字，或您指定的任何 CTE 最大递归级别（“语句终止。最大递归 100 在语句完成之前已用完”）。
谢谢！您可以使用 MAXRECURSION 查询提示 (msdn.microsoft.com/en-us/library/ms181714.aspx) 将每个查询的递归级别提高到 32,767。尽管如此，这对于任何范围都不是一个完全通用的解决方案。

【解决方案5】：

如果使用 SQL Server 2000 或更高版本，您可以使用 表数据类型 来避免创建普通表或临时表。然后用普通的表操作就可以了。

使用此解决方案，您基本上可以在内存中拥有一个表结构，您几乎可以像使用真实表一样使用它，但性能要好得多。

我在这里找到了一个很好的讨论：Temporary tables vs the table data type

【讨论】：

【解决方案6】：

这是一个你永远不应该使用的技巧：

select sum(numberGenerator.rank)
from
(
select
    rank =  ( select count(*)  
              from reallyLargeTable t1 
              where t1.uniqueValue > t2.uniqueValue ), 
    t2.uniqueValue id1, 
    t2.uniqueValue id2
from reallyLargeTable t2 
) numberGenerator
where rank between 1 and 10

您可以使用 SQL 2005 中的 Rank() 或 Row_Number 函数来简化此操作

【讨论】：