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

Question

Je me demandais quelle était la différence entre BigInt , MediumInt y Int sont... il semblerait évident qu'ils permettent des nombres plus importants ; cependant, je peux faire une Int(20) ou un BigInt(20) et il semblerait que ce ne soit pas nécessairement une question de taille.

Un avis serait le bienvenu, je suis juste un peu curieux. J'ai utilisé MySQL pendant un certain temps et en essayant d'appliquer les besoins de l'entreprise lors du choix des types, mais je n'ai jamais compris cet aspect.

Answer 1

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

• INT est un nombre entier signé de quatre octets.

• BIGINT est un nombre entier signé de huit octets.

Ils n'acceptent ni plus ni moins de valeurs que celles qui peuvent être stockées dans leur nombre d'octets respectif. Cela signifie que 2 32 dans un INT et 2 64 dans un BIGINT .

Les 20 en INT(20) y BIGINT(20) ne signifie presque rien. C'est une indication de la largeur d'affichage. Cela n'a rien à voir avec le stockage, ni avec la gamme de valeurs que cette colonne acceptera.

En pratique, cela n'affecte que le ZEROFILL option :

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

+----------------------+
| bar                  |
+----------------------+
| 00000000000000001234 |
+----------------------+

C'est une source commune de confusion pour les utilisateurs de MySQL de voir INT(20) et supposer que c'est une limite de taille, quelque chose d'analogue à CHAR(20) . Ce n'est pas le cas.

Answer 2

Le nombre entre parenthèses dans une déclaration de type est largeur d'affichage qui n'a rien à voir avec la gamme de valeurs pouvant être stockées dans un type de données. Ce n'est pas parce que vous pouvez déclarer Int(20) ne signifie pas que vous pouvez y stocker des valeurs allant jusqu'à 10^20 :

[...] Cette largeur d'affichage optionnelle peut être utilisée par les applications pour afficher des valeurs entières dont la largeur est inférieure à celle spécifiée pour la colonne, en les faisant précéder d'espaces à gauche. ...

La largeur d'affichage ne limite pas la plage de valeurs qui peuvent être stockées dans la colonne, ni le nombre de chiffres qui sont affichés pour les valeurs dont la largeur dépasse 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 situées 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 qui peuvent être stockées dans chaque type de données MySQL, voir aquí .

Answer 3

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 complétées par des zéros. 2^64 est la limite stricte 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 remplacé par des espaces à l'affichage.

Answer 4

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

Dans les exemples, j'utiliserai 401421228216 qui est 101110101110110100100011101100010111000 (longueur 39 personnages)

• 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 qui est plus grande que 2^20 il sera stocké avec succès, seulement s'il est inférieur à 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 qui est plus grande que 2^20 il sera stocké avec succès, s'il est inférieur à 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)

Answer 5

Donnons un exemple pour int(10), l'un avec le mot clé zerofill, l'autre non, la table aime cela :

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

Insérons des 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'

On peut voir que

• avec mot-clé zerofill , les chiffres inférieurs à 10 rempliront 0, mais sans zerofill ça ne le fera pas

• Ensuite, avec le mot-clé zerofill int_10_with_zf devient un type d'int non signé, si vous insérez un moins vous obtiendrez une erreur. Out of range value for column..... . Mais vous pouvez insérer des moins dans int_10. De même, si vous insérez 4294967291 dans int_10, vous obtiendrez une erreur. Out of range value for column.....

Conclusion :

1. int(X) sans mot-clé zerofill est égal à int range -2147483648~2147483647

2. int(X) avec le mot clé zerofill le champ est égal à un int non signé de 0~4294967295, si la longueur de num est inférieure à X, il remplira 0 à gauche.