J'ai trouvé assez difficile d'obtenir une plage de nombres sous forme de lignes MySQL .

Par exemple, la plage 1-5 est atteinte par:

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

aura pour résultat:

1
2
3
4
5

pour 0-99 je peux croiser joindre deux tables 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

J'en ai marre d'écrire tout ça UNION s et de chercher un moyen de réduire le code.

Des idées sur la façon de jouer au golf (par exemple une plage de 0 à 1 000 000) dans MySQL ou toute syntaxe SQL?

Des points supplémentaires sont accordés pour:

• déclaration unique
• pas de procédures
• pas de variables
• aucune instruction DDL
• uniquement les instructions DQL

Pour les dialectes SQL qui prennent en charge les CTE récursifs comme sqlite, vous pouvez faire quelque chose comme ceci:

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

Cela ne dépend d'aucune table existante et vous pouvez modifier la clause LIMIT comme vous le souhaitez. J'ai vu à l'origine une variante de cela sur StackOverflow.

Similaire à la méthode de @ BradC .

J'ai utilisé MS SQL, qui a une table [master]avec une plage de nombres de -1 à 2048. Vous pouvez utiliser l' BETWEENopérateur pour créer votre plage.

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

Si vous voulez jouer au golf, vous pouvez faire:

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

PostgreSQL, 35 octets

PostgreSQL a aussi simple:

SELECT * FROM generate_series(1,5)

Si vous en avez besoin:

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

Vous pouvez également le faire avec des horodatages. https://www.postgresql.org/docs/9.5/static/functions-srf.html

Grande option de ce post (trouvé par @Arnauld):

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

Pour moi, cela résout à peu près le défi.

Spécifique à PostgreSQL

generate_series()génère un ensemble, vous pouvez donc l'utiliser non seulement dans la fromclause, mais partout où un ensemble peut se produire:

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

Vous pouvez également effectuer des opérations directement sur l'ensemble:

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

Si plusieurs ensembles ont la même longueur, vous pouvez les parcourir en parallèle:

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

Pour les ensembles de longueurs différentes, un produit cartésien est généré:

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)

Mais si vous les utilisez dans la fromclause, vous obtenez également un produit cartésien pour les mêmes ensembles de longueurs:

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)

Il peut également générer un ensemble d'horodatages. Par exemple, vous êtes né le 30/06/2000 et vous voulez savoir en quelles années vous avez célébré votre anniversaire un week-end:

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 a une table système non documentée dans la masterbase de données appelée spt_values. Entre autres, il contient une plage de nombres de 0 à 2047:

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

Utile en tant que tableau de nombres juste en soi, mais dans un CTE, vous pouvez obtenir des gros nombres assez rapidement:

--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

(Ceux-ci fonctionnent dans MS-SQL, je ne sais pas s'ils fonctionnent pour mySQL ou d'autres plates-formes.)

Pour les petits ensembles (ordonnés ou non ordonnés), utilisez le VALUESconstructeur:

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

(Cela fonctionne pour n'importe quoi, bien que les chaînes puissent devenir assez longues avec toutes les guillemets simples répétés.)

Ensuite, vous pouvez multiplier en utilisant un CTE nommé (expression de table commune) afin de ne pas avoir à le répéter:

--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

Il existe de nombreuses autres techniques, recherchez «Génération SQL d'une table numérique», bien que la plupart ne soient pas optimisées pour le golf.

Encore une option, celle-ci spécifique à MS SQL 2016 et au-dessus:

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

Je trouverai probablement cela plus pratique pour les listes de chaînes, mais je peux voir comment cela sera également utile avec les nombres.

T-SQL, 98 octets

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

• ✓ déclaration unique
• ✓ aucune procédure
• ✓ aucune variable
• ✓ aucune instruction DDL
• ✓ uniquement les instructions DQL

Un autre pour 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;