Saya merasa cukup sulit untuk mencapai kisaran angka seperti baris MySQL.

Misalnya rentang 1-5 dicapai dengan:

SELECT 1 
UNION
SELECT 2
UNION
SELECT 3
UNION
SELECT 4
UNION
SELECT 5

akan menghasilkan:

1
2
3
4
5

untuk 0-99 saya bisa bergabung dengan dua tabel 0-9:

CREATE TABLE nums as
SELECT 0 as num
UNION
SELECT 1 
UNION
SELECT 2
UNION
SELECT 3
UNION
SELECT 4
UNION
SELECT 5
UNION
SELECT 6 
UNION
SELECT 7
UNION
SELECT 8
UNION
SELECT 9
;

Select n.num*10+nums.num v 
From nums n cross join nums

Saya bosan menulis semua ini UNIONdan mencari cara untuk mengecilkan kode.

Adakah ide bagaimana membuatnya golf (misalnya rentang 0-1.000.000) di MySQL atau sintaks SQL apa pun?

Poin ekstra diberikan untuk:

• satu pernyataan
• tidak ada prosedur
• tidak ada variabel
• tidak ada pernyataan DDL
• hanya pernyataan DQL

Untuk dialek SQL yang mendukung CTE rekursif seperti sqlite, Anda dapat melakukan sesuatu seperti berikut:

WITH RECURSIVE f(x) AS
(
  SELECT 1 UNION ALL SELECT x + 1 FROM f LIMIT 1000000
)
SELECT x
FROM f;

Ini tidak tergantung pada tabel yang ada dan Anda dapat mengubah klausa LIMIT seperti yang diinginkan. Saya awalnya melihat varian ini di StackOverflow.

Mirip dengan metode @ BradC .

Saya menggunakan MS SQL, yang memiliki tabel [master]dengan kisaran angka -1 hingga 2048. Anda dapat menggunakan BETWEENoperator untuk membuat rentang Anda.

SELECT DISTINCT(number)
FROM master..[spt_values] 
WHERE number BETWEEN 1 AND 5

Jika Anda ingin bermain golf ini, Anda dapat melakukan:

SELECT TOP 5 ROW_NUMBER()OVER(ORDER BY number)FROM master..spt_values

PostgreSQL, 35 byte

PostgreSQL memiliki kemudahan ini:

SELECT * FROM generate_series(1,5)

Jika Anda membutuhkannya beri nama:

SELECT num FROM generate_series(1,5)AS a(num)

Anda juga dapat melakukan ini dengan cap waktu. https://www.postgresql.org/docs/9.5/static/functions-srf.html

Opsi hebat dari pos ini (ditemukan oleh @Arnauld):

SELECT id%1000001 as num
FROM <any_large_table>
GROUP BY num

Bagi saya - ini cukup banyak memecahkan tantangan.

Khusus postgreSQL

generate_series()menghasilkan set, sehingga Anda dapat menggunakannya bukan hanya dalam fromklausa, tetapi di mana pun di mana set dapat terjadi:

psql=# select generate_series(10, 20, 3);
 generate_series 
-----------------
              10
              13
              16
              19
(4 rows)

Anda juga dapat melakukan operasi langsung di set:

psql=# select 2000 + generate_series(10, 20, 3) * 2;
 ?column? 
----------
     2020
     2026
     2032
     2038
(4 rows)

Jika beberapa set memiliki panjang yang sama, Anda dapat melewatinya secara paralel:

psql=# select generate_series(1, 3), generate_series(4, 6);
 generate_series | generate_series 
-----------------+-----------------
               1 |               4
               2 |               5
               3 |               6
(3 rows)

Untuk set dengan panjang berbeda, dihasilkan produk Cartesian:

psql=# select generate_series(1, 3), generate_series(4, 5);
 generate_series | generate_series 
-----------------+-----------------
               1 |               4
               2 |               5
               3 |               4
               1 |               5
               2 |               4
               3 |               5
(6 rows)

