mysql 自增id

一、mysql 自增id

MySQL自增ID的工作原理

在MySQL数据库中，自增ID是一种非常常见的数据类型，它允许我们在插入新记录时自动生成唯一的标识符。这在许多应用程序中都非常有用，例如用户注册、商品管理等。

MySQL的自增ID工作原理非常简单。当我们定义一个自增ID字段时，在插入新记录时，MySQL会自动为该字段赋予一个唯一的整数值。这个整数值随着每次插入而增加，确保每个记录都有一个唯一的标识符。

要在MySQL中创建一个自增ID字段，我们可以使用AUTO_INCREMENT关键字。例如：

在上面的例子中，我们创建了一个名为users的表，其中包含了一个自增ID字段id。当我们向这个表插入新记录时，id字段的值将会自动增加。

一旦我们在表中定义了自增ID字段，MySQL会在每次插入新记录时自动处理它。这在很大程度上简化了我们的开发工作，因为我们不需要手动计算和管理唯一标识符。

自增ID的优势

使用自增ID有许多优势。首先，它为我们提供了一个简单的方法来确保每个记录都有一个唯一的标识符。这对于数据的唯一性和完整性非常重要。

其次，自增ID允许我们更容易地进行数据的排序和比较。由于ID的值是按顺序增加的，我们可以根据ID值对记录进行排序，使得数据的查询和分析更加高效。

此外，自增ID还可以提高数据库的性能。在插入新记录时，它比其他生成唯一ID的方法（例如UUID）更加高效。因为自增ID只需要增加一个整数值，而不需要生成复杂的字符串或使用其他算法。

如何使用自增ID

要在MySQL中使用自增ID，我们需要遵循一些最佳实践：

1. 定义自增ID字段

当我们创建新的表时，我们应该考虑在其中添加一个自增ID字段。这可以通过在字段定义中使用AUTO_INCREMENT关键字来实现。例如：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50),
    email VARCHAR(50)
);

在上面的例子中，我们创建了一个名为users的表，并为id字段定义了自增属性。

2. 插入新记录

当我们向表中插入新记录时，不需要显式地为自增ID字段提供值。MySQL会自动为我们处理。例如：

INSERT INTO users (name, email)
VALUES ('John Doe', 'john@example.com');

上述查询将自动为id字段生成一个唯一的值，并将其插入到users表中。

3. 检索自增ID值

有时，我们可能需要在插入新记录后获取自增ID的值。为此，我们可以使用LAST_INSERT_ID()函数。

INSERT INTO users (name, email)
VALUES ('John Doe', 'john@example.com');

SELECT LAST_INSERT_ID();

上面的示例将插入新记录，并返回刚插入的记录的自增ID值。

4. 更新自增ID字段

通常情况下，我们不应该手动更新自增ID字段的值。因为MySQL会自动处理它们，确保它们的唯一性。如果我们试图手动更新自增ID字段，可能会导致数据不一致。

然而，有时我们可能需要重新设置自增ID的起始值。为此，我们可以使用AUTO_INCREMENT关键字和ALTER TABLE语句。

ALTER TABLE users AUTO_INCREMENT = 1001;

上述语句将重新设置users表的自增ID起始值为1001。这意味着下一次插入记录时，ID将从1001开始增加。

总结

MySQL的自增ID是一种简单而强大的特性，可以帮助我们轻松管理数据表中记录的唯一标识符。它提供了诸多优势，例如确保数据的唯一性、简化数据的排序和比较、提高数据库的性能等。

通过遵循最佳实践，我们可以轻松地在MySQL中使用自增ID，并充分发挥其优势。

希望本文对你理解和使用MySQL自增ID有所帮助。

二、mysql自增id

MySQL自增ID的使用及注意事项

在MySQL数据库中，自增ID是常用的主键类型之一。自增ID为每一条记录分配一个唯一的、递增的标识符，确保数据的唯一性，并便于管理和索引。本文将介绍MySQL自增ID的使用方法和一些注意事项。

MySQL中使用自增ID非常简单，只需在创建表时，将主键字段的类型设置为INT，并在字段定义后添加“AUTO_INCREMENT”关键字即可。例如：

上述示例中，我们创建了一个名为“users”的表，并设置了一个自增ID字段。“id”字段的类型为INT，表示整型数据，而关键字“AUTO_INCREMENT”则告诉MySQL自动递增该字段的值。

插入数据时的自增ID

在插入数据时，可以省略自增ID字段，MySQL会自动为该字段生成递增的唯一值。例如：

INSERT INTO `users` (`name`, `email`) VALUES ('张三', 'zhangsan@example.com');

上述代码中，我们将一个名为“张三”的用户插入到了“users”表中。由于省略了“id”字段，MySQL会自动为该记录生成一个新的自增ID。

获取自增ID的值

在插入数据后，如果需要获取刚刚生成的自增ID的值，可以使用MySQL的函数“LAST_INSERT_ID()”。该函数会返回上一次插入操作生成的自增ID值。例如：

