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

El número entre paréntesis en una declaración de tipo es display width, 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:

[...] Este ancho de visualización opcional puede ser utilizado por aplicaciones para mostrar valores enteros que tienen un ancho menor que el ancho especificado para la columna por la izquierda-rellenándolos con espacios. ...

El ancho de la pantalla hace no restringe el rango de valores que se pueden almacenar en la columna, ni el número de dígitos que se muestran para los valores que tienen un ancho superior al especificado para la columna. Por ejemplo, una columna especificada como SMALLINT(3) tiene el rango habitual de SMALLINT de -32768 a 32767, y los valores fuera del rango permitido por tres caracteres se muestran usando 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 aquí.

Cita :

La especificación "BIGINT(20)" no es un límite de dígitos. Solo significa que cuando se muestran los datos, si usa menos de 20 dígitos, se rellenará a la izquierda con ceros. 2^64 es el límite duro para el tipo BIGINT, y tiene 20 dígitos en sí, por lo tanto BIGINT(20) solo significa que todo menos de 10^20 será rellenado con espacios en pantalla.

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

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

• Si tiene INT(20) para el sistema esto significa asignar en memoria un mínimo de 20 bits. Pero si va a insertar un valor que sea mayor que 2^20, se almacenará correctamente, 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 memoria un mínimo de 20 bits. Pero si va a insertar un valor que sea mayor que 2^20, se almacenará correctamente, 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)

Quería añadir un punto más es, si usted está almacenando un número realmente grande como 902054990011312 entonces uno puede ver fácilmente la diferencia de INT(20) y BIGINT(20). Se recomienda conservar en BIGINT.

Vamos a dar un ejemplo para int(10) uno con palabra clave zerofill, uno no, a 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 que

• Con la palabra zerofill, num menos de 10 llenará 0, pero sin zerofill no

• En segundo lugar con keyword zerofill, int_10_with_zf se convierte en unsigned int type, si inserta un menos obtendrá error Out of range value for column...... Pero puedes insertar menos a int_10. También si inserte 4294967291 a int_10 obtendrá un error Out of range value for column.....

Conclusión:

1. Int (X) sin palabra clave zerofill, es igual a 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