Question

如何在没有循环的情况下让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.

Answer 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。有时使用会很痛苦，因为多年来它一直缺乏增强功能，有助于减少复杂操作所需的冗余。但是，它非常强大，并且是一种非常直观的方式，可以将数据集作为算法的目标和驱动程序。

Answer 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

Answer 3

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

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

Answer 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

Answer 5

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

使用这个解决方案，你在内存中基本上有一个表结构，你可以使用它几乎像一个真正的表，但性能更高。

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

Answer 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函数来简化此操作

基于SQL集的范围

6 个答案: