Quelle est la différence entre MySQL et SQL Server

Différences : 1. mysql prend en charge les types enum et set, mais le serveur SQL ne le prend pas en charge ; 2. l'instruction d'incrémentation de mysql est "AUTO_INCREMENT", tandis que le serveur SQL est "identity(1,1)" ; serveur SQL L'instruction de limite n'est pas prise en charge.

(Tutoriel recommandé : Tutoriel vidéo MySQL)

Différence 1

Mysql prend en charge l'énumération, et définissez le type, le serveur SQL ne prend pas en charge

mysql ne prend pas en charge le type nchar, nvarchar, ntext

l'instruction d'incrémentation de MySQL est AUTO_INCREMENT et le serveur SQL est Identity(1,1)

La valeur par défaut de l'instruction de création de table du serveur SQL est ((0)), et deux parenthèses ne sont pas autorisées dans MySQL

Mysql doit spécifier le type de stockage de la table

Le L'identifiant du serveur SQL est [], [type] signifie qu'il est différent des mots-clés, mais mysql est `, qui est le symbole à gauche du bouton 1

Le serveur SQL prend en charge la méthode getdate() pour obtenir l'identifiant du serveur SQL. heure et date actuelles. Cependant, MySQL peut être divisé en type de date et en type d'heure. La date actuelle est cur_date(), et l'heure complète actuelle est la fonction now()

mysql prend en charge l'insertion dans la table1 set t1. = '', t2 = '', mais le serveur SQL ne prend pas en charge l'écriture comme celle-ci

mysql prend en charge l'insertion dans les valeurs tabl1 (1,1), (1,1), (1,1), (1,1), (1,1), (1 ,1), (1,1)

Le serveur SQL ne prend pas en charge l'instruction limit, ce qui est très regrettable. Vous ne pouvez utiliser top que pour remplacer. limit 0,N et la fonction row_number() over() pour remplacer limit N,M

mysql doit spécifier un type de moteur de stockage pour chaque table lors de la création d'une table, et le serveur SQL ne prend en charge qu'un seul moteur de stockage

mysql ne prend pas en charge le type datetime dont la valeur par défaut est l'heure actuelle (mssql est très facile à faire), dans mysql, utilisez le type timestamp

dans le serveur SQL pour vérifier s'il y a cette table, puis supprimez-la. Vous devez faire ceci :

si existe (sélectionnez * dans dbo.sysobjects où id = object_id(N'uc_newpm') et OBJECTPROPERTY(id, N'IsUserTable') = 1. )

Mais dans MySQL, vous n'avez besoin que de DROP TABLE IF EXISTS cdb_forums;

mysql prend en charge le type entier non signé, alors mssql peut stocker deux fois plus de nombre maximum que mssql qui ne prend pas en charge les types non signés

mysql ne prend pas en charge le type varchar(max) très pratique dans mssql. Ce type peut être utilisé dans mssql Pour le stockage général des données, vous pouvez également effectuer un stockage de données blob

Mysql crée un fichier non clusterisé. index, il vous suffit de le spécifier comme clé lors de la création de la table, par exemple : KEY displayorder (fid, displayorder) Dans mssql vous devez : créer un index non clusterisé unique index_uc_protectedmembers_username_appid sur dbo.uc_protectedmembers

(username asc, appid asc)

Le type de champ de texte mysql n'autorise pas une valeur par défaut

La longueur totale du champ d'une table dans mysql Pas plus de 65XXX.

Une différence très superficielle est que l'installation de mysql est très simple et que la taille du fichier n'est que de 110 Mo (version sans installation). Par rapport au géant Microsoft, la progression de l'installation est tout simplement...

mysql Il existe plusieurs meilleurs outils de gestion, notamment mysql_front et la suite officielle, mais ils ne sont pas aussi faciles à utiliser que SSMS. C'est une grosse lacune de mysql.

Les procédures stockées de MySQL n'apparaissent que dans la dernière version, et la stabilité et les performances peuvent ne pas être aussi bonnes que celles de mssql.

Sous la même pression de charge, mysql consomme moins de CPU et de mémoire, alors que mssql est en effet très consommateur de ressources.

La façon dont PHP connecte mysql et mssql est similaire, il vous suffit de remplacer le mysql de la fonction par mssql.

Mysql prend en charge les types de date, d'heure et d'année, et mssql ne prend en charge que la date et l'heure en 2008.

Différence 2

1. Définition des données

Commandes de base pour les opérations de base de données

Mysql :

créer le nom de la base de données Créer une base de données

🎜 >

utilisez le nom de la base de données ; sélectionnez la base de données

déposez le nom de la base de données et supprimez la base de données directement sans rappel –

CREATE TABLE --Créez une table de base de données

2.1 Analyse de différence de contrainte PRIMARY KEY (clé primaire) :

Mysql:    
2.1.1 创建primary key
			CREATE TABLE Persons
			(
			Id_P  int  NOT NULL,
			LastName varchar(255) NOT NULL,
			FirstName varchar(255),
			Address varchar(255),
			City varchar(255),
			PRIMARY KEY (Id_P)               //声明主健写在最后
			)
			SqlServer：
			CREATE TABLE Persons
			(
			Id_P int NOT NULL PRIMARY KEY,     //声明主健 紧跟列后
			LastName varchar(255) NOT NULL,
			FirstName varchar(255),
			Address varchar(255),
			City varchar(255)
			)
			但是如果表存在，之后给表加主健时：
			Mysql 和SqlServer
			ALTER TABLE Persons ADD PRIMARY KEY (Id_P)
2.1.2撤销 PRIMARY KEY 约束
			MySQL:
			ALTER TABLE Persons DROP PRIMARY KEY
			SQL Server
			ALTER TABLE Persons DROP CONSTRAINT pk_PersonID
2.1.3 创建外健约束
			MySQL:
			CREATE TABLE Orders
			(
			O_Id  int NOT NULL,
			OrderNo int NOT NULL,
			Id_P int,
			PRIMARY KEY (O_Id),
			FOREIGN  KEY (Id_P)  REFERENCES  Persons(Id_P)    //写在最后
			)

SQL Server ：
			CREATE TABLE Orders
			(
			O_Id  int  NOT NULL  PRIMARY KEY,
			OrderNo  int NOT NULL,
			Id_P  int  FOREIGN KEY REFERENCES Persons(Id_P)    //顺序不同
			)
			如果在 "Orders" 表已存在的情况下为 "Id_P" 列创建 FOREIGN KEY 约束，请使用下面的 SQL：
			MySQL / SQL Server 
			ALTER  TABLE  Orders ADD  FOREIGN KEY  (Id_P) REFERENCES  Persons(Id_P)
2.1.4 撤销外健约束
			MySQL:
			ALTER TABLE Orders DROP  FOREIGN KEY f k_PerOrders
			SQL Server 
			ALTER TABLE Orders DROP CONSTRAINT  fk_PerOrders

2.2 Analyse de différence de contrainte UNIQUE (unique, unique)

La contrainte UNIQUE identifie de manière unique la table de base de données par enregistrement.

Les contraintes UNIQUE et PRIMARY KEY fournissent des garanties d'unicité pour une colonne ou un ensemble de colonnes.

PRIMARY KEY a automatiquement défini des contraintes UNIQUE.

Notez que vous pouvez avoir plusieurs contraintes UNIQUE par table, mais vous ne pouvez avoir qu'une seule contrainte PRIMARY KEY par table.

2.2.1 Créer des contraintes UNIQUES

MySQL :

CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
Prénom varchar(255),
Adresse varchar(255),
Ville varchar(255),
UNIQUE (Id_P) //Écrire à la fin
)

SQL Server
CREATE TABLE Persons
(
Id_P int NOT NULL UNIQUE, //En suivant la colonne
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Adresse varchar(255),
Ville varchar(255)
)

2.2.2 Révoquer la contrainte UNIQUE

MySQL :

ALTER TABLE Personnes DROP INDEX uc_PersonID

SQL Server

ALTER TABLE Persons DROP CONSTRAINT uc_PersonID

2.3 Contrainte CHECK

La contrainte CHECK est utilisée pour limiter les valeurs ​​dans la plage de valeurs de la colonne.

Si une contrainte CHECK est définie sur une seule colonne, seules des valeurs spécifiques sont autorisées pour cette colonne.

如果对一个表定义 CHECK 约束，那么此约束会在特定的列中对值进行限制。

2.3.1 创建 CHECK约束

下面的 SQL 在 "Persons" 表创建时为 "Id_P" 列创建 CHECK 约束。CHECK 约束规定 "Id_P" 列必须只包含大于 0 的整数。
My SQL:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CHECK (Id_P>0)                       //写在最后
)

SQL Server 
CREATE TABLE Persons
(
Id_P int NOT NULL CHECK (Id_P>0),    //紧跟列后
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)

如果需要命名 CHECK 约束，以及为多个列定义 CHECK 约束，请使用下面的 SQL 语法：

MySQL / SQL Server:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT chk_Person CHECK (Id_P>0 AND City='Sandnes') //多个条件
)

如果在表已存在的情况下为 “Id_P” 列创建 CHECK 约束，请使用下面的 SQL：

MySQL / SQL Server:
ALTER TABLE Persons ADD CHECK (Id_P>0)

2.3.2 撤销 CHECK约束

Sqlserver:
ALTER  TABLE  Persons  DROP CONSTRAINT chk_Person
Mysql我没有找到怎么删除。

2.4 DEFAULT 约束（系统默认值）

DEFAULT 约束用于向列中插入默认值。

如果没有规定其他的值，那么会将默认值添加到所有的新纪录。

2.4.1 创建DEFAULT约束

下面的 SQL 在 "Persons" 表创建时为 "City" 列创建 DEFAULT 约束：
My SQL / SQL Server:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255) DEFAULT 'Sandnes'     //紧跟列后，默认值字符串Sandnes
)

通过使用类似 GETDATE() 这样的函数，DEFAULT 约束也可以用于插入系统值：

CREATE TABLE Orders
(
Id_O int NOT NULL,
OrderNo int NOT NULL,
Id_P int,
OrderDate date DEFAULT GETDATE()   //紧跟列后，函数
)

如果在表已存在的情况下为 “City” 列创建 DEFAULT 约束，请使用下面的 SQL：

MySQL:
ALTER  TABLE  Persons  ALTER  City  SET  DEFAULT  'SANDNES'

SQL Server:
ALTER  TABLE  Persons  ALTER  COLUMN  City  SET  DEFAULT  'SANDNES'

2.4 .2 撤消DEFAULT约束

MySQL:
ALTER  TABLE  Persons  ALTER  City  DROP  DEFAULT

SQL Server:
ALTER  TABLE  Persons  ALTER  COLUMN  City  DROP  DEFAULT

2.5 索引区别

CREATE INDEX 语句

CREATE INDEX 语句用于在表中创建索引。

在不读取整个表的情况下，索引使数据库应用程序可以更快地查找数据。

在表上创建一个简单的索引。允许使用重复的值：

CREATE INDEX index_name ON table_name (column_name) //“column_name” 规定需要索引的列。

在表上创建一个唯一的索引。唯一的索引意味着两个行不能拥有相同的索引值。

CREATE UNIQUE INDEX index_name ON table_name (column_name)

Mysql和SqlServer的创建索引都是一致的，但是在删除索引方面却有区别:

SqlServer: DROP INDEX table_name.index_name

Mysql: ALTER TABLE table_name DROP INDEX index_name

2.6 主键自动增加的区别

mySql的主键自动增加是用auto_increment字段，sqlServer的自动增加则是identity字段.

Auto-increment 会在新纪录插入表中时生成一个唯一的数字。

我们通常希望在每次插入新纪录时，自动地创建主键字段的值。

我们可以在表中创建一个 auto-increment 字段。

关于 MySQL 的语法
下列 SQL 语句把 "Persons" 表中的 "P_Id" 列定义为 auto-increment 主键：
CREATE TABLE Persons
(
P_Id int NOT NULL AUTO_INCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (P_Id)
)
MySQL 使用 AUTO_INCREMENT 关键字来执行 auto-increment 任务。
默认地，AUTO_INCREMENT 的开始值是 1，每条新纪录递增 1。
要让 AUTO_INCREMENT 序列以其他的值起始，请使用下列 SQL 语法：
ALTER TABLE Persons AUTO_INCREMENT=100

关于 SQL Server 的语法
下列 SQL 语句把 "Persons" 表中的 "P_Id" 列定义为 auto-increment 主键：
CREATE TABLE Persons
(
P_Id int PRIMARY KEY IDENTITY,或则是写成P_id int primary key identity (1,1),
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
MS SQL 使用 IDENTITY 关键字来执行 auto-increment 任务。
默认地，IDENTITY 的开始值是 1，每条新纪录递增 1。
要规定 "P_Id" 列以 20 起始且递增 10，请把 identity 改为 IDENTITY(20,10)

2.7 MySQL支持enum,和set类型，SQL Server不支持
2.8 MySQL不支持nchar,nvarchar,ntext类型

二、数据操作

2.1 limit和top

SQL SERVER : select   top   8   *   from   table1 
MYSQL: select   *   from   table1   limit   5或则是 limit 0,5; 
注意，在MySQL中的limit不能放在子查询内，limit不同与top,它可以规定范围 limit a,b——范围a-b

2.2 ISNULL()函数

SqlServer:
select * from test where isnull(no,0)=0;
MySQL
MySQL 可以使用 ISNULL() 函数。不过它的工作方式与微软的 ISNULL() 函数有点不同。
在 MySQL 中，我们可以使用 IFNULL() 函数，就像这样：
mysql> select * from test where ifnull(no,0)=0;
row in set (0.03 sec)

2.3 select查询

SELECT * FROM tablename

2.4 insert 插入

INSERT INTO table(col1,col2) values(value1,value2);

MySQL支持insert into table1 set t1 = ‘’, t2=‘’,但是MSSQL不支持这样写

2.5 update 修改

Update tablename set col=”value”;

2.6 delete 删除

Delete from tablename;

三、语法定义

3.1 注释符区别

SqlServer的注释符为 --和/**/

MySql的注释符为 --和/**/和#

3.2 识别符的区别

MS SQL识别符是[],[type]表示他区别于关键字，但是MySQL却是 `，也就是按键1左边的那个符号