INSERT INTO `users` (`name`, `email`) VALUES ('李四', 'lisi@example.com');
SELECT LAST_INSERT_ID();

以上代码插入了一个名为“李四”的用户，并通过SELECT语句获取了刚插入记录的自增ID值。

注意事项

自增ID的唯一性

自增ID确保了每一条记录都具有唯一标识符，从而避免了数据冲突。然而，需要注意的是，当表中的记录达到自增ID字段类型的最大值时，将无法继续插入新的记录，因为已经无法生成唯一的自增ID。因此，在设计表结构时，应根据实际需求选择合适的数据类型，以免出现此类问题。

自增ID的顺序

自增ID的顺序是递增的，在插入新记录时，自增ID的值会自动增加。然而，当删除表中的记录时，并不会重置自增ID的值。这意味着，当删除了一条自增ID为10的记录后，再次插入新记录时，新的自增ID值可能会大于10。因此，需要注意在使用自增ID的场景下，可能会存在不连续的自增ID值。

自增ID的管理

在某些情况下，可能需要手动管理自增ID的值，例如将自增ID设置为指定的值或重置自增ID的起始值等。MySQL提供了一些相关的命令和函数，供开发人员进行管理。例如：

• ALTER TABLE命令：可以使用ALTER TABLE命令修改表的定义，包括自增ID的起始值。
• SET INSERT_ID函数：可以使用SET INSERT_ID函数设置自增ID的值。

对于这些功能的具体使用方法，请参考MySQL的官方文档。

综上所述，MySQL的自增ID在数据表设计和管理中起到了重要的作用。通过自增ID，可以确保数据的唯一性，方便索引和管理。同时，也需要注意自增ID的唯一性、顺序以及可能需要手动管理的情况，以避免出现问题。

三、mysql数据库设置主键自增

MySQL数据库设置主键自增

随着互联网的快速发展，数据库管理成为各个企业和个人的重要任务。MySQL作为一种常见的关系型数据库管理系统，广泛应用于各种网络应用和网站开发中。在MySQL数据库中，设置主键自增是一项非常关键的操作，可以提高数据库的性能和数据完整性。本文将介绍如何在MySQL数据库中设置主键自增。

首先，让我们了解一下主键的概念。主键是用来标识数据库表中唯一记录的一列或一组列。它具有唯一性和非空性的特点，确保了表中的每一行都可以通过主键进行唯一标识。在MySQL中，可以使用AUTO_INCREMENT关键字来设置主键自增。

使用MySQL数据库管理工具（如phpMyAdmin）或命令行操作，可以对数据表进行设置。下面是一个例子，演示如何在MySQL数据库中创建一张包含自增主键的数据表：

在上面的例子中，我们创建了一个名为“students”的数据表，其中包含三个字段：id、name和age。id是我们设置的自增主键，类型为INT。通过将AUTO_INCREMENT关键字与PRIMARY KEY关键字一起使用，我们告诉MySQL数据库在插入新记录时自动为id字段生成唯一的自增值。

在实际的应用中，设置主键自增具有许多好处。首先，它简化了数据库中记录的管理。当插入新记录时，不再需要手动指定主键的值，而是由数据库自动生成。这样就避免了人为错误导致的主键冲突。其次，主键自增可以提高数据库的性能。由于数据库不需要再去检索和计算唯一的主键值，插入新记录的速度更快。此外，设置主键自增也有助于保持数据的完整性，因为它确保了每一行都具有唯一标识。

然而，在设置主键自增时也需要注意一些细节。首先，主键字段的数据类型通常为整数类型（如INT或BIGINT），以确保自增值的唯一性。其次，一个数据表只能有一个自增主键字段。如果需要设置复合主键，可以使用组合字段来实现。最后，如果需要在插入新记录时指定主键的值，可以使用INSERT语句的IGNORE选项来避免主键冲突。

除了创建数据表时设置主键自增，我们还可以在已经存在的数据表中添加自增主键。在MySQL中，可以使用ALTER TABLE语句来修改数据表的结构。下面是一个例子，演示如何为已存在的数据表添加自增主键：

通过以上命令，我们将“students”表中的“id”列修改为自增主键。需要注意的是，修改数据表结构时可能会影响已有的数据。因此，务必在进行任何表结构的修改之前，先备份数据库以防止数据丢失。

总结来说，设置主键自增是在MySQL数据库中管理数据表的重要操作之一。它可以提高数据库的性能、数据完整性和管理便捷性。通过使用AUTO_INCREMENT关键字，我们可以轻松地在创建新数据表或修改已有数据表的结构时设置主键自增。

希望本文对您在MySQL数据库中设置主键自增有所帮助。

四、如何把把id设置为自增？

sqlserver建表时设置ID字段自增的方法有两种：

1、在SQLServerManagementStudio中实现SQLServer自增字段

打开SQLServerManagementStudio,打开数据库之后，在选中的表上点“修改”，在选中需要设置为自增的字段，在右下方的表设计器里选择“标识规范”，选“是”，就设定即可。

五、如何在Access数据库中删除自增的ID列，如何设置主键？

