मेरे पास उपयोगकर्ता से इनपुट के रूप में दो नंबर हैं, उदाहरण के लिए 1000
और 1050
।
मैं अलग पंक्तियों में एक sql क्वेरी का उपयोग करके इन दो नंबरों के बीच की संख्याओं को कैसे उत्पन्न करता हूं? मैं यह चाहता हूँ:
1000
1001
1002
1003
.
.
1050
मेरे पास उपयोगकर्ता से इनपुट के रूप में दो नंबर हैं, उदाहरण के लिए 1000
और 1050
।
मैं अलग पंक्तियों में एक sql क्वेरी का उपयोग करके इन दो नंबरों के बीच की संख्याओं को कैसे उत्पन्न करता हूं? मैं यह चाहता हूँ:
1000
1001
1002
1003
.
.
1050
जवाबों:
VALUES
कीवर्ड के साथ गैर-जारी मूल्यों का चयन करें । फिर JOIN
बहुत सारे और बहुत सारे संयोजनों को उत्पन्न करने के लिए उपयोग करें (सैकड़ों हजारों पंक्तियों और उससे आगे बनाने के लिए बढ़ाया जा सकता है)।
SELECT ones.n + 10*tens.n + 100*hundreds.n + 1000*thousands.n
FROM (VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) ones(n),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) tens(n),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) hundreds(n),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) thousands(n)
WHERE ones.n + 10*tens.n + 100*hundreds.n + 1000*thousands.n BETWEEN @userinput1 AND @userinput2
ORDER BY 1
एक छोटा विकल्प, जिसे समझना आसान नहीं है:
WITH x AS (SELECT n FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(n))
SELECT ones.n + 10*tens.n + 100*hundreds.n + 1000*thousands.n
FROM x ones, x tens, x hundreds, x thousands
ORDER BY 1
एक वैकल्पिक समाधान पुनरावर्ती CTE है:
DECLARE @startnum INT=1000
DECLARE @endnum INT=1050
;
WITH gen AS (
SELECT @startnum AS num
UNION ALL
SELECT num+1 FROM gen WHERE num+1<=@endnum
)
SELECT * FROM gen
option (maxrecursion 10000)
SELECT DISTINCT n = number
FROM master..[spt_values]
WHERE number BETWEEN @start AND @end
ध्यान दें कि इस तालिका में अधिकतम 2048 है क्योंकि तब संख्या में अंतराल है।
यहां सिस्टम दृश्य (SQL-Server 2005 से) का उपयोग करके थोड़ा बेहतर दृष्टिकोण दिया गया है:
;WITH Nums AS
(
SELECT n = ROW_NUMBER() OVER (ORDER BY [object_id])
FROM sys.all_objects
)
SELECT n FROM Nums
WHERE n BETWEEN @start AND @end
ORDER BY n;
या एक कस्टम का उपयोग नंबर-तालिका। हारून बर्ट्रेंड को क्रेडिट, मैं पूरे लेख को पढ़ने का सुझाव देता हूं: बिना लूप के एक सेट या अनुक्रम उत्पन्न करें
WHERE type = 'P'
और बच सकते हैंSELECT DISTINCT
String index out of range: 33
मैंने हाल ही में इस इनलाइन टेबल वैल्यू फंक्शन को लिखा है ताकि इस समस्या को हल किया जा सके। यह मेमोरी और स्टोरेज के अलावा अन्य सीमा में सीमित नहीं है। यह कोई तालिकाओं तक नहीं पहुंचता है इसलिए डिस्क रीड या आम तौर पर लिखने की कोई आवश्यकता नहीं है। यह प्रत्येक पुनरावृत्ति पर तेजी से मूल्यों को जोड़ता है इसलिए यह बहुत बड़ी रेंज के लिए भी बहुत तेज़ है। यह मेरे सर्वर पर पाँच सेकंड में दस मिलियन रिकॉर्ड बनाता है। यह नकारात्मक मूल्यों के साथ भी काम करता है।
CREATE FUNCTION [dbo].[fn_ConsecutiveNumbers]
(
@start int,
@end int
) RETURNS TABLE
RETURN
select
x268435456.X
| x16777216.X
| x1048576.X
| x65536.X
| x4096.X
| x256.X
| x16.X
| x1.X
+ @start
X
from
(VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15)) as x1(X)
join
(VALUES (0),(16),(32),(48),(64),(80),(96),(112),(128),(144),(160),(176),(192),(208),(224),(240)) as x16(X)
on x1.X <= @end-@start and x16.X <= @end-@start
join
(VALUES (0),(256),(512),(768),(1024),(1280),(1536),(1792),(2048),(2304),(2560),(2816),(3072),(3328),(3584),(3840)) as x256(X)
on x256.X <= @end-@start
join
(VALUES (0),(4096),(8192),(12288),(16384),(20480),(24576),(28672),(32768),(36864),(40960),(45056),(49152),(53248),(57344),(61440)) as x4096(X)
on x4096.X <= @end-@start
join
(VALUES (0),(65536),(131072),(196608),(262144),(327680),(393216),(458752),(524288),(589824),(655360),(720896),(786432),(851968),(917504),(983040)) as x65536(X)
on x65536.X <= @end-@start
join
(VALUES (0),(1048576),(2097152),(3145728),(4194304),(5242880),(6291456),(7340032),(8388608),(9437184),(10485760),(11534336),(12582912),(13631488),(14680064),(15728640)) as x1048576(X)
on x1048576.X <= @end-@start
join
(VALUES (0),(16777216),(33554432),(50331648),(67108864),(83886080),(100663296),(117440512),(134217728),(150994944),(167772160),(184549376),(201326592),(218103808),(234881024),(251658240)) as x16777216(X)
on x16777216.X <= @end-@start
join
(VALUES (0),(268435456),(536870912),(805306368),(1073741824),(1342177280),(1610612736),(1879048192)) as x268435456(X)
on x268435456.X <= @end-@start
WHERE @end >=
x268435456.X
| isnull(x16777216.X, 0)
| isnull(x1048576.X, 0)
| isnull(x65536.X, 0)
| isnull(x4096.X, 0)
| isnull(x256.X, 0)
| isnull(x16.X, 0)
| isnull(x1.X, 0)
+ @start
GO
SELECT X FROM fn_ConsecutiveNumbers(5, 500);
यह तिथि और समय सीमाओं के लिए भी उपयोगी है:
SELECT DATEADD(day,X, 0) DayX
FROM fn_ConsecutiveNumbers(datediff(day,0,'5/8/2015'), datediff(day,0,'5/31/2015'))
SELECT DATEADD(hour,X, 0) HourX
FROM fn_ConsecutiveNumbers(datediff(hour,0,'5/8/2015'), datediff(hour,0,'5/8/2015 12:00 PM'));
आप तालिका में मानों के आधार पर रिकॉर्ड को विभाजित करने के लिए उस पर एक क्रॉस अप्लाई जॉइन का उपयोग कर सकते हैं। तो उदाहरण के लिए एक तालिका में हर मिनट के लिए एक रिकॉर्ड बनाने के लिए एक तालिका में आप कुछ ऐसा कर सकते हैं:
select TimeRanges.StartTime,
TimeRanges.EndTime,
DATEADD(minute,X, 0) MinuteX
FROM TimeRanges
cross apply fn_ConsecutiveNumbers(datediff(hour,0,TimeRanges.StartTime),
datediff(hour,0,TimeRanges.EndTime)) ConsecutiveNumbers
SELECT X FROM fn_ConsecutiveNumbers(5, 500) ORDER BY X;
मेरे द्वारा उपयोग किया गया सबसे अच्छा विकल्प इस प्रकार है:
DECLARE @min bigint, @max bigint
SELECT @Min=919859000000 ,@Max=919859999999
SELECT TOP (@Max-@Min+1) @Min-1+row_number() over(order by t1.number) as N
FROM master..spt_values t1
CROSS JOIN master..spt_values t2
मैंने इसका उपयोग करके लाखों रिकॉर्ड बनाए हैं और यह सही काम करता है।
यह मेरे लिए काम करता है!
select top 50 ROW_NUMBER() over(order by a.name) + 1000 as Rcount
from sys.all_objects a
sys.all_objects
- छोटी श्रेणियों के लिए <2000 आइटम, यह एक मुद्दा नहीं है। सुनिश्चित नहीं है कि क्या इसकी अनुमति समस्याएं होंगी? जल्दी से परीक्षण डेटा का एक बैच उत्पन्न करने के लिए एकदम सही है।
select top 50 ROW_NUMBER() over(order by a.name) + 1000 as Rcount from sys.all_objects a, sys.all_objects b
। जहां मैं पहले केवल 2384 पंक्तियों को उत्पन्न कर सकता था, अब मैं 5683456 पंक्तियों को उत्पन्न कर सकता हूं।
सबसे अच्छा तरीका पुनरावर्ती ctes का उपयोग कर रहा है।
declare @initial as int = 1000;
declare @final as int =1050;
with cte_n as (
select @initial as contador
union all
select contador+1 from cte_n
where contador <@final
) select * from cte_n option (maxrecursion 0)
saludos।
declare @start int = 1000
declare @end int =1050
;with numcte
AS
(
SELECT @start [SEQUENCE]
UNION all
SELECT [SEQUENCE] + 1 FROM numcte WHERE [SEQUENCE] < @end
)
SELECT * FROM numcte
यदि आपको अपने सर्वर में सीएलआर असेंबली स्थापित करने में कोई समस्या नहीं है, तो एक अच्छा विकल्प .NET में एक टेबल वैल्यू फ़ंक्शन लिख रहा है। इस तरह आप एक सरल वाक्यविन्यास का उपयोग कर सकते हैं, जिससे अन्य प्रश्नों के साथ जुड़ना आसान हो जाता है और एक बोनस के रूप में स्मृति को बर्बाद नहीं किया जाएगा क्योंकि परिणाम प्रवाहित होता है।
निम्नलिखित वर्ग वाली एक परियोजना बनाएं:
using System;
using System.Collections;
using System.Data;
using System.Data.Sql;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
namespace YourNamespace
{
public sealed class SequenceGenerator
{
[SqlFunction(FillRowMethodName = "FillRow")]
public static IEnumerable Generate(SqlInt32 start, SqlInt32 end)
{
int _start = start.Value;
int _end = end.Value;
for (int i = _start; i <= _end; i++)
yield return i;
}
public static void FillRow(Object obj, out int i)
{
i = (int)obj;
}
private SequenceGenerator() { }
}
}
असेंबली को सर्वर पर कहीं रखें और चलाएं:
USE db;
CREATE ASSEMBLY SqlUtil FROM 'c:\path\to\assembly.dll'
WITH permission_set=Safe;
CREATE FUNCTION [Seq](@start int, @end int)
RETURNS TABLE(i int)
AS EXTERNAL NAME [SqlUtil].[YourNamespace.SequenceGenerator].[Generate];
अब आप चला सकते हैं:
select * from dbo.seq(1, 1000000)
कुछ भी नया नहीं है, लेकिन मैंने ब्रायन प्रेसलर समाधान को आंख पर आसान होने के लिए फिर से लिखा है, यह किसी के लिए उपयोगी हो सकता है (भले ही यह सिर्फ मेरे लिए है:
alter function [dbo].[fn_GenerateNumbers]
(
@start int,
@end int
) returns table
return
with
b0 as (select n from (values (0),(0x00000001),(0x00000002),(0x00000003),(0x00000004),(0x00000005),(0x00000006),(0x00000007),(0x00000008),(0x00000009),(0x0000000A),(0x0000000B),(0x0000000C),(0x0000000D),(0x0000000E),(0x0000000F)) as b0(n)),
b1 as (select n from (values (0),(0x00000010),(0x00000020),(0x00000030),(0x00000040),(0x00000050),(0x00000060),(0x00000070),(0x00000080),(0x00000090),(0x000000A0),(0x000000B0),(0x000000C0),(0x000000D0),(0x000000E0),(0x000000F0)) as b1(n)),
b2 as (select n from (values (0),(0x00000100),(0x00000200),(0x00000300),(0x00000400),(0x00000500),(0x00000600),(0x00000700),(0x00000800),(0x00000900),(0x00000A00),(0x00000B00),(0x00000C00),(0x00000D00),(0x00000E00),(0x00000F00)) as b2(n)),
b3 as (select n from (values (0),(0x00001000),(0x00002000),(0x00003000),(0x00004000),(0x00005000),(0x00006000),(0x00007000),(0x00008000),(0x00009000),(0x0000A000),(0x0000B000),(0x0000C000),(0x0000D000),(0x0000E000),(0x0000F000)) as b3(n)),
b4 as (select n from (values (0),(0x00010000),(0x00020000),(0x00030000),(0x00040000),(0x00050000),(0x00060000),(0x00070000),(0x00080000),(0x00090000),(0x000A0000),(0x000B0000),(0x000C0000),(0x000D0000),(0x000E0000),(0x000F0000)) as b4(n)),
b5 as (select n from (values (0),(0x00100000),(0x00200000),(0x00300000),(0x00400000),(0x00500000),(0x00600000),(0x00700000),(0x00800000),(0x00900000),(0x00A00000),(0x00B00000),(0x00C00000),(0x00D00000),(0x00E00000),(0x00F00000)) as b5(n)),
b6 as (select n from (values (0),(0x01000000),(0x02000000),(0x03000000),(0x04000000),(0x05000000),(0x06000000),(0x07000000),(0x08000000),(0x09000000),(0x0A000000),(0x0B000000),(0x0C000000),(0x0D000000),(0x0E000000),(0x0F000000)) as b6(n)),
b7 as (select n from (values (0),(0x10000000),(0x20000000),(0x30000000),(0x40000000),(0x50000000),(0x60000000),(0x70000000)) as b7(n))
select s.n
from (
select
b7.n
| b6.n
| b5.n
| b4.n
| b3.n
| b2.n
| b1.n
| b0.n
+ @start
n
from b0
join b1 on b0.n <= @end-@start and b1.n <= @end-@start
join b2 on b2.n <= @end-@start
join b3 on b3.n <= @end-@start
join b4 on b4.n <= @end-@start
join b5 on b5.n <= @end-@start
join b6 on b6.n <= @end-@start
join b7 on b7.n <= @end-@start
) s
where @end >= s.n
GO
ROW_NUMBER()
में वह समस्या नहीं है।
2 साल बाद, लेकिन मैंने पाया कि मेरे पास एक ही मुद्दा था। यहाँ है कि मैंने इसे कैसे हल किया। (मापदंडों को शामिल करने के लिए संपादित)
DECLARE @Start INT, @End INT
SET @Start = 1000
SET @End = 1050
SELECT TOP (@End - @Start+1) ROW_NUMBER() OVER (ORDER BY S.[object_id])+(@Start - 1) [Numbers]
FROM sys.all_objects S WITH (NOLOCK)
कार्टियरियन उत्पाद के सभी संदर्भों को समाप्त करने और ROW_NUMBER()
इसके बजाय ( निष्पादन की तुलना में निष्पादन ):
SELECT ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS n FROM
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x1(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x2(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x3(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x4(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x5(x)
ORDER BY n
इसे CTE के अंदर लपेटें और वांछित संख्याओं का चयन करने के लिए एक क्लॉज जोड़ें:
DECLARE @n1 AS INT = 100;
DECLARE @n2 AS INT = 40099;
WITH numbers AS (
SELECT ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS n FROM
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x1(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x2(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x3(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x4(x),
(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) x5(x)
)
SELECT numbers.n
FROM numbers
WHERE n BETWEEN @n1 and @n2
ORDER BY n
SELECT ROW_NUMBER() OVER (...) - 1 AS n
। कुछ मामलों में यह प्रदर्शन को मार सकता है।
यहाँ कुछ इष्टतम और संगत समाधान हैं:
USE master;
declare @min as int; set @min = 1000;
declare @max as int; set @max = 1050; --null returns all
-- Up to 256 - 2 048 rows depending on SQL Server version
select isnull(@min,0)+number.number as number
FROM dbo.spt_values AS number
WHERE number."type" = 'P' --integers
and ( @max is null --return all
or isnull(@min,0)+number.number <= @max --return up to max
)
order by number
;
-- Up to 65 536 - 4 194 303 rows depending on SQL Server version
select isnull(@min,0)+value1.number+(value2.number*numberCount.numbers) as number
FROM dbo.spt_values AS value1
cross join dbo.spt_values AS value2
cross join ( --get the number of numbers (depends on version)
select sum(1) as numbers
from dbo.spt_values
where spt_values."type" = 'P' --integers
) as numberCount
WHERE value1."type" = 'P' --integers
and value2."type" = 'P' --integers
and ( @max is null --return all
or isnull(@min,0)+value1.number+(value2.number*numberCount.numbers)
<= @max --return up to max
)
order by number
;
select
आईएनजी से बेहतर है where spt_values.number between @min and @max
?
मुझे पता है कि मुझे 4 साल बहुत देर हो चुकी है, लेकिन मैं इस समस्या का एक और वैकल्पिक जवाब देने पर अड़ गया हूं। गति के लिए समस्या सिर्फ पूर्व फ़िल्टरिंग नहीं है, बल्कि छँटाई को भी रोकती है। यह शामिल होने के आदेश को लागू करने के लिए मजबूर करना संभव है कि कार्टेशियन उत्पाद वास्तव में शामिल होने के परिणामस्वरूप मायने रखता है। जंप-ऑफ बिंदु के रूप में स्लार्टिडन के उत्तर का उपयोग करना:
WITH x AS (SELECT n FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(n))
SELECT ones.n + 10*tens.n + 100*hundreds.n + 1000*thousands.n
FROM x ones, x tens, x hundreds, x thousands
ORDER BY 1
यदि हम अपनी इच्छित सीमा जानते हैं, तो हम इसे @Upper और @Lower के माध्यम से निर्दिष्ट कर सकते हैं। TOP के साथ join hint REMOTE को जोड़कर, हम केवल उन मानों के सबसेट की गणना कर सकते हैं, जिन्हें हम बर्बाद नहीं करना चाहते हैं।
WITH x AS (SELECT n FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(n))
SELECT TOP (1+@Upper-@Lower) @Lower + ones.n + 10*tens.n + 100*hundreds.n + 1000*thousands.n
FROM x thousands
INNER REMOTE JOIN x hundreds on 1=1
INNER REMOTE JOIN x tens on 1=1
INNER REMOTE JOIN x ones on 1=1
शामिल होने का संकेत REMOTE ऑप्टिमाइज़र को पहले शामिल होने के दाईं ओर तुलना करने के लिए मजबूर करता है। सबसे कम से कम महत्वपूर्ण मूल्य से REMOTE के रूप में प्रत्येक में शामिल होने को निर्दिष्ट करके, जुड़ने से एक सही ढंग से ऊपर की ओर गिना जाएगा। WHERE के साथ फ़िल्टर करने या ORDER BY के साथ सॉर्ट करने की आवश्यकता नहीं है।
यदि आप सीमा बढ़ाना चाहते हैं, तो आप परिमाण के उच्चतर क्रमों के साथ अतिरिक्त जुड़ना जारी रख सकते हैं, इसलिए जब तक कि वे FROM क्लॉज में सबसे कम से कम महत्वपूर्ण से ऑर्डर किए जाते हैं।
ध्यान दें कि यह SQL Server 2008 या उच्चतर के लिए विशिष्ट क्वेरी है।
क्वेरी चलाते समय सबसे अच्छी गति
DECLARE @num INT = 1000
WHILE(@num<1050)
begin
INSERT INTO [dbo].[Codes]
( Code
)
VALUES (@num)
SET @num = @num + 1
end
पुनरावर्ती CTE घातीय आकार में (भले ही 100 पुनरावृत्ति के डिफ़ॉल्ट के लिए, यह 2 ^ 100 नंबर तक का निर्माण कर सकता है):
DECLARE @startnum INT=1000
DECLARE @endnum INT=1050
DECLARE @size INT=@endnum-@startnum+1
;
WITH numrange (num) AS (
SELECT 1 AS num
UNION ALL
SELECT num*2 FROM numrange WHERE num*2<=@size
UNION ALL
SELECT num*2+1 FROM numrange WHERE num*2+1<=@size
)
SELECT num+@startnum-1 FROM numrange order by num
@startnum
और endnum
उपयोगकर्ता द्वारा इनपुट होना चाहिए?
मुझे इसी तरह की विधि का उपयोग करके डेटाबेस में चित्र फ़ाइलपथ सम्मिलित करना था। नीचे दी गई क्वेरी ठीक काम की है:
DECLARE @num INT = 8270058
WHILE(@num<8270284)
begin
INSERT INTO [dbo].[Galleries]
(ImagePath)
VALUES
('~/Content/Galeria/P'+CONVERT(varchar(10), @num)+'.JPG')
SET @num = @num + 1
end
आपके लिए कोड होगा:
DECLARE @num INT = 1000
WHILE(@num<1051)
begin
SELECT @num
SET @num = @num + 1
end
यह वही है जो मैं करता हूं, यह बहुत तेज और लचीला है और बहुत सारे कोड नहीं है।
DECLARE @count int = 65536;
DECLARE @start int = 11;
DECLARE @xml xml = REPLICATE(CAST('<x/>' AS nvarchar(max)), @count);
; WITH GenerateNumbers(Num) AS
(
SELECT ROW_NUMBER() OVER (ORDER BY @count) + @start - 1
FROM @xml.nodes('/x') X(T)
)
SELECT Num
FROM GenerateNumbers;
ध्यान दें कि (ORDER BY @count) एक डमी है। यह कुछ नहीं करता है लेकिन ROW_NUMBER () को ORDER BY की आवश्यकता है।
संपादित करें : मुझे एहसास हुआ कि मूल प्रश्न x से y तक की सीमा प्राप्त करना था। मेरी स्क्रिप्ट को एक श्रेणी प्राप्त करने के लिए इस तरह संशोधित किया जा सकता है:
DECLARE @start int = 5;
DECLARE @end int = 21;
DECLARE @xml xml = REPLICATE(CAST('<x/>' AS nvarchar(max)), @end - @start + 1);
; WITH GenerateNumbers(Num) AS
(
SELECT ROW_NUMBER() OVER (ORDER BY @end) + @start - 1
FROM @xml.nodes('/x') X(T)
)
SELECT Num
FROM GenerateNumbers;
-- Generate Numeric Range
-- Source: http://www.sqlservercentral.com/scripts/Miscellaneous/30397/
CREATE TABLE #NumRange(
n int
)
DECLARE @MinNum int
DECLARE @MaxNum int
DECLARE @I int
SET NOCOUNT ON
SET @I = 0
WHILE @I <= 9 BEGIN
INSERT INTO #NumRange VALUES(@I)
SET @I = @I + 1
END
SET @MinNum = 1
SET @MaxNum = 1000000
SELECT num = a.n +
(b.n * 10) +
(c.n * 100) +
(d.n * 1000) +
(e.n * 10000)
FROM #NumRange a
CROSS JOIN #NumRange b
CROSS JOIN #NumRange c
CROSS JOIN #NumRange d
CROSS JOIN #NumRange e
WHERE a.n +
(b.n * 10) +
(c.n * 100) +
(d.n * 1000) +
(e.n * 10000) BETWEEN @MinNum AND @MaxNum
ORDER BY a.n +
(b.n * 10) +
(c.n * 100) +
(d.n * 1000) +
(e.n * 10000)
DROP TABLE #NumRange
यह केवल अनुक्रमों के लिए काम करता है जब तक कि कुछ अनुप्रयोग तालिका में पंक्तियाँ हों। मान लें कि मैं १.१०० से अनुक्रम चाहता हूं, और कॉलम (संख्यात्मक या स्ट्रिंग प्रकार के) के साथ आवेदन तालिका dbo.foo है:
select
top 100
row_number() over (order by dbo.foo.bar) as seq
from dbo.foo
खण्ड द्वारा एक क्रम में इसकी उपस्थिति के बावजूद, dbo.foo.bar के पास विशिष्ट या यहां तक कि गैर-शून्य मान नहीं हैं।
बेशक, SQL सर्वर 2012 में अनुक्रम ऑब्जेक्ट हैं, इसलिए उस उत्पाद में एक प्राकृतिक समाधान है।
यहाँ मैं क्या लेकर आया हूँ:
create or alter function dbo.fn_range(@start int, @end int) returns table
return
with u2(n) as (
select n
from (VALUES (0),(1),(2),(3)) v(n)
),
u8(n) as (
select
x0.n | x1.n * 4 | x2.n * 16 | x3.n * 64 as n
from u2 x0, u2 x1, u2 x2, u2 x3
)
select
@start + s.n as n
from (
select
x0.n | isnull(x1.n, 0) * 256 | isnull(x2.n, 0) * 65536 as n
from u8 x0
left join u8 x1 on @end-@start > 256
left join u8 x2 on @end-@start > 65536
) s
where s.n < @end - @start
2 ^ 24 मान तक उत्पन्न करता है। शामिल होने की स्थिति छोटे मूल्यों के लिए इसे तेजी से बनाए रखें।
यह मेरे DEV सर्वर पर 36 सेकंड में मेरे लिए पूरा हुआ। ब्रायन के उत्तर की तरह, सीमा को छानने पर ध्यान केंद्रित करना क्वेरी के भीतर से महत्वपूर्ण है; एक BETWEEN अभी भी निचले बाउंड से पहले सभी प्रारंभिक रिकॉर्ड उत्पन्न करने की कोशिश करता है, भले ही इसके लिए उन्हें ज़रूरत न हो।
declare @s bigint = 10000000
, @e bigint = 20000000
;WITH
Z AS (SELECT 0 z FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12),(13),(14),(15)) T(n)),
Y AS (SELECT 0 z FROM Z a, Z b, Z c, Z d, Z e, Z f, Z g, Z h, Z i, Z j, Z k, Z l, Z m, Z n, Z o, Z p),
N AS (SELECT ROW_NUMBER() OVER (PARTITION BY 0 ORDER BY z) n FROM Y)
SELECT TOP (1+@e-@s) @s + n - 1 FROM N
ध्यान दें कि ROW_NUMBER एक है bigint तो हम किसी भी विधि के साथ 2 ^^ 64 (== 16 ^^ 16) उत्पन्न रिकॉर्ड अधिक नहीं हो सकती है कि यह उपयोग करता है,। यह क्वेरी उत्पन्न मानों पर समान ऊपरी सीमा का सम्मान करती है।
यह प्रक्रियात्मक कोड और तालिका-मूल्यवान फ़ंक्शन का उपयोग करता है। धीमा, लेकिन आसान और अनुमानित।
CREATE FUNCTION [dbo].[Sequence] (@start int, @end int)
RETURNS
@Result TABLE(ID int)
AS
begin
declare @i int;
set @i = @start;
while @i <= @end
begin
insert into @result values (@i);
set @i = @i+1;
end
return;
end
उपयोग:
SELECT * FROM dbo.Sequence (3,7);
ID
3
4
5
6
7
यह एक तालिका है, इसलिए आप इसे अन्य डेटा के साथ जुड़ने में उपयोग कर सकते हैं। मैं सबसे अधिक बार इस फ़ंक्शन का उपयोग समय मानों के एक सन्निहित अनुक्रम को सुनिश्चित करने के लिए एक समूह BY घंटे, दिन आदि के खिलाफ एक सम्मिलित के रूप में करता हूं।
SELECT DateAdd(hh,ID,'2018-06-20 00:00:00') as HoursInTheDay FROM dbo.Sequence (0,23) ;
HoursInTheDay
2018-06-20 00:00:00.000
2018-06-20 01:00:00.000
2018-06-20 02:00:00.000
2018-06-20 03:00:00.000
2018-06-20 04:00:00.000
(...)
प्रदर्शन नगण्य है (एक लाख पंक्तियों के लिए 16 सेकंड) लेकिन कई उद्देश्यों के लिए पर्याप्त है।
SELECT count(1) FROM [dbo].[Sequence] (
1000001
,2000000)
GO
ओरेकल 12 सी; त्वरित लेकिन सीमित:
select rownum+1000 from all_objects fetch first 50 rows only;
नोट : all_objects दृश्य की पंक्ति गणना तक सीमित;
मैंने अभी कुछ समय के लिए जो समाधान विकसित किया है और उपयोग किया है, वह (दूसरों के साझा कार्यों पर कुछ सवारी करना) कम से कम एक पोस्ट के समान है। यह किसी भी तालिका का संदर्भ नहीं देता है और 1048576 मान (2 ^ 20) तक की एक अनसुलझी श्रेणी देता है और यदि वांछित हो तो नकारात्मक शामिल कर सकता है। यदि आवश्यक हो तो आप निश्चित रूप से परिणाम को सॉर्ट कर सकते हैं। यह बहुत जल्दी चलता है, खासकर छोटी रेंज पर।
Select value from dbo.intRange(-500, 1500) order by value -- returns 2001 values
create function dbo.intRange
(
@Starting as int,
@Ending as int
)
returns table
as
return (
select value
from (
select @Starting +
( bit00.v | bit01.v | bit02.v | bit03.v
| bit04.v | bit05.v | bit06.v | bit07.v
| bit08.v | bit09.v | bit10.v | bit11.v
| bit12.v | bit13.v | bit14.v | bit15.v
| bit16.v | bit17.v | bit18.v | bit19.v
) as value
from (select 0 as v union ALL select 0x00001 as v) as bit00
cross join (select 0 as v union ALL select 0x00002 as v) as bit01
cross join (select 0 as v union ALL select 0x00004 as v) as bit02
cross join (select 0 as v union ALL select 0x00008 as v) as bit03
cross join (select 0 as v union ALL select 0x00010 as v) as bit04
cross join (select 0 as v union ALL select 0x00020 as v) as bit05
cross join (select 0 as v union ALL select 0x00040 as v) as bit06
cross join (select 0 as v union ALL select 0x00080 as v) as bit07
cross join (select 0 as v union ALL select 0x00100 as v) as bit08
cross join (select 0 as v union ALL select 0x00200 as v) as bit09
cross join (select 0 as v union ALL select 0x00400 as v) as bit10
cross join (select 0 as v union ALL select 0x00800 as v) as bit11
cross join (select 0 as v union ALL select 0x01000 as v) as bit12
cross join (select 0 as v union ALL select 0x02000 as v) as bit13
cross join (select 0 as v union ALL select 0x04000 as v) as bit14
cross join (select 0 as v union ALL select 0x08000 as v) as bit15
cross join (select 0 as v union ALL select 0x10000 as v) as bit16
cross join (select 0 as v union ALL select 0x20000 as v) as bit17
cross join (select 0 as v union ALL select 0x40000 as v) as bit18
cross join (select 0 as v union ALL select 0x80000 as v) as bit19
) intList
where @Ending - @Starting < 0x100000
and intList.value between @Starting and @Ending
)
;WITH u AS (
SELECT Unit FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(Unit)
),
d AS (
SELECT
(Thousands+Hundreds+Tens+Units) V
FROM
(SELECT Thousands = Unit * 1000 FROM u) Thousands
,(SELECT Hundreds = Unit * 100 FROM u) Hundreds
,(SELECT Tens = Unit * 10 FROM u) Tens
,(SELECT Units = Unit FROM u) Units
WHERE
(Thousands+Hundreds+Tens+Units) <= 10000
)
SELECT * FROM d ORDER BY v
मैंने इस सूत्र को पढ़ने के बाद नीचे का कार्य किया। सरल और तेज:
go
create function numbers(@begin int, @len int)
returns table as return
with d as (
select 1 v from (values(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0),(0)) d(v)
)
select top (@len) @begin -1 + row_number() over(order by (select null)) v
from d d0
cross join d d1
cross join d d2
cross join d d3
cross join d d4
cross join d d5
cross join d d6
cross join d d7
go
select * from numbers(987654321,500000)