3.3存储过程的区别（未经验证，从网上找的）

(1) mysql的存储过程中变量的定义去掉@;

(2) SQLServer存储过程的AS在MySql中需要用begin …end替换

(3) Mysql的Execute对应SqlServer的exec;

(注意：必须想下面这样调用)

Set @cnt=’select * from 表名’;

Prepare str from @cnt;

Execute str;

(4) MySql存储过程调用其他存储过程用call

Call 函数名（即SQLServer的存储过程名）（’参数1’,’参数2’,……）

(5) select @a=count() from VW_Action 在mySql中修改为：select count() from VW_Action into @a;

(6) MySQL视图的FROM子句不允许存在子查询，因此对于SQL Server中FROM子句带有子查询的视图，需要手工进行迁移。可通过消除FROM子句中的子查询，或将FROM子句中的子查询重构为一个新的视图来进行迁移。

(7) )MySql存储过程中没有return函数，在MySql中可以用循环和out参数代替

  If EXISTS(SELECT * FROM T_Chance WHERE FCustID=CostomerID)  return 0
改写为：
（在参数中定义一个out变量：out temp varchar(100);）
    BEGIN
        Loop1:loop
    SELECT count(*) FROM T_Chance WHERE FCustID=CostomerID int @cnt
    If @cnt>0 then
    begin
        set temp=0;
        leave loop1;
    end;
    end if
    end loop loop1;