第一步：用查找重复项向导将重复记录查找出来。

第二步：删除重复记录。

第三步：设置主键。

六、数据库中varchar类型怎么自增？

为了测试，表中仅添加了两列，分别是主键id 和 name列，两列都为varchar类型。

备注：id内容格式为 BHXXXX，如：BH0001

因为主键id不是int类型，想实现自动自增功能，使用内置的方法肯定是行不通的，所以，使用了复杂的查询方法及拼接方式，此方法虽然比较笨，但测试还是可以通过的。

大致思路：在MySql中新建表时，可以创建触发器为id进行自增。

详细思路：

 1、使用查询语句查出表中最后一条数据的id，语句：select id from user order by id desc limit 1     得到结果 BH0001

 2、使用substring函数截取最后一条BHXXXX中数字部分：

        SELECT substring(id,3,4) from user where id=(select id from user order by id desc limit 1)   得到结果 0001

     其中，3表示从第3位进行截取，4表示截取长度

 3、使用concat语句进行字符串连接

          concat('BH',(SELECT substring(id,3,4) from user where id=(select id from user order by id desc limit 1) +1));

        我刚开始认为到这一步的时候，只要给以上结果 +1 ，然后使用concat语句连接字符串就可以了，但是，得到的结果并不是我想象中的 BH0002，而是BH2，所以，在进行字符串连接之前，得将数字2进行填充，使用LPAD函数，最终结果如下：

         concat('BH',lpad(((SELECT substring(id,3,4) from user where id=(select id from user order by id desc limit 1))+1),4,0));

         其中，4表示填充长度，0表示填充内容。

触发器完整语句：

CREATE TRIGGER `T` BEFORE INSERT ON `user`

FOR EACH ROW begin\nset new.id=concat('SH',lpad(((SELECT substring(id,3,4) from user where id=(select id from user order by id desc limit 1))+1),4,0));

end;

其中，大写T为触发器名称，user为表名，结束！

七、MySQL数据库自增：全面解析自增字段的用法和注意事项

什么是MySQL数据库自增

在MySQL数据库中，自增是一种常见的字段属性，通常用于为表中的每一行数据生成一个唯一的标识符。

如何在MySQL中创建自增字段

要在MySQL中创建自增字段，可以使用AUTO_INCREMENT属性。在创建表的时候，只需要将需要自增的字段声明为AUTO_INCREMENT，数据库就会自动为这个字段生成唯一的递增值。

自增字段的注意事项

尽管自增字段提供了方便和唯一性，但在使用的过程中也需要注意一些事项。

• 自增字段只能用于整数类型，比如INT或BIGINT。
• 删除表中的数据并不会重置自增字段的值，如果需要重新开始计数，可以使用ALTER TABLE命令手动重置。
• 在多主机和主从复制的环境中，注意不同服务器生成的自增值可能存在冲突。

如何在MySQL中使用自增字段

在插入数据时，如果不提供自增字段的值，MySQL会自动为这个字段分配一个递增的值。同时，也可以使用MySQL的LAST_INSERT_ID函数来获取最后插入行的自增值。

总结

MySQL数据库自增字段是一种强大的工具，可以为表中的每一条数据提供唯一的标识符。合理使用自增字段，可以简化数据库操作，并提高数据管理的效率。

感谢您阅读本文，希望对您了解MySQL数据库自增字段有所帮助！

八、数据库ID类型定义？

数据类型

从本小节开始，就开始为学习如何操作记录做准备了。

我们先来学习，MySQL中常用的数据类型。

在MySQL中，我们需要了解的数据类型共有以下几种：

• 数值类型。
• 日期类型。
• 字符串类型。
• ENUM和SET类型。

我们一一来看看吧。

数值类型

MySQL支持所有标准SQL数值类型。包括严格数值数据类型(INTEGER、SMALLINT、DECIMAL和NUMERIC)，以及近似数值数据类型(FLOAT、REAL和DOUBLE PRECISION)。

关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词。

MySQL支持的整数类型有TINYINT、SMALLINT、MEDIUMINT、INT和BIGINT。下面的表显示了需要的每个整数类型的存储和范围。

对于小数的表示，MYSQL分为两种方式：浮点数和定点数。浮点数包括float(单精度)和double(双精度),而定点数只有decimal一种，在mysql中以字符串的形式存放，比浮点数更精确，适合用来表示货币等精度高的数据。

BIT数据类型保存位字段值，并且支持MyISAM、MEMORY、InnoDB和BDB表。

int类型

这里我们先以int为例展开讨论。

 create table t1(n1 int(4));
desc t1;
+-------+--------+------+-----+---------+-------+
| Field | Type   | Null | Key | Default | Extra |
+-------+--------+------+-----+---------+-------+
| n1    | int(4) | YES  |     | NULL    |       |
+-------+--------+------+-----+---------+-------+
insert into t1 values(11);
insert into t1 values(111111);
select n1 from t1;
+--------+
| n1     |
+--------+
|     11 |
| 111111 |
+--------+

