operador - sentencia between mysql

Generando un rango de números en MySQL

Question

¿Cómo puedo generar un rango de números consecutivos (uno por línea) desde una consulta MySQL para poder insertarlos en una tabla?

Por ejemplo:

nr
1
2
3
4
5

Me gustaría usar solo MySQL para esto (no PHP u otros idiomas).

Answer 1

Aquí hay una manera de hacerlo basado en conjuntos sin bucles. Esto también se puede convertir en una vista para su reutilización. El ejemplo muestra la generación de una secuencia de 0 a 999, pero, por supuesto, puede modificarse para adaptarse.

INSERT INTO
    myTable
    (
    nr
    )
SELECT
    SEQ.SeqValue
FROM
(
SELECT
    (HUNDREDS.SeqValue + TENS.SeqValue + ONES.SeqValue) SeqValue
FROM
    (
    SELECT 0  SeqValue
    UNION ALL
    SELECT 1 SeqValue
    UNION ALL
    SELECT 2 SeqValue
    UNION ALL
    SELECT 3 SeqValue
    UNION ALL
    SELECT 4 SeqValue
    UNION ALL
    SELECT 5 SeqValue
    UNION ALL
    SELECT 6 SeqValue
    UNION ALL
    SELECT 7 SeqValue
    UNION ALL
    SELECT 8 SeqValue
    UNION ALL
    SELECT 9 SeqValue
    ) ONES
CROSS JOIN
    (
    SELECT 0 SeqValue
    UNION ALL
    SELECT 10 SeqValue
    UNION ALL
    SELECT 20 SeqValue
    UNION ALL
    SELECT 30 SeqValue
    UNION ALL
    SELECT 40 SeqValue
    UNION ALL
    SELECT 50 SeqValue
    UNION ALL
    SELECT 60 SeqValue
    UNION ALL
    SELECT 70 SeqValue
    UNION ALL
    SELECT 80 SeqValue
    UNION ALL
    SELECT 90 SeqValue
    ) TENS
CROSS JOIN
    (
    SELECT 0 SeqValue
    UNION ALL
    SELECT 100 SeqValue
    UNION ALL
    SELECT 200 SeqValue
    UNION ALL
    SELECT 300 SeqValue
    UNION ALL
    SELECT 400 SeqValue
    UNION ALL
    SELECT 500 SeqValue
    UNION ALL
    SELECT 600 SeqValue
    UNION ALL
    SELECT 700 SeqValue
    UNION ALL
    SELECT 800 SeqValue
    UNION ALL
    SELECT 900 SeqValue
    ) HUNDREDS
) SEQ

Answer 2

Aquí hay una versión del ingeniero de hardware de share de share :

SELECT
    (TWO_1.SeqValue + TWO_2.SeqValue + TWO_4.SeqValue + TWO_8.SeqValue + TWO_16.SeqValue) SeqValue
FROM
    (SELECT 0 SeqValue UNION ALL SELECT 1 SeqValue) TWO_1
    CROSS JOIN (SELECT 0 SeqValue UNION ALL SELECT 2 SeqValue) TWO_2
    CROSS JOIN (SELECT 0 SeqValue UNION ALL SELECT 4 SeqValue) TWO_4
    CROSS JOIN (SELECT 0 SeqValue UNION ALL SELECT 8 SeqValue) TWO_8
    CROSS JOIN (SELECT 0 SeqValue UNION ALL SELECT 16 SeqValue) TWO_16;

Answer 3

Como todos ustedes entienden, esto es bastante hacky así que úselo con cuidado

SELECT id % 12 + 1 as one_to_twelve FROM any_large_table group by one_to_twelve

Answer 4

Digamos que quiere insertar los números del 1 al 100 en su tabla. Siempre que tenga alguna otra tabla que tenga al menos tantas filas (no importa el contenido de la tabla), este es mi método preferido:

INSERT INTO pivot100 
SELECT @ROW := @ROW + 1 AS ROW
 FROM someOtherTable t
 join (SELECT @ROW := 0) t2
 LIMIT 100
;

¿Quieres un rango que comience con algo que no sea 1? Simplemente cambie a qué @ROW se establece en la unión.

Answer 5

La forma "más corta" que conozco (en MySQL) para crear una tabla con una secuencia larga es (cruzar) unirme a una tabla existente consigo misma. Como cualquier servidor (común) MySQL tiene la tabla information_schema.COLUMNS , la usaría:

DROP TABLE IF EXISTS seq;
CREATE TABLE seq (i MEDIUMINT AUTO_INCREMENT PRIMARY KEY)
    SELECT NULL AS i
    FROM information_schema.COLUMNS t1
    JOIN information_schema.COLUMNS t2
    JOIN information_schema.COLUMNS t3
    LIMIT 100000; -- <- set your limit here

Por lo general, una unión debería ser suficiente para crear más de 1M filas, pero una unión más no le hará daño :-) - No olvides establecer un límite.

Si desea incluir 0 , debe "eliminar" la propiedad AUTO_INCEMENT .

ALTER TABLE seq ALTER i DROP DEFAULT;
ALTER TABLE seq MODIFY i MEDIUMINT;

Ahora puedes insertar 0

INSERT INTO seq (i) VALUES (0);

y números negativos también

INSERT INTO seq (i) SELECT -i FROM seq WHERE i <> 0;

Puede validar los números con

SELECT MIN(i), MAX(i), COUNT(*) FROM seq;

Answer 6

La idea que quiero compartir no es una respuesta precisa para la pregunta, pero puede ser útil para algunos, por lo que me gustaría compartirla.

Si con frecuencia necesita solo un conjunto limitado de números, puede ser beneficioso crear una tabla con los números que pueda necesitar y simplemente usar esa tabla cada vez. Por ejemplo:

CREATE TABLE _numbers (num int);
INSERT _numbers VALUES (0), (1), (2), (3), ...;

Esto solo se puede aplicar si necesita números por debajo de un cierto límite razonable, por lo tanto, no lo use para generar una secuencia de 1 ... 1 millón, pero puede usarse para los números 1 ... 10k, por ejemplo.

Si tiene esta lista de números en la tabla _numbers , puede escribir consultas como esta para obtener los caracteres individuales de una cadena:

SELECT number, substr(name, num, 1) 
    FROM users
    JOIN _numbers ON num < length(name)
    WHERE user_id = 1234
    ORDER BY num;

Si necesita números mayores que 10k, puede unirse a la tabla solo:

SELECT n1.num * 10000 + n2.num
    FROM _numbers n1
    JOIN _numbers n2
    WHERE n1 < 100 
    ORDER BY n1.num * 10000 + n2.num; -- or just ORDER BY 1 meaning the first column

Answer 7

Si necesita los registros en una tabla y desea evitar problemas de simultaneidad, aquí le mostramos cómo hacerlo.

Primero creas una tabla en la que almacenar tus registros

CREATE TABLE `incr` (
  `Id` int(11) NOT NULL auto_increment,
  PRIMARY KEY  (`Id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8;

En segundo lugar crea un procedimiento almacenado como este:

DELIMITER ;;
CREATE PROCEDURE dowhile()
BEGIN
  DECLARE v1 INT DEFAULT 5;
  WHILE v1 > 0 DO
    INSERT incr VALUES (NULL);
    SET v1 = v1 - 1;
  END WHILE;
END;;
DELIMITER ;

Por último, llame al SP:

CALL dowhile();
SELECT * FROM incr;

Resultado

Id
1
2
3
4
5

Answer 8

DECLARE i INT DEFAULT 0;

WHILE i < 6 DO
  /* insert into table... */
  SET i = i + 1;
END WHILE;