(8) mysql的uuid()对应sql的GUID();

(9) MySql的out对应SQLServer的output,且mysql 的out要放在变量的前面，SQLServer的output放在变量后面：
MySql out,in,inout的区别——
MySQL 存储过程 “in” 参数：跟 C 语言的函数参数的值传递类似， MySQL 存储过程内部可能会修改此参数，但对 in 类型参数的修改，对调用者（caller）来说是不可见的（not visible）。
MySQL 存储过程 “out” 参数：从存储过程内部传值给调用者。在存储过程内部，该参数初始值为 null，无论调用者是否给存储过程参数设置值。
MySQL 存储过程 inout 参数跟 out 类似，都可以从存储过程内部传值给调用者。不同的是：调用者还可以通过 inout 参数传递值给存储过程。

3.4字符串连接

SQLServer: Temp=’select * from ’+’tablename’+…+…
MySql:Temp=concat(’select * from’, ’tablecname’,…,…)

四、函数和数据类型的区别

4.1 Date 函数

MySQL Date 函数

• NOW() 返回当前的日期和时间
• CURDATE() 返回当前的日期
• CURTIME() 返回当前的时间 、
• DATE() 提取日期或日期/时间表达式的日期部分
• EXTRACT() 返回日期/时间按的单独部分
• DATE_ADD() 给日期添加指定的时间间隔
• DATE_SUB() 从日期减去指定的时间间隔
• DATEDIFF() 返回两个日期之间的天数
• DATE_FORMAT() 用不同的格式显示日期/时间