由最后的查看结果，我们为int类型设定的宽度为4，结果插入一个6位的也行。这是怎么回事？

create table t2(n1 int(4) zerofill);
desc t2;
+-------+--------------------------+------+-----+---------+-------+
| Field | Type                     | Null | Key | Default | Extra |
+-------+--------------------------+------+-----+---------+-------+
| n1    | int(4) unsigned zerofill | YES  |     | NULL    |       |
+-------+--------------------------+------+-----+---------+-------+
insert into t2 values(11);
insert into t2 values(111111);
select n1 from t2;
+--------+
| n1     |
+--------+
|   0011 |
| 111111 |
+--------+

可以看到，我们在创建表的时候，为n1字段加上zerofill，表示不够4位就填充0。而最后的查询结果告诉我们，如果为int类型指定宽度，则是显示字符的宽度（字符数量），超过这个限制也会显示。

而查询表结构的时候，有个unsigned，这是无符号的类型。那这是什么意思呢？

 create table t3(n1 int);
desc t3;
+-------+---------+------+-----+---------+-------+
| Field | Type    | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| n1    | int(11) | YES  |     | NULL    |       |
+-------+---------+------+-----+---------+-------+
insert into t3 values(11111111111111111111111111);
insert into t3 values(-11111111111111111111111111);
select n1 from t3;
+-------------+
| n1          |
+-------------+
|  2147483647 |
| -2147483648 |
+-------------+

首先，desc告诉我们int类型的默认显示宽度是11位，而最大表示数值范围是2147483647，如果你插入的数据是超过这个范围的话。而2147483647的显示宽度是10位，为什么不是默认的11位呢？这是因为int类型默认类型是有符号的，而有符号的就要考虑正号和负号，而符号仅用1位就能表示。

原因如下：

int的存储宽度是4个Bytes，即32个bit，即2^32

无符号最大值为：4294967296-1

有符号最大值：2147483648-1

有符号和无符号的最大数字需要的显示宽度均为10，而针对有符号的最小值则需要11位才能显示完全，所以int类型默认的显示宽度为11是非常合理的。

那么如何设置一个无符号的呢？

 create table t4(n1 int unsigned);
desc t4;
+-------+------------------+------+-----+---------+-------+
| Field | Type             | Null | Key | Default | Extra |
+-------+------------------+------+-----+---------+-------+
| n1    | int(10) unsigned | YES  |     | NULL    |       |
+-------+------------------+------+-----+---------+-------+
insert into t4 values(11111111111111111111111111);
select n1 from t4;
+------------+
| n1         |
+------------+
| 4294967295 |
+------------+

无符号的需要在int类型指定unsigned。结果也是没错的。都最开始列举的表中数据一致。

最后：int类型，其实没有必要指定显示宽度，使用默认的就行；如果你的整数范围超过int类型范围，请选用别的数据类型；并且默认的，我们创建的int类型是有符号类型。

float类型

先来看定义：

FLOAT[M, D] [UNSIGNED] [ZEROFILL]
DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]
DECIMAL[(m[,d])] [unsigned] [zerofill]

float表示单精度浮点数（非准确小数值），M表示数字总个数，最大值是255；D是小数点后的数字个数，最大值30。也就是说，如果float(255,30)意思是，小数位是30位，而整数位就不是255了，而是255-30=225位。它的精准度：随着小数的增多，精度变得不准确。

双精度（double）浮点数（非准确小数值），m是数字总个数，d是小数点后个数。m最大值为255，d最大值为30。它的精准度：随着小数的增多，精度比float要高，但也会变得不准确。

而decimal的准确的小数值，m是数字总个数（负号不算），d是小数点后个数。 m最大值为65，d最大值为30。它的精准度：随着小数的增多，精度始终准确；对于精确数值计算时需要用此类型。decaimal能够存储精确值的原因在于其内部按照字符串存储。

create table f1(weight float(256,30));
ERROR 1439 (42000): Display width out of range for column 'weight' (max = 255)  # 说显示宽度超过了255
create table f2(weight float(255,31));
ERROR 1425 (42000): Too big scale 31 specified for column 'weight'. Maximum is 30.  # 告诉我们小数点后的位数最多30位
create table f3(weight float(255,30));   # 这样就没问题了
desc f3;
+--------+---------------+------+-----+---------+-------+
| Field  | Type          | Null | Key | Default | Extra |
+--------+---------------+------+-----+---------+-------+
| weight | float(255,30) | YES  |     | NULL    |       |
+--------+---------------+------+-----+---------+-------+

首先，我们创建的float类型是有符号类型。

同样的，你想创建一个无符号的，也要指定unsigned。

create table f4(weight float(255,30) unsigned);
desc f4;
+--------+------------------------+------+-----+---------+-------+
| Field  | Type                   | Null | Key | Default | Extra |
+--------+------------------------+------+-----+---------+-------+
| weight | float(255,30) unsigned | YES  |     | NULL    |       |
+--------+------------------------+------+-----+---------+-------+
1 row in set (0.01 sec)