Tetapi jika Anda menggunakannya dalam fromklausa, Anda mendapatkan produk Cartesian untuk set panjang yang sama juga:

psql=# select * from generate_series(1, 2), generate_series(3, 4) second;
 generate_series | second 
-----------------+--------
               1 |      3
               1 |      4
               2 |      3
               2 |      4
(4 rows)

Itu juga dapat menghasilkan set cap waktu. Misalnya Anda lahir pada 2000-06-30 dan ingin tahu tahun berapa Anda merayakan ulang tahun di akhir pekan:

psql=# select to_char(generate_series, 'YYYY - Day') from generate_series('2000-06-30', current_date, interval '1 year') where to_char(generate_series, 'D') in ('1', '7');
     to_char      
------------------
 2001 - Saturday 
 2002 - Sunday   
 2007 - Saturday 
 2012 - Saturday 
 2013 - Sunday   
(5 rows)

MS SQL memiliki tabel sistem tidak terdokumentasi dalam masterdatabase yang disebut spt_values. Di antara hal-hal lain, ini berisi rentang angka dari 0 hingga 2047:

--returns 0 to 2,047
SELECT number n 
FROM master..spt_values
WHERE TYPE='P'

Berguna sebagai tabel angka hanya dengan sendirinya, tetapi dalam CTE Anda bisa mendapatkan beberapa angka besar dengan cepat:

--returns 0 to 4,194,304
WITH x AS(SELECT number n FROM master..spt_values WHERE TYPE='P')
SELECT 2048*x.a+*y.a
FROM x,x y
ORDER BY 1

(Ini berfungsi dalam MS-SQL, tidak yakin apakah mereka berfungsi untuk mySQL atau platform lain.)

Untuk set yang lebih kecil (dipesan atau tidak dipesan), gunakan VALUESkonstruktor:

--Generates 0-9
SELECT a 
FROM(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9))x(a)

(Ini bisa digunakan untuk apa saja, walaupun string bisa cukup panjang dengan semua tanda kutip tunggal yang diulang.)

Kemudian Anda bisa melipatgandakan menggunakan CTE bernama (ekspresi tabel umum) sehingga Anda tidak perlu mengulanginya:

--Generates 0-999
WITH x AS(SELECT a FROM(VALUES(0),(1),(2),(3),(4),(5),(6),(7),(8),(9))x(a))
SELECT 100*x.a+10*y.a+z.a 
FROM x,x y,x z
ORDER BY 1

Ada banyak teknik lain di luar sana, cari "SQL menghasilkan tabel angka", meskipun sebagian besar tidak dioptimalkan untuk bermain golf.

Satu lagi opsi, yang satu ini khusus untuk MS SQL 2016 ke atas:

SELECT value v
FROM STRING_SPLIT('1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16', ',')

Saya mungkin akan menemukan ini lebih berguna untuk daftar string, tetapi saya bisa melihat cara ini akan berguna dengan angka juga.

T-SQL, 98 byte

WITH H AS(SELECT 0i UNION ALL SELECT i+1FROM H WHERE i<99)SELECT H.i+1e4*A.i+B.i*1e2FROM H,H A,H B

• ✓ pernyataan tunggal
• ✓ tidak ada prosedur
• ✓ tidak ada variabel
• ✓ tidak ada pernyataan DDL
• ✓ hanya pernyataan DQL

Lain untuk SQL Server ...

WITH 
    cte_n1 (n) AS (SELECT 1 FROM (VALUES (1),(1),(1),(1),(1),(1),(1),(1),(1),(1)) n (n)),   -- 10
    cte_n2 (n) AS (SELECT 1 FROM cte_n1 a CROSS JOIN cte_n1 b),                             -- 100
    cte_Tally (n) AS (
        SELECT TOP (<how many ROWS do you want?>)
            ROW_NUMBER() OVER (ORDER BY (SELECT NULL))
        FROM
            cte_n2 a CROSS JOIN cte_n2 b                                                    -- 10,000
        )
SELECT 
    t.n
FROM
    cte_Tally t;