smallint - tamaño de int mysql

Tipos en MySQL: BigInt(20) vs Int(20)

Question

Me preguntaba cuál es la diferencia entre BigInt , MediumInt e Int ... parece obvio que permitirían números más grandes; sin embargo, puedo hacer un Int(20) o un BigInt(20) y parecería que no se trata necesariamente del tamaño.

Algunas ideas serían increíbles, solo un poco curiosas. He estado usando MySQL por un tiempo y tratando de aplicar las necesidades comerciales al elegir tipos, pero nunca entendí este aspecto.

Answer 1

El número entre paréntesis en una declaración de tipo es el ancho de visualización , que no está relacionado con el rango de valores que se pueden almacenar en un tipo de datos. El hecho de que pueda declarar Int(20) no significa que pueda almacenar valores de hasta 10 ^ 20 en él:

[...] Las aplicaciones pueden usar este ancho de visualización opcional para mostrar los valores enteros que tienen un ancho inferior al ancho especificado para la columna al rellenarlos con espacios. ...

El ancho de visualización no restringe el rango de valores que se pueden almacenar en la columna, ni la cantidad de dígitos que se muestran para valores que tienen un ancho que excede el especificado para la columna. Por ejemplo, una columna especificada como SMALLINT (3) tiene el rango SMALLINT habitual de -32768 a 32767, y los valores fuera del rango permitido por tres caracteres se muestran con más de tres caracteres.

Para obtener una lista de los valores máximos y mínimos que se pueden almacenar en cada tipo de datos MySQL, consulte here .

Answer 2

Por lo que yo sé, solo hay una pequeña diferencia cuando estás tratando de insertar un valor que está fuera de rango.

En ejemplos 401421228216 , que es 101110101110110100100011101100010111000 (longitud 39 caracteres)

• Si tiene INT(20) para el sistema, esto significa asignar en la memoria un mínimo de 20 bits. Pero si inserta un valor mayor que 2^20 , se almacenará con éxito, solo si es menor que INT(32) -> 2147483647 (o 2 * INT(32) -> 4294967295 para UNSIGNED )

Ejemplo:

mysql> describe `test`;
+-------+------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+------------------+------+-----+---------+-------+
| id | int(20) unsigned | YES | | NULL | |
+-------+------------------+------+-----+---------+-------+
1 row in set (0,00 sec)
mysql> INSERT INTO `test` (`id`) VALUES (401421228216);
ERROR 1264 (22003): Out of range value for column ''id'' at row 1
mysql> SET sql_mode = '''';
Query OK, 0 rows affected, 1 warning (0,00 sec)
mysql> INSERT INTO `test` (`id`) VALUES (401421228216);
Query OK, 1 row affected, 1 warning (0,06 sec)
mysql> SELECT * FROM `test`;
+------------+
| id |
+------------+
| 4294967295 |
+------------+
1 row in set (0,00 sec)

• Si tiene BIGINT(20) para el sistema, esto significa asignar en la memoria un mínimo de 20 bits. Pero si inserta un valor mayor que 2^20 , se almacenará con éxito, si es menor que BIGINT(64) -> 9223372036854775807 (o 2 * BIGINT(64) -> 18446744073709551615 para UNSIGNED )

Ejemplo:

mysql> describe `test`;
+-------+---------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+---------------------+------+-----+---------+-------+
| id | bigint(20) unsigned | YES | | NULL | |
+-------+---------------------+------+-----+---------+-------+
1 row in set (0,00 sec)
mysql> INSERT INTO `test` (`id`) VALUES (401421228216);
Query OK, 1 row affected (0,04 sec)
mysql> SELECT * FROM `test`;
+--------------+
| id |
+--------------+
| 401421228216 |
+--------------+
1 row in set (0,00 sec)

Answer 3

Quería agregar un punto más, si está almacenando un número realmente grande como 902054990011312, entonces uno puede ver fácilmente la diferencia entre INT(20) y BIGINT(20) . Es recomendable almacenar en BIGINT .

Answer 4

Vamos a dar un ejemplo para int (10) uno con la palabra clave zerofill, uno no, la tabla le gusta eso:

create table tb_test_int_type(
int_10 int(10),
int_10_with_zf int(10) zerofill,
unit int unsigned
);

Vamos a insertar algunos datos:

insert into tb_test_int_type(int_10, int_10_with_zf, unit)
values (123456, 123456,3147483647), (123456, 4294967291,3147483647)
;

Entonces

select * from tb_test_int_type;
# int_10, int_10_with_zf, unit
''123456'', ''0000123456'', ''3147483647''
''123456'', ''4294967291'', ''3147483647''

Podemos ver eso

• con la palabra clave zerofill , num menos de 10 llenará 0, pero sin zerofill no lo hará

• En segundo lugar, con la palabra clave zerofill , int_10_with_zf pasa a ser unsigned int type, si inserta un signo menos, obtendrá el error Out of range value for column..... Pero puedes insertar menos en int_10. Además, si inserta 4294967291 en int_10 obtendrá el error Out of range value for column.....

Conclusión:

1. int (X) sin la palabra clave zerofill , es igual al rango int -2147483648 ~ 2147483647

2. int (X) con la palabra clave zerofill , el campo es igual al rango int sin signo 0 ~ 4294967295, si la longitud de num es menor que X, llenará 0 a la izquierda

Answer 5

Ver http://dev.mysql.com/doc/refman/8.0/en/numeric-types.html

• INT es un entero de cuatro bytes con signo.

• BIGINT es un entero con signo de ocho bytes.

Cada uno de ellos no acepta más ni menos valores de los que se pueden almacenar en sus respectivos bytes. Eso significa 2 ³² valores en un INT y 2 ⁶⁴ valores en un BIGINT .

El 20 en INT(20) y BIGINT(20) significan casi nada. Es una pista para el ancho de la pantalla. No tiene nada que ver con el almacenamiento ni con el rango de valores que aceptará la columna.

Prácticamente, afecta solo a la opción ZEROFILL :

CREATE TABLE foo ( bar INT(20) ZEROFILL );
INSERT INTO foo (bar) VALUES (1234);
SELECT bar from foo;
+----------------------+
| bar |
+----------------------+
| 00000000000000001234 |
+----------------------+

Es una fuente común de confusión para los usuarios de MySQL ver INT(20) y suponer que es un límite de tamaño, algo análogo a CHAR(20) . Este no es el caso.

Answer 6

Quote :

La especificación "BIGINT (20)" no es un límite de dígitos. Simplemente significa que cuando se muestren los datos, si usa menos de 20 dígitos, se rellenará con ceros. 2 ^ 64 es el límite estricto para el tipo BIGINT, y tiene 20 dígitos, por lo tanto, BIGINT (20) solo significa que menos de 10 ^ 20 se rellenarán con espacios en pantalla.