在使用浮点型的数据时，我们考虑的核心是关注它们的精度。来看对比。

create table f5(weight float(255,30) unsigned);
create table f6(weight double(255, 30) unsigned);
create table f7(weight decimal(65, 30) unsigned);
insert into f5 values(1.111111111111111111111111111111111111111111111111111);
insert into f6 values(1.111111111111111111111111111111111111111111111111111);
insert into f7 values(1.111111111111111111111111111111111111111111111111111);

我们创建三张不同类型的表，并插入一些数据，并且这些小数位都超过30位。来观察他们的精度：

 select weight from f5;
+----------------------------------+
| weight                           |
+----------------------------------+
| 1.111111164093017600000000000000 |
+----------------------------------+
select weight from f6;
+----------------------------------+
| weight                           |
+----------------------------------+
| 1.111111111111111200000000000000 |
+----------------------------------+
select weight from f7;
+----------------------------------+
| weight                           |
+----------------------------------+
| 1.111111111111111111111111111111 |
+----------------------------------+

由各自的查询结果可以看到，float类型的精度只有前7位是精确的；double类型的精度是15位；而decimal则保留完整的精度，毕竟是字符串形式的存储么。 但是decimal虽然精度较高，但是它也是有限制的，因为它的数字总大小为65位，所以抛出小数位的30位，还剩30位整数位。

最后，最后，这里只是说的显示宽度仅是在int中使用，其他数据类型宽度是存储限制。比如BIT类型。

BIT

 create table b1(b bit(1));
desc b1;
+-------+--------+------+-----+---------+-------+
| Field | Type   | Null | Key | Default | Extra |
+-------+--------+------+-----+---------+-------+
| b     | bit(1) | YES  |     | NULL    |       |
+-------+--------+------+-----+---------+-------+
insert into b1 values(0);
insert into b1 values(1);
insert into b1 values(2);
select b from b1;
+------+
| b    |
+------+
|      |
|     |
|     |
+------+

首先了解，字段b的类型是bit，宽度是1，那能表示多少数值呢，一个bit，只能表示0和1两个。但是通过查询发现，跟我们想要的结果不一样。

这是为什么，bit类型存储是以二进制存储到硬盘上的。所以，我们想要查询到我们想要的值，还要借助MySQL提供给我们的函数bin()和hex()，意思是返回二进制值的字符串形式表示和十六进制的表示形式。

 select bin(b) from b1;
+--------+
| bin(b) |
+--------+
| 0      |
| 1      |
| 1      |
select hex(b) from b1;
+--------+
| hex(b) |
+--------+
| 0      |
| 1      |
| 1      |
+--------+

可以看到，字段b的bit(1)类型只能表示0和1，而插入的2超出了范围。所以，你在用的时候，需要注意：

create table b2(b bit(2));
insert into b2 values(2);
select bin(b) from b2;
+--------+
| bin(b) |
+--------+
| 10     |
+--------+

可以看到，2的二进制形式是10。

时间类型

日期类型有：

• DATE（YYYY-MM-DD（1000-01-01/9999-12-31）），2019-07-31，出生年月日
• TIME（HH:MM:SS（'-838:59:59'/‘838:59:59’）），16:40:40，下班时间
• DATETIME（YYYY-MM-DD HH:MM:SS（1000-01-01 00:00:00/9999-12-31 23:59:59 Y））、2019-07-31 16:40:40，注册时间、文章发布时间、员工入职时间
• TIMESTAMP（YYYYMMDD HHMMSS（1970-01-01 00:00:00/2037 年某时））、2019-07-31 16:40:40
• YEAR（YYYY（1901/2155））、2019，历史大事件，出生年

来个示例：

create tabled1(
    born_date date, 
    get_time time, 
    reg_time datetime, 
    born_year year    # 最后一个字段后面不要有逗号
);
insert into d1 values(
	'1999-11-11',
	'18:30:00',   
	'2018-11-11 11:11:11',
	'1999'  # 不要写成18/30/30
);

来查询：

desc d1;
+-----------+----------+------+-----+---------+-------+
| Field     | Type     | Null | Key | Default | Extra |
+-----------+----------+------+-----+---------+-------+
| born_date | date     | YES  |     | NULL    |       |
| get_time  | time     | YES  |     | NULL    |       |
| reg_time  | datetime | YES  |     | NULL    |       |
| born_year | year(4)  | YES  |     | NULL    |       |
+-----------+----------+------+-----+---------+-------+
select * from d1;
+------------+----------+---------------------+-----------+
| born_date  | get_time | reg_time            | born_year |
+------------+----------+---------------------+-----------+
| 1999-11-11 | 18:30:00 | 2018-11-11 11:11:11 |      1999 |
+------------+----------+---------------------+-----------+

再来掌握一个now()函数：

insert into d1 values(now(), now(), now(), now());
select * from d1;
+------------+----------+---------------------+-----------+
| born_date  | get_time | reg_time            | born_year |
+------------+----------+---------------------+-----------+
| 1999-11-11 | 18:30:00 | 2018-11-11 11:11:11 |      1999 |
| 2019-07-31 | 16:57:51 | 2019-07-31 16:57:51 |      2019 |

