web-dev-qa-db-fra.com

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

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

Un aperçu serait génial, juste un peu curieux. J'utilise MySQL depuis un moment et j'essaie de prendre en compte les besoins de l'entreprise lors du choix des types, mais je n'ai jamais compris cet aspect.

mysqltypes
195
Parris

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

  • INT est un entier signé de quatre octets.

  • BIGINT est un entier signé de huit octets.

Ils n'acceptent chacun ni plus ni moins de valeurs que ce qui peut être stocké dans leur nombre d'octets respectif. Cela signifie 232 valeurs dans un INT et 264 valeurs dans un BIGINT.

Le 20 dans INT(20) et BIGINT(20) signifie presque rien. C'est un indice pour la largeur d'affichage. Cela n'a rien à voir avec le stockage, ni la plage de valeurs que la colonne acceptera.

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

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

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

Les utilisateurs de MySQL voient souvent INT(20) avec une limite de taille, ce qui est analogue à CHAR(20). Ce n'est pas le cas.

415
Bill Karwin

Le nombre entre parenthèses dans une déclaration de type est largeur d'affichage , qui n'est pas lié à la plage de valeurs pouvant être stockée dans un type de données. Le fait de déclarer Int(20) ne signifie pas 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 les valeurs entières ayant une largeur inférieure à la largeur spécifiée pour la colonne en les remplissant à gauche d'espaces. ...

La largeur d'affichage ne limite pas la plage de valeurs pouvant être stockée dans la colonne, ni le nombre de chiffres affichés pour les valeurs dont la largeur dépasse celle spécifiée pour la colonne. Par exemple, une colonne spécifié 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 avec plus de trois caractères.

Pour obtenir la liste des valeurs maximales et minimales pouvant être stockées dans chaque type de données MySQL, reportez-vous à la section here.

38
John Feminella

Citation :

La spécification "BIGINT (20)" n'est pas une limite en chiffres. Cela signifie simplement que lorsque les données sont affichées, si elles utilisent moins de 20 chiffres, elles sont complétées à gauche par des zéros. 2 ^ 64 est la limite stricte pour le type BIGINT et a 20 chiffres, donc BIGINT (20) signifie simplement que tout ce qui est inférieur à 10 ^ 20 sera rempli à gauche avec des espaces à l'écran.

13
OMG Ponies

Autant que je sache, il n'y a qu'une petite différence, c'est lorsque vous essayez d'insérer une valeur hors limites.

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

  • Si vous avez INT(20) pour le système, cela signifie que vous allouez en mémoire au moins 20 bits. Mais si vous insérez une valeur plus grande que 2^20, elle sera stockée avec succès, mais 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 que vous allouez en mémoire au moins 20 bits. Mais si vous insérez une valeur plus grande que 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)
2
Sergey Podgornyy

Je voulais ajouter un point supplémentaire: si vous stockez un très grand nombre comme 902054990011312, vous pouvez facilement voir la différence entre INT(20) et BIGINT(20). Il est conseillé de stocker dans BIGINT.

1
Debasis Sabat

Donnons un exemple pour int (10) avec le mot-clé zerofill, mais pas la table, elle 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) 
;

Ensuite

select * from tb_test_int_type; 

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

On peut voir ça

  • avec le mot clé zerofill, num inférieur à 10 remplira 0, mais sans zerofill il ne le fera pas

  • Deuxièmement, avec le mot clé zerofill, int_10_with_zf devient un type int non signé, si vous insérez un signe moins, vous obtiendrez l'erreur Out of range value for column...... Mais vous pouvez insérer moins à int_10. De plus, si vous insérez 4294967291 dans int_10, vous obtiendrez l'erreur Out of range value for column.....

Conclusion:

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

  2. int (X) avec le mot clé zerofill, le champ est égal à unsigned int, plage comprise entre 0 et 4294967295; si la longueur de num est inférieure à X, la valeur 0 sera remplie à gauche

0
Jayhello