SQL Server Date 函数

• GETDATE() 返回当前日期和时间
• DATEPART() 返回日期/时间的单独部分
• DATEADD() 在日期中添加或减去指定的时间间隔
• DATEDIFF() 返回两个日期之间的时间
• CONVERT() 用不同的格式显示日期/时间

4.2 Date 数据类型

MySQL 使用下列数据类型在数据库中存储日期或日期/时间值：
DATE - 格式 YYYY-MM-DD 
DATETIME - 格式: YYYY-MM-DD HH:MM:SS 
TIMESTAMP - 格式: YYYY-MM-DD HH:MM:SS 
YEAR - 格式 YYYY 或 YY

SQL Server 使用下列数据类型在数据库中存储日期或日期/时间值：
DATE - 格式 YYYY-MM-DD 
DATETIME - 格式: YYYY-MM-DD HH:MM:SS 
SMALLDATETIME - 格式: YYYY-MM-DD HH:MM:SS 
TIMESTAMP - 格式: 唯一的数字

五、性能比较
（1）一个很表面的区别就是MySQL的安装特别简单，而且文件大小才110M(非安装版)，相比微软这个庞然大物，安装进度来说简直就是…
（2）MySQL的管理工具有几个比较好的，MySQL_front,和官方那个套件，不过都没有SSMS的使用方便，这是MySQL很大的一个缺点。
（3）MySQL的存储过程只是出现在最新的版本中，稳定性和性能可能不如MS SQL。
（4）同样的负载压力，MySQL要消耗更少的CPU和内存，MS SQL的确是很耗资源。