由第二行记录可以发现，各类型都按照自己的规则截取所需的日期数据。

了解：datetime与timestamp的区别

create table d2(x datetime, y timestamp);
desc d2;
+-------+-----------+------+-----+-------------------+-----------------------------+
| Field | Type      | Null | Key | Default           | Extra                       |
+-------+-----------+------+-----+-------------------+-----------------------------+
| x     | datetime  | YES  |     | NULL              |                             |
| y     | timestamp | NO   |     | CURRENT_TIMESTAMP | on update CURRENT_TIMESTAMP |
+-------+-----------+------+-----+-------------------+-----------------------------+
insert into d2 values(Null, Null);
insert into d2 values('1111-11-11','1111-11-11');
 select * from d2;
+---------------------+---------------------+
| x                   | y                   |
+---------------------+---------------------+
| NULL                | 2019-07-31 17:05:43 |
| 1111-11-11 00:00:00 | 0000-00-00 00:00:00 |
+---------------------+---------------------+

通过上述验证分析，虽然这两种日期格式，都能满足我们大多数使用场景，但是在某些情况下，它们也有自己的优劣之分，来看看它们的区别：

• DATETIME的日期范围是1001——9999年，TIMESTAMP的时间范围是1970——2038年。
• DATETIME存储时间与时区无关，TIMESTAMP存储时间与时区有关，显示的值也依赖于时区。在mysql服务器，操作系统以及客户端连接都有时区的设置。
• DATETIME使用8字节的存储空间，TIMESTAMP的存储空间为4字节。因此，TIMESTAMP比DATETIME的空间利用率更高。
• DATETIME的默认值为null，TIMESTAMP的字段默认不为空（not null），默认值为当前时间（CURRENT_TIMESTAMP），如果不做特殊处理，并且update语句中没有指定该列的更新值，则默认更新为当前时间。

字符串类型

字符串类型这里需要重点掌握的就是char和varchar两个，存放名字、性别、密码、文本内容等等。

先看它们的区别，注意，长度指的是字符的长度：

• char，定长，简单粗暴，浪费空间，存取速度快。
• 字符长度范围：0~255，一个汉字是一个字符，utf8编码一个普通汉字占用3个字节。
• 存储：如果存储的值，不满足指定的长度时，会往右填充空格来满足长度，例如指定长度为10，存储大于10个字符报错，小于10个字符会用空格填充，凑够十个字符。
• 查询（或称检索）：查询出的结果会自动删除尾部的空格，除非我们打开pad_char_to_full_length SQL模式

  set sql_mode = 'PAD_CHAR_TO_FULL_LENGTH'

• varchar，可变长度，存储更精确，但存取速度慢。
• 字符长度范围：0-65535，在utf8编码中，如果大于21844会提示用其他类型 。mysql行最大限制为65535字节。
• 存储：varchar类型存储的是真实内容，而不是用空格填充，如存储abc ，尾部的空格也会被存储起来。注意，varchar类型会在真实数据前面加1~2个Bytes前缀，用来存储真实数据的bytes字节数，1~2Bytes最大表示65535个数字，正好符合MySQL对row的最大字节限制。如果真实的数据小于255bytes则需要1Bytes的前缀（1Bytes=8bit 2**8最大表示的数字为255）；如果真实的数据>255bytes则需要2Bytes的前缀（2Bytes=16bit 2**16最大表示的数字为65535）。
• 查询：尾部有空格会保存下来，在检索或者说查询时，也会正常显示包含空格在内的内容。

char VS varchar：存储范围验证

create table c1(s char(256));
ERROR 1074 (42000): Column length too big for column 's' (max = 255); use BLOB or TEXT instead
create table c2(s char(255));
create table c3(s varchar(21845));
ERROR 1118 (42000): Row size too large. The maximum row size for the used table type, not counting BLOBs, is 65535. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs
create table c4(s varchar(21844));
create table c5(s varchar(65534));

通过打印结果，可以看到，char类型，如果长度超过255，就提示我们字段长度最大是255；varchar的列长度如果超过21844，提示我们varchar类型的最大行大小为65535。

但是最后的c5却成功创建，这是为什么呢？我们来看它的表结构：

desc c4;
+-------+----------------+------+-----+---------+-------+
| Field | Type           | Null | Key | Default | Extra |
+-------+----------------+------+-----+---------+-------+
| s     | varchar(21844) | YES  |     | NULL    |       |
+-------+----------------+------+-----+---------+-------+
desc c5;
+-------+------------+------+-----+---------+-------+
| Field | Type       | Null | Key | Default | Extra |
+-------+------------+------+-----+---------+-------+
| s     | mediumtext | YES  |     | NULL    |       |
+-------+------------+------+-----+---------+-------+

可以看到，c5表的字段类型已经变成了mediumtext，而不是varchar类型。

char VS varchar：存储长度验证

