Types dans MySQL: BigInt (20) vs Int (20)

Le nombre entre parenthèses dans une déclaration de type est display width, ce qui n'est pas lié à la plage de valeurs pouvant être stockées dans un type de données. Ce n'est pas parce que vous pouvez déclarer Int(20) que vous pouvez y stocker des valeurs allant jusqu'à 10^20:

[...] Cette largeur d'affichage facultative peut être utilisée par les applications pour afficher des valeurs entières ayant une largeur inférieure à la largeur spécifiée pour la colonne en les remplissant à gauche avec des espaces. ...

La largeur d'affichage fait ne pas contraindre la plage de valeurs qui peuvent être stockées dans la colonne, ni le nombre de chiffres qui s'affichent pour les valeurs ayant une largeur supérieure à celle spécifiée pour la colonne. par exemple, une colonne spécifiée comme SMALLINT(3) a la plage SMALLINT habituelle de -32768 à 32767, et les valeurs en dehors de la plage autorisée par trois caractères sont affichées en utilisant plus de trois caractères.

Pour une liste des valeurs maximales et minimales pouvant être stockées dans chaque type de données MySQL, voir ici.

Citation:

La spécification" BIGINT(20) " n'est pas une limite de chiffres. Cela signifie simplement que lorsque les données sont affichées, si elles utilisent moins de 20 chiffres, elles seront remplies de zéros. 2^64 est la limite dure pour le type BIGINT, et a 20 chiffres lui-même, donc BIGINT(20) signifie simplement que tout ce qui est inférieur à 10^20 sera rembourré à gauche avec des espaces affichés.

Pour autant que je sache, il n'y a qu'une petite différence lorsque vous essayez d'insérer une valeur qui est hors de portée.

Dans les exemples que je vais utiliser 401421228216, qui est 101110101110110100100011101100010111000 (longueur 39 caractères)

• Si vous avez INT(20) pour le système, cela signifie allouer en mémoire un minimum de 20 bits. Mais si vous insérez une valeur supérieure à 2^20, elle sera stockée avec succès, seulement si elle est inférieure à INT(32) -> 2147483647 (ou 2 * INT(32) -> 4294967295 pour UNSIGNED)

Exemple:

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 vous avez BIGINT(20) pour le système, cela signifie allouer en mémoire un minimum de 20 bits. Mais si vous insérez une valeur supérieure à 2^20, elle sera stockée avec succès, si elle est inférieure à BIGINT(64) -> 9223372036854775807 (ou 2 * BIGINT(64) -> 18446744073709551615 pour UNSIGNED)

Exemple:

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)

Je voulais ajouter un point de plus, si vous stockez un très grand nombre comme 902054990011312 alors on peut facilement voir la différence de INT(20) et BIGINT(20). Il est conseillé de stocker dans BIGINT.

Donnons un exemple pour int (10) un avec le mot-clé zerofill, un pas, la table aime ça:

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

Insérons quelques données:

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

Puis

select * from tb_test_int_type; 

# int_10, int_10_with_zf, unit
'123456', '0000123456', '3147483647'
'123456', '4294967291', '3147483647'

, Nous pouvons voir que

• Avec le mot-clé zerofill, num moins de 10 remplira 0, mais sans zerofill, il ne sera pas

• Deuxièmement, avec le mot-clé zerofill, int_10_with_zf devient unsigned int type, si vous insérez un moins vous obtiendrez une erreur Out of range value for column...... Mais vous pouvez insérer moins à int_10. Aussi, si vous insérez 4294967291 à int_10 vous obtiendrez une erreur Out of range value for column.....

Conclusion:

1. Int(X) sans le mot clé zerofill, est égal à int gamme -2147483648~2147483647

2. Int(X) avec le mot-clé zerofill, le champ est égal à unsigned int gamme 0 à 4294967295, si la longueur est inférieure à X, il remplira 0 à gauche