1、把主键定义为自动增长标识符类型
MySql
在mysql中，如果把表的主键设为auto_increment类型，数据库就会自动为主键赋值。例如：
create table customers(id int auto_increment primary key not null, name varchar(15));

J'ai récemment travaillé sur la conversion de mssql en mysql, j'ai résumé une expérience et je la partage avec vous.
Parallèlement, ceux-ci seront continuellement mis à jour. J'espère également que vous pourrez en ajouter davantage.
mysql prend en charge les types enum et set, le serveur SQL ne prend pas en charge
mysql ne prend pas en charge les types nchar, nvarchar, ntext
l'instruction d'incrémentation de mysql est AUTO_INCREMENT, tandis que mssql est Identity(1,1)
msms La valeur par défaut de l'instruction de création de table est ((0)), et deux parenthèses ne sont pas autorisées dans MySQL
Mysql doit spécifier le type de stockage de la table
L'identifiant mssql est [], [type] Cela signifie que c'est différent des mots-clés, mais mysql est `, qui est le symbole à gauche du bouton 1
mssql prend en charge la méthode getdate() pour obtenir l'heure et la date actuelles, mais mysql peut être divisé en type de date et le type d'heure. Pour obtenir la date actuelle, c'est cur_date(), l'heure complète actuelle est la fonction now()
mssql ne prend pas en charge l'instruction replace into, mais dans la dernière version de sql20008, la syntaxe de fusion est également prise en charge
mysql prend en charge l'insertion dans la table1 set t1 = '', t2 = ' ' , mais mssql ne prend pas en charge l'écriture comme celle-ci
mysql prend en charge l'insertion dans les valeurs tabl1 (1,1), (1,1), (1 ,1), (1,1), (1,1), (1, 1), (1,1)
mssql ne prend pas en charge l'instruction limit, ce qui est très regrettable. Vous ne pouvez utiliser top que pour remplacer. limit 0,N et la fonction row_number() over() pour remplacer limit N,M
lors de la création de mysql Lors de la création d'une table, vous devez spécifier un type de moteur de stockage pour chaque table, et mssql ne prend en charge qu'un seul moteur de stockage
Mysql ne prend pas en charge le type datetime dont la valeur par défaut est l'heure actuelle (mssql est facile à faire) Dans mysql, le type timestamp est utilisé
Dans mssql, vérifiez si cette table existe avant de la supprimer. pour ce faire :
si existe (sélectionnez * dans dbo.sysobjects où id = object_id(N'uc_newpm') et OBJECTPROPERTY(id, N'IsUserTable') = 1 ; le type varchar(max) très pratique dans mssql est non pris en charge. Ce type peut être utilisé à la fois pour le stockage de données générales et pour le stockage de données blob dans mssql
Pour créer un index non clusterisé dans mysql, il vous suffit de le spécifier lors de la création de la table. La clé suffit, par exemple. : KEY displayorder (fid, displayorder) Dans mssql il faut : ​​créer un index non clusterisé unique index_uc_protectedmembers_username_appid sur dbo.uc_protectedmembers
(username asc,appid asc)
Le type de champ de texte Mysql n'autorise pas les valeurs par défaut
19La longueur totale des champs d'une table dans MySQL ne dépasse pas 65XXX.
20Une différence très superficielle est que l'installation de MySQL est très simple et que la taille du fichier n'est que de 110 Mo (version sans installation). Par rapport au géant Microsoft, la progression de l'installation est tout simplement...
21Il y a). plusieurs outils de gestion pour MySQL Les meilleurs sont mysql_front et la suite officielle, mais ils ne sont pas aussi faciles à utiliser que SSMS. C'est une grosse lacune de MySQL.
22Les procédures stockées de MySQL n'apparaissent que dans la dernière version, et la stabilité et les performances peuvent ne pas être aussi bonnes que celles de mssql.
Sous la même pression de charge, mysql consomme moins de CPU et de mémoire, alors que mssql est en effet très consommateur de ressources.
24php a des méthodes similaires pour connecter mysql et mssql. Il vous suffit de remplacer le mysql de la fonction par mssql.
25mysql prend en charge les types de date, d'heure et d'année, mssql ne prend en charge que la date et l'heure en 2008.

Les types de données numériques de MySQL peuvent être grossièrement divisés en deux catégories, l'une est entière et l'autre est un nombre à virgule flottante ou décimal.
De nombreux sous-types différents sont disponibles pour chacune de ces catégories, chaque sous-type prend en charge différentes tailles de données et MySQL nous permet de spécifier si les valeurs des champs numériques sont positives ou négatives ou complétées par des zéros.

Le tableau suivant répertorie les différents types numériques, leurs plages autorisées et l'espace mémoire qu'ils occupent.

Entier :

Valeur à virgule flottante

类型	大小	范围（有符号）	范围（无符号）	用途
TINYINT	1字节	(-128，127)	(0，255)	小整数值
SMALLINT	2字节	(-32 768，32 767)	(0，65 535)	大整数值
MEDIUMINT	3 字节	(-8 388 608，8 388 607)	(0，16 777 215)	大整数值
INT/INTEGER	4字节	(-2 147 483 648，2 147 483 647)	(0，4 294 967 295)	大整数值
BIGINT	8字节	(-9 233 372 036 854 775 808，9 223 372 036 854 775 807)	(0，18 446 744 073 709 551 615)	极大整数值
FLOAT	4字节	(-3.402 823 466 E+38，1.175 494 351 E-38)	，(1.175 494 351 E-38，3.402 823 466 351 E+38)	单精度

• Valeur à virgule flottante
  DECIMAL Pour DECIMAL(M,D), si M>D, c'est M+2 sinon c'est D+2 Dépend de la valeur de M et D Dépend de la valeur de M et D Valeur décimale

  Type INT
  Les 5 principaux types d'entiers pris en charge dans MySQL sont TINYINT, SMALLINT, MEDIUMINT, INT et BIGINT. Ces types sont en grande partie les mêmes, seule la taille des valeurs qu'ils stockent diffère.
  MySQL étend la norme SQL sous la forme d'un indicateur de largeur d'affichage facultatif afin que lorsqu'une valeur est récupérée de la base de données, la valeur puisse être allongée jusqu'à une longueur spécifiée. Par exemple, spécifier qu'un champ est de type INT(6) garantit que les valeurs contenant moins de six chiffres sont automatiquement complétées par des espaces lorsqu'elles sont extraites de la base de données. Notez que l'utilisation d'un indicateur de largeur n'affecte pas la taille du champ ni la plage de valeurs qu'il peut stocker.
  Dans le cas où nous devons stocker un nombre dans un champ qui dépasse la plage autorisée, MySQL le tronquera en fonction de la fin de la plage autorisée la plus proche avant de le stocker. Une autre particularité est que MySQL changera automatiquement la valeur illégale à 0 avant de l'insérer dans la table.
  Le modificateur UNSIGNED précise que le champ ne stocke que les valeurs positives. Puisqu'il n'est pas nécessaire de sauvegarder les signes positifs et négatifs des nombres, un "bit" d'espace peut être économisé pendant le stockage. Cela augmente la plage de valeurs que ce champ peut stocker.
  Le modificateur ZEROFILL spécifie que 0 (pas un espace) peut être utilisé pour compléter la valeur de sortie. Utilisez ce modificateur pour empêcher la base de données MySQL de stocker des valeurs négatives.
  　
  　Les trois types à virgule flottante pris en charge par MySQL sont les types FLOAT, DOUBLE et DECIMAL. Le type numérique FLOAT est utilisé pour représenter des valeurs à virgule flottante simple précision, et le type numérique DOUBLE est utilisé pour représenter des valeurs à virgule flottante double précision.
  Comme les entiers, ces types prennent également des paramètres supplémentaires : un indicateur de largeur d'affichage et un indicateur de point décimal. Par exemple, l'instruction FLOAT(7,3) précise que la valeur affichée ne dépassera pas 7 chiffres, avec 3 chiffres après la virgule décimale.
  Pour une valeur avec plus de chiffres après la virgule décimale que la plage autorisée, MySQL l'arrondira automatiquement à la valeur la plus proche puis l'insérera.
  Le type de données DECIMAL est utilisé dans les calculs avec des exigences de très haute précision. Ce type vous permet de spécifier la précision et la méthode de comptage de la valeur comme paramètres de sélection. La précision fait ici référence au nombre total de chiffres significatifs enregistrés pour la valeur, tandis que la méthode de comptage indique le nombre de chiffres après la virgule décimale. Par exemple, l'instruction DECIMAL(7,3) spécifie que la valeur stockée ne dépassera pas 7 chiffres et ne dépassera pas 3 chiffres après la virgule décimale.
  L'omission des modificateurs de précision et de méthode de comptage du type de données DECIMAL entraînera la base de données MySQL à définir la précision de tous les champs identifiés comme ce type de données sur 10 et la méthode de comptage sur 0.
  Les modificateurs UNSIGNED et ZEROFILL peuvent également être utilisés avec les types de données FLOAT, DOUBLE et DECIMAL. Et l'effet est le même que celui du type de données INT.
  Types de chaînes
  MySQL fournit 8 types de chaînes de base, qui peuvent stocker n'importe quoi, d'un simple caractère à un énorme bloc de texte ou de données de chaîne binaire.

  类型	大小	用途
  CHAR	0-255字节	定长字符串
  VARCHAR	0-255字节	变长字符串
  TINYBLOB	0-255字节	不超过 255 个字符的二进制字符串
  TINYTEXT	0-255字节	短文本字符串
  BLOB	0-65 535字节	二进制形式的长文本数据
  TEXT	0-65 535字节	长文本数据
  MEDIUMBLOB	0-16 777 215字节	二进制形式的中等长度文本数据
  MEDIUMTEXT	0-16 777 215字节	中等长度文本数据
  LOGNGBLOB	0-4 294 967 295字节	二进制形式的极大文本数据
  LONGTEXT	0-4 294 967 295字节	极大文本数据

  Types CHAR et VARCHAR

  • Le type CHAR est utilisé pour les chaînes de longueur fixe et doit être défini avec un modificateur de taille entre parenthèses. Ce modificateur de taille va de
    0 à 255. Les valeurs supérieures à la longueur spécifiée seront tronquées, tandis que les valeurs inférieures à la longueur spécifiée seront complétées par des espaces.
  • Le type CHAR peut utiliser le modificateur BINARY. Lorsqu'il est utilisé dans des opérations de comparaison, ce modificateur fait que CHAR
    participe à l'opération sous forme binaire, plutôt que de la manière traditionnelle sensible à la casse.
  • Une variante du type CHAR est le type VARCHAR. Il s'agit d'un type de chaîne de longueur variable et doit également avoir un indicateur compris entre 0 et 255. La différence entre CHAR et VARCHGAR réside dans la façon dont la base de données MuSQL gère cet indicateur : CHAR traite la taille comme la taille de la valeur, et la complète avec des espaces si la longueur n'est pas suffisante.
  • Le type VARCHAR, en revanche, traite cela comme la valeur maximale et utilise uniquement la longueur réellement nécessaire pour stocker la chaîne (plus un octet supplémentaire pour stocker la longueur de la chaîne elle-même) pour stocker la valeur . Donc plus court que la longueur de l'indicateur.
  • Les types VARCHAR ne sont pas complétés par des espaces, mais les valeurs plus longues que l'indicateur sont toujours tronquées.
  • Le type VARCHAR peut modifier dynamiquement la longueur de la valeur stockée en fonction du contenu réel, donc l'utilisation du type VARCHAR peut considérablement économiser de l'espace disque et améliorer l'efficacité du stockage lorsque vous n'êtes pas sûr du nombre de caractères requis par un champ.
  • Le type VARCHAR est identique au type CHAR lors de l'utilisation du modificateur BINARY.

  Types TEXT et BLOB
  Pour les cas où la longueur du champ requise dépasse 255, MySQL propose deux types : TEXT et BLOB. Ils ont tous des sous-types différents en fonction de la taille des données stockées. Ces données volumineuses sont utilisées pour stocker des blocs de texte ou des types de données binaires tels que des images et des fichiers sonores.
  Il existe des différences de classification et de comparaison entre les types TEXT et BLOB. Le type BLOB est sensible à la casse, tandis que TEXT n'est pas sensible à la casse. Les modificateurs de taille ne sont pas utilisés sur les différents sous-types BLOB et TEXT. Les valeurs supérieures à la plage maximale prise en charge par le type spécifié seront automatiquement tronquées.
  Types de date et d'heure
  Lorsqu'il s'agit de valeurs de type de date et d'heure, MySQL propose 5 types de données différents parmi lesquels choisir. Ils peuvent être divisés en types de date et d’heure simples et en types de date et d’heure mixtes. En fonction de la précision requise, des sous-types peuvent être utilisés dans chaque sous-type, et MySQL dispose de fonctionnalités intégrées pour convertir divers formats d'entrée en un format standard.
  Taille du type
  (octets) Utilisation du format de plage
  DATE 3 1000-01-01/9999-12-31 AAAA-MM-JJ Valeur de la date
  TIME 3 '-838:59:59' /'838:59:59' HH:MM:SS Valeur temporelle ou durée
  ANNÉE 1 1901/2155 AAAA Valeur de l'année
  DATETIME 8 1000-01-01 00:00:00/9999-12- 31 23 :59:59 AAAA-MM-JJ HH:MM:SS Valeurs mixtes de date et d'heure
  TIMESTAMP 8 1970-01-01 00:00:00/Parfois en 2037 AAAAMMJJ HHMMSS Valeurs mixtes de date et d'heure, heure Cliquez

  Types DATE, TIME et TEAR
  MySQL utilise les types DATE et TEAR pour stocker des valeurs de date simples, et le type TIME pour stocker les valeurs d'heure. Ces types peuvent être décrits comme des chaînes ou des séquences d'entiers sans délimiteurs. Si elles sont décrites sous forme de chaînes, les valeurs de type DATE doivent être séparées par des traits d'union comme délimiteurs, et les valeurs de type TIME doivent être séparées par des deux-points comme délimiteurs.
  Il convient de noter qu'une valeur de type TIME sans séparateur deux-points sera comprise par MySQL comme une durée et non comme un horodatage.
  MySQL interprète également la valeur de deux nombres dans l'année d'une date ou de deux nombres saisis pour le type TEAR dans une instruction SQL dans la mesure du possible. Car toutes les valeurs de type TEAR doivent être stockées avec 4 nombres. MySQL tente de convertir une année à 2 chiffres en une valeur à 4 chiffres. Convertit les valeurs comprises entre 00 et 69 en valeurs comprises entre 2000 et 2069. Convertit les valeurs comprises entre 70-99 et 1970-1979. Si la valeur convertie automatiquement par MySQL ne répond pas à nos besoins, saisissez une année à 4 chiffres.
  Types DATEYIME et TIMESTAMP
  En plus des types de données date et heure, MySQL prend également en charge deux types mixtes, DATEYIME et TIMESTAMP. Ils peuvent stocker la date et l'heure sous forme de valeur unique. Les deux types sont couramment utilisés pour stocker automatiquement les horodatages contenant la date et l'heure actuelles et peuvent bien fonctionner dans les applications qui doivent effectuer un grand nombre de transactions de base de données et qui doivent établir une piste d'audit à des fins de débogage et de révision.
  Si nous n'attribuons pas explicitement de valeur à un champ de type TIMESTAMP, ou si une valeur nulle lui est attribuée. MySQL le remplit automatiquement avec la date et l'heure actuelles du système.
  Types composites
  MySQL prend également en charge deux types de données composites, ENUM et SET, qui étendent la spécification SQL. Bien que ces types soient techniquement des types de chaînes, ils peuvent être traités comme des types de données différents. Un type ENUM permet d'obtenir une seule valeur à partir d'une collection ; un type SET permet d'obtenir n'importe quel nombre de valeurs à partir d'une collection.
  Type ENUM
  Le type ENUM ne permet d'obtenir qu'une seule valeur dans la collection, ce qui est un peu similaire à une option unique. Plus facile à comprendre lorsqu’il s’agit de données mutuellement exclusives, telles que le sexe humain. Les champs de type ENUM peuvent prendre une valeur d'une collection ou utiliser une valeur nulle, sinon la saisie amènera MySQL à insérer une chaîne vide dans le champ. De plus, si la casse de la valeur insérée ne correspond pas à la casse des valeurs de la collection, MySQL utilisera automatiquement la casse de la valeur insérée pour la convertir en une valeur cohérente avec la casse de la collection.
  Le type ENUM peut être stocké sous forme de nombre en interne dans le système et est indexé à partir de 1. Un type ENUM peut contenir jusqu'à 65 536 éléments, dont un est réservé par MySQL pour stocker les informations d'erreur. Cette valeur d'erreur est représentée par l'index 0 ou une chaîne vide.
  MySQL considère les valeurs apparaissant dans la collection de types ENUM comme une entrée légale, et toute autre entrée échouera. Cela montre que l'emplacement de l'enregistrement erroné peut être facilement trouvé en recherchant des lignes contenant une chaîne vide ou un index numérique correspondant de 0.
  Type SET
  Le type SET est similaire au type ENUM mais pas le même. Le type SET peut prendre n'importe quel nombre de valeurs d'une collection prédéfinie. Et comme pour le type ENUM, toute tentative d'insertion d'une valeur non prédéfinie dans un champ de type SET entraînera l'insertion par MySQL d'une chaîne vide. Si vous insérez un enregistrement contenant à la fois des éléments légaux et illégaux, MySQL conservera les éléments légaux et supprimera les éléments illégaux.
  Un type SET peut contenir jusqu'à 64 éléments. Dans un élément SET, la valeur est stockée sous la forme d'une séquence discrète de "bits" qui représentent son élément correspondant. Les bits sont un moyen simple et efficace de créer des collections ordonnées d'éléments. Et il supprime également les éléments en double, il est donc impossible de contenir deux éléments identiques dans un type SET.
  Si vous souhaitez rechercher des enregistrements illégaux à partir d'un champ de type SET, recherchez simplement les lignes contenant des chaînes vides ou des valeurs binaires de 0.

  Pour plus de connaissances sur la programmation, veuillez visiter : Apprendre la programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!