create table c6(s char(3));
create table c7(s varchar(3));
insert into c6 values('abcd');
insert into c6 values('生存还是毁灭');
insert into c7 values('abcd');
insert into c7 values('生存还是毁灭');

再来看查询结果：

select s from c6;
+-----------+
| s         |
+-----------+
| abc       |
| 生存还    |
+-----------+
select s from c7;
+-----------+
| s         |
+-----------+
| abc       |
| 生存还    |
+-----------+

可以看到，无论是char还是varchar；无论是中文还是其他，它们限制的是字符个数。

char VS varchar：定长与可变长度

再来研究它们之间的特点的区别，也就是定长和可变长度的区别。

我们通过表格来看看他们的存储关系：

不要被5bytes所迷惑，abcd占4个字节，还有一个字节存储该字符串的长度。

先了解两个函数：

• length：查看字节数。
• char_length：查看字符数。

create table c8(s1 char(3), s2 varchar(3));
desc c8;
+-------+------------+------+-----+---------+-------+
| Field | Type       | Null | Key | Default | Extra |
+-------+------------+------+-----+---------+-------+
| s1    | char(3)    | YES  |     | NULL    |       |
| s2    | varchar(3) | YES  |     | NULL    |       |
+-------+------------+------+-----+---------+-------+
insert into c8 values('a', 'b');
select s1, s2 from c8;
+------+------+
| s1   | s2   |
+------+------+
| a    | b    |
+------+------+

现在看是啥也看不出来，所以，我们用上char_length函数：

select char_length(s1), char_length(s2) from c8;
+-----------------+-----------------+
| char_length(s1) | char_length(s2) |
+-----------------+-----------------+
|               1 |               1 |
+-----------------+-----------------+

这也看不出来啥呀，a和b不就是各占用一个字符长度么。

这是因为啊，我们在查询char类型数据的时候，MySQL会默默的删除尾部的空格（装作我并没有浪费空间！），我们来让它现原形：

SET sql_mode = 'PAD_CHAR_TO_FULL_LENGTH';
select char_length(s1), char_length(s2) from c8;
+-----------------+-----------------+
| char_length(s1) | char_length(s2) |
+-----------------+-----------------+
|               3 |               1 |
+-----------------+-----------------+

这个时候再看，是不是现原形了，char类型占用指定的3个字符宽度，当然，一个英文字符也占用一个字节。而varchar就占用一个字符。

中文也一样：

insert into c8 values('你', '好');
select char_length(s1), char_length(s2) from c8;
+-----------------+-----------------+
| char_length(s1) | char_length(s2) |
+-----------------+-----------------+
|               3 |               1 |
|               3 |               1 |
+-----------------+-----------------+

这就是我们使用char和varchar时需要注意的点。

小结：

InnoDB存储引擎：建议使用VARCHAR类型 单从数据类型的实现机制去考虑，char数据类型的处理速度更快，有时甚至可以超出varchar处理速度的50%。

但对于InnoDB数据表，内部的行存储格式没有区分固定长度和可变长度列（所有数据行都使用指向数据列值的头指针），因此在本质上，使用固定长度的CHAR列不一定比使用可变长度VARCHAR列性能要好。因而，主要的性能因素是数据行使用的存储总量。由于CHAR平均占用的空间多于VARCHAR，因此使用VARCHAR来最小化需要处理的数据行的存储总量和磁盘I/O是比较好的。 其他字符串系列（效率：char>varchar>text）

• TEXT系列 TINYTEXT TEXT MEDIUMTEXT LONGTEXT
• BLOB 系列 TINYBLOB BLOB MEDIUMBLOB LONGBLOB
• BINARY系列 BINARY VARBINARY

text：text数据类型用于保存变长的大字符串，可以组多到65535 (2**16 − 1)个字符。

枚举与集合

有些情况，我们需要在一堆选项中选择一个，或者选择多个，如单选框和复选框。 那，在MySQL的字段中，字段的类型也可以有单选和多选。

• enum单选，只能在给定范围内选一个值，如果性别；适用于给定范围后续不会发生变化的场景；另外数字类型不适用枚举。
• set多选，在给定的范围聂选择多个值，如爱好。

create table user1(
	id int,
	name char(5),
	sex enum('male', 'female', 'unknow'),
	hobby set('eat', 'sleep', 'play mobile phone')
);
desc user1;
+-------+----------------------------------------+------+-----+---------+-------+
| Field | Type                                   | Null | Key | Default | Extra |
+-------+----------------------------------------+------+-----+---------+-------+
| id    | int(11)                                | YES  |     | NULL    |       |
| name  | char(5)                                | YES  |     | NULL    |       |
| sex   | enum('male','female','unknow')         | YES  |     | NULL    |       |
| hobby | set('eat','sleep','play mobile phone') | YES  |     | NULL    |       |
+-------+----------------------------------------+------+-----+---------+-------+
insert into user1 values(1, '张三', 'male', 'eat,sleep');
select * from user1;
+------+-----------+------+-----------+
| id   | name      | sex  | hobby     |
+------+-----------+------+-----------+
|    1 | 张三      | male | eat,sleep |
+------+-----------+------+-----------+

如果是set类型，多个参数以逗号隔开。 这里，我们也可以设置默认值，如果用户不填写的话：

create table user2 (id int, sex enum('male', 'female', 'unknow') default 'male');
insert into user2(id) values(1);
insert into user2 values(2, 'female');
select * from user2;
+------+--------+
| id   | sex    |
+------+--------+
|    1 | male   |
|    2 | female |
+------+--------+

根据查询结果可以看到，如果性别字段传值就用我们传的值，不传就用默认的。

九、mysql数据库设置自增型字段PPT

MySQL数据库是一种常用的关系型数据库管理系统，广泛应用于各个领域。在数据库设计中，设置自增型字段是非常常见的需求。本文将介绍如何在MySQL数据库中设置自增型字段，并提供相关的PPT文档供参考。

什么是自增型字段

自增型字段，即自动增长字段，是指在插入新记录时，数据库会自动为该字段分配一个唯一的值，且每次插入值都会比前一次的值大1。自增型字段通常用作主键，以保证每条记录都有唯一的标识。

在MySQL数据库中设置自增型字段的方法

在MySQL数据库中，有多种方法可以实现自增型字段的设置。

方法一：使用AUTO_INCREMENT属性

在创建表时，可以为字段加上AUTO_INCREMENT属性，示例代码如下：

在上述示例中，id字段被设置为自增型字段，并作为主键。每次插入新记录时，MySQL会自动为id字段分配一个唯一的值。

方法二：使用序列（Sequence）

MySQL中并没有内置的序列（Sequence）的概念，但可以通过创建自定义函数实现类似的功能。以下是示例代码：

上述代码创建了一个名为nextval的自定义函数，通过查询information_schema.TABLES表获取下一个自增值。

常见问题与解决方案

在设置自增型字段时，常常会遇到一些问题。下面列举一些常见问题及其解决方案：

问题一：自增值重复

有时候自增值会出现重复的情况，这可能是由于数据表中的间隙导致的。解决该问题的方式包括：

• 检查数据表是否有被删除或撤销的记录，这可能会导致间隙。
• 使用ALTER TABLE语句修复自增序列。
• 使用TRUNCATE TABLE语句清空表中的数据并重置自增序列。

问题二：自增值超过上限

由于自增值是有限的，当达到上限时，可能会出现错误。解决该问题的方式包括：

• 使用BIGINT类型代替INT类型，增加自增值的上限。
• 重新设计数据库结构，将自增字段拆分成多个字段，以支持更大的范围。

PPT演示文档

为了更好地理解和掌握MySQL数据库中设置自增型字段的方法，我们特别准备了一份PPT演示文档。

您可以通过以下链接下载PPT文档：

MySQL数据库设置自增型字段

希望以上内容对您有所帮助，如果您有任何疑问或者其他相关问题，欢迎随时联系我们。

十、in自增字段

数据库设计中的 in自增字段

在关系型数据库设计中，经常会遇到需要使用自增字段的情况。自增字段通常用于唯一标识表中的每一行，并且在每次插入新记录时自动递增。这种机制不仅简化了开发人员的工作，还确保了数据的一致性和准确性。本文将重点讨论数据库设计中的 in自增字段，包括其用途、限制和最佳实践。

in自增字段的用途

in自增字段在数据库设计中被广泛应用于主键的生成。主键是用来唯一标识表中每一行记录的字段，确保数据的唯一性和完整性。通过使用自增字段作为主键，可以简化数据操作，避免主键冲突，并提高数据检索的性能。另外，in自增字段还可以用于跟踪数据插入的顺序，为数据分析和性能优化提供支持。

in自增字段的限制

尽管in自增字段具有诸多优点，但在实际应用中也存在一些限制需要注意。首先，自增字段的取值范围有限，通常为整数类型，因此需要确保不会因为溢出而导致数据错误。其次，自增字段的唯一性由数据库自身保证，因此需要谨慎处理并发插入的情况，避免出现主键冲突。

此外，有些情况下并不适合使用自增字段，比如需要手动指定主键值或主键值需要跨表保持唯一性的场景。在这种情况下，开发人员可以考虑使用其他生成主键的方式，如UUID或序列。然而，需要注意的是，这些方法可能会带来额外的性能开销和复杂性。

in自增字段的最佳实践

针对in自增字段的最佳实践有以下几点建议：

• 谨慎选择自增字段的初始值和递增步长，避免溢出和数据错误。
• 定期监控自增字段的使用情况，及时优化主键索引以提高性能。
• 使用自增字段时，尽量避免手动插入主键值，以免破坏自增序列的连续性。
• 在设计表结构时，考虑表的增长规模和数据访问模式，合理选择主键策略。

总之，in自增字段作为数据库设计中常用的一种字段类型，在实际应用中发挥着重要作用。了解其用途、限制和最佳实践，可以帮助开发人员更好地设计和优化数据表结构，提高系统的性能和可维护性。