PART1. 插入数据

可以插入的方式由插入完整的记录、插入记录的一部分、插入多条记录、插入另一个查询的结果，下面分别介绍这些内容。

1. 为表的所有字段插入数据

使用基本的INSERT语句插入数据要求指定表名称和插入到新纪录中的值。

INSERT INTO table_name (column_list) VALUES (value_list);

注意：虽然使用INSERT插入数据时可以忽略插入数据的列名称，但是值如果不包含列名称，那么VALUES关键字后面的值不仅要求完整而且顺序必须和表定义时列的顺序相同，如果表的结构被修改，对列进行增加、删除或者位置改变操作，这些操作将使得用这种方式插入数据时的顺序也同时改变。如果指定列名称，则不会受到表结构改变的影响。

2. 为表的指定字段插入数据

为表的指定字段插入数据，就是在INSERT语句中只向部分字段中插入值，而其他字段的值为表定义时的默认值。

注意：要保证每一插入值的类型和对应列的数据类型匹配，如果类型不同，将无法插入，并且MySQL会产生错误。

3. 同时插入多条记录

INSERT 语句可以同时向数据表中插入多条记录，插入时指定多个值列表，每个值列表之间用逗号分隔开，基本语法格式如下：

INSERT INTO table_name (column_list)
VALUES (value_list1), (value_list2), ... ,(value_listn);

使用INSERT同时插入多条记录时，MySQL会返回一些在执行单行插入时没有的额外信息，这些信息的含义如下：

Records：表明插入的记录条数。

Duplicates：表明插入时被忽略的记录，原因可能是这些记录包含了重复的主键值。

Warnings：表明有问题的数据值，例如发生数据类型转换。

注意：一个同时插入多行记录的INSERT语句等于多个单行插入的INSERT语句，但是单行的INSERT语句在处理过程中效率更高。因为MySQL执行单行INSERT语句插入多行数据比使用多条INSERT语句快，所以在插入多条记录时最好选择使用单条INSERT语句的方式插入。

4. 将查询结果插入到表中

INSERT语句用来给数据表插入记录时直嘀咕插入记录的列值。INSERT还可以将SELECT语句查询的结果插入到表中，只需要一个INSERT语句和一个SELECT语句组成的组合语句即可快速地从一个或多个表中向一个表中插入多行。

INSERT INTO table_name1 (column_list1)
SELECT (column_list2) FROM table_name2 WHERE (condition)

table_name1 指定待插入数据的表；column_list1指定待插入表中要插入数据的哪些列；table_name2指定插入数据是从哪个表中查询出来的；column_list2指定数据来源表的查询列，该列表必须和column_list1列表中的字段个数相同，数据类型相同；condition指定select语句的查询条件。

PART2. 更新数据

MySQL中使用update语句更新表中的记录，可以更新特定的行或者同时更新所有的行。

UPDATE table_name
SET column_name1 = value1, column_name2 = value2, ... , column_namen = valuen
WHERE (condition);

column_name1,column_name2,......,column_namen 为指定更新的字段的名称；value1，value2，……，valuen为相对应的指定字段的更新值；condition指定更新的记录需要满足的条件。更新多列时，每个“列-值”对之间用逗号隔开，最后一列之后不需要逗号。

注意：保证UPDATE以WHERE子句结束，通过WHERE子句指定被更新的记录所需要满足的条件，如果忽略WHERE子句，MySQL将更新表中所有的行。

PART3. 删除数据

从数据表中删除数据使用DELETE语句，DELETE语句允许WHERE子句指定删除条件。

DELETE FROM table_name [WHERE <condition>];

table_name 指定要执行删除操作的表；“[WHERE <condition>]”为可选参数，指定删除条件，如果没有WHERE子句，DELETE语句将删除表中的所有记录。

注意：如果想删除表中的所有记录，还可以使用TRUNCATE TABLE语句。TRUNCATE将直接删除原来的表，并删除创建一个表，其语法结构为TRUNCATE TABLE table_name。TRUNCATE 直接删除表而不是删除记录，因此执行速度比DELETE快。

PART4. 为表增加计算列

计算列：简单来说就是某一列的值时通过别的列计算得来的。例如a列值为1、b列值为2，c列值不需要手动插入，定义a+b的结果为c的值，那么c就是计算列，是通过别的列计算得来的。

col_name data_type [GENERATED ALWAYS] AS (expression)
[VIRTUAL | STORED] [UNIQUE [KEY]]  [COMMENT comment]
[NOT NULL | NULL] [[PRIMARY] KEY]

创建测试表tb1：

 更新数据中的数据：

字段c中的数据始终时字段a和字段b的和，随着字段a和字段b中数据的变化，自动重新计算a+b的值。

PART5. MySQL8.0 的新特性——DDL的原子化

 在MySQL8.0版本中，InnoDB表的DDL支持事务完整性，即DDL操作要么成功要么回滚。DDL操作回滚日志写入到data dictionary数据字典表 mysql.innodb_ddl_log（该表是隐藏的表，通过show tables无法看到）中，用于回滚操作。通过设置参数，可将DDL操作日志打印输出到MySQL错误日志中。

MySQL5.7中会执行成功部分的DDL.

-- end

继续上一篇文章：mysql 8.0 一条insert语句的具体执行流程分析(一)_一缕阳光的博客-CSDN博客

由于最近换工作一直在试用期内，在拼命的学习、总结中，因此没有时间写文章，今天转正了腾出来时间继续写下一篇文章。mysql 8.0 一条insert语句的具体执行流程分析写完了write_record部分，下面将会运行到engine层，主要存储引擎的接口

代码版本：mysql 8.0.22

编程语言：c++ && c++11 && c++14 && c++17

这里使用MySQL InnoDB存储引擎，存储引擎接口涉及多个文件，由于内容过多，分下面几个部分进行分开描述，代码是按下面的章节顺序执行的。

| > handler::ha_write_row
| | > ha_innobase::write_row
| | | > row_insert_for_mysql
| | | | > row_insert_for_mysql_using_ins_graph
| | | | | > trx_start_if_not_started_xa
             > trx_start_if_not_started_xa_low
               > trx_start_low                 
| | | | | > row_mysql_convert_row_to_innobase
| | | | | > row_ins_step     

(1)、ha_write_row : 用于插入一条记录

int handler::ha_write_row(uchar *buf) {

  ...
  ...

  // 主要是调用这个ha_innobase::write_row
  MYSQL_TABLE_IO_WAIT(PSI_TABLE_WRITE_ROW, MAX_KEY, error,
                      { error = write_row(buf); })

  return 0;
}

(2)、write_row : 在InnoDB database中存储一行数据，针对这张表对应的handle

int ha_innobase::write_row(uchar *record) {

    ...
    ...
    update_auto_increment();  // 更新自增建

    ...
    /* Execute insert graph that will result in actual insert. */
    error = row_insert_for_mysql((byte *)record, m_prebuilt);

    
}

其中里面会更新自增键，如果建表语句中有自增列。

(3)、row_insert_for_mysql : 执行insert操作

这个函数比较简单，直接透传到下面的函数中了

/** Does an insert for MySQL.
@param[in]	mysql_rec	row in the MySQL format
@param[in,out]	prebuilt	prebuilt struct in MySQL handle
@return error code or DB_SUCCESS*/
dberr_t row_insert_for_mysql(const byte *mysql_rec, row_prebuilt_t *prebuilt) {
  /* For intrinsic tables there a lot of restrictions that can be
  relaxed including locking of table, transaction handling, etc.
  Use direct cursor interface for inserting to intrinsic tables. */
  if (prebuilt->table->is_intrinsic()) {
    return (row_insert_for_mysql_using_cursor(mysql_rec, prebuilt));
  } else {
    return (row_insert_for_mysql_using_ins_graph(mysql_rec, prebuilt));
  }
}

(4)、row_insert_for_mysql_using_ins_graph : 使用graph结构存储insert的信息

static dberr_t row_insert_for_mysql_using_ins_graph(const byte *mysql_rec,
                                                    row_prebuilt_t *prebuilt) { 
    ...
    ...
    row_mysql_convert_row_to_innobase(node->row, prebuilt, mysql_rec, &blob_heap);

  run_again:
      thr->run_node = node;
      thr->prev_node = node;

      row_ins_step(thr); // 向一个table中插入一行
   ...
}

(5)、trx_start_if_not_started_xa : 这部分是开启XA事务

(6)、row_mysql_convert_row_to_innobase : 将一行数据从MySQL格式转换为innodb格式

(7)、row_ins_step : 向一个table中插入一行

| > row_ins_step
| | > row_ins
| | | > row_ins_index_entry_step
| | | | > row_ins_index_entry
            > row_ins_clust_index_entry
            > row_ins_sec_index_multi_value_entry      
            > row_ins_sec_index_entry   

(8)、row_ins_step : 向表中插入一行，会调用下面的row_ins

/** Inserts a row to a table. This is a high-level function used in SQL
 execution graphs.
 @return query thread to run next or NULL */
que_thr_t *row_ins_step(que_thr_t *thr) /*!< in: query thread */
{
  ...

  err = row_ins(node, thr);

  ...
  return (thr);
}

(9)、row_ins : 向表中插入一行

(10)、row_ins_index_entry_step : 向表中插入index

(11)、row_ins_index_entry :

    (1)、row_ins_clust_index_entry : 聚集索引执行这个分支

    (2)、row_ins_sec_index_multi_value_entry : 使用二级索引多个value值时，执行这个分支

    (3)、row_ins_sec_index_entry : 二级索引执行这个分支

本篇文章先写到这里，下一篇文章主要讲述使用二级索引时的执行流程。

题外话：跟公司签了3年合同，试用期6个月，是不是试用期太长了，国家规定的也是6个月吗？如果比较清楚这个事，请告知我(zgaoq@163.com)，谢谢

• 启动mysql服务

net start mysql80	#mysql80为我的mysql名称

• 连接到mysql server

mysql -h host -u user -p	#mysql服务没有运行在用户登录的机器上
mysql -u user -p	#mysql服务运行在用户登录的机器上，user为用户名如root

如果报错[Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user ‘root’@‘localhost’ (using password: YES)可能是在命令最后加了分号，删掉分号即可。

• 与mysql server断开连接

mysql> QUIT

• 显示警告

mysql> SHOW WARNINGS;

• 显示当前mysql版本，当前日期，当前具体时间，当前用户

mysql> SELECT VERSION(), CURRENT_DATE, NOW(), USER();

• mysql中不等于的符号为<>

• 计算

mysql> SELECT SIN(PI()/4), (4+1)*5;
/*直接计算日期*/
mysql> SELECT '2018-10-31' + INTERVAL 1 DAY;
+-------------------------------+
| '2018-10-31' + INTERVAL 1 DAY |
+-------------------------------+
| 2018-11-01                    |
+-------------------------------+

• 获取关于数据库和表的信息

/*显示当前用户管理的数据库*/
mysql> SHOW DATABASES;
	
/*显示当前选择的数据库，若当前没有选定任何数据库，则返回NULL*/
mysql> SELECT DATABASE();

/*显示当前选中的数据库中所包含的所有表格*/
mysql> SHOW TABLES;

/*显示一个表的结构*/
mysql> DESCRIBE pet;
/*SHOW COLUMNS可达到同样效果*/
SHOW COLUMNS FROM pet;
#DESC是DESCRIBE的缩写
#Field（字段）代表列名
#Type代表列的数据类型
#NULL代表该列是否可以包含NULL值
#Key表示该列是否被索引
#Default指定该列的默认值
#Extra显示该列的特殊信息，如某列使用AUTO_INCREMENT创建，则Extra值为auto_increment而不是空
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| name    | varchar(20) | YES  |     | NULL    |       |
| owner   | varchar(20) | YES  |     | NULL    |       |
| species | varchar(20) | YES  |     | NULL    |       |
| sex     | char(1)     | YES  |     | NULL    |       |
| birth   | date        | YES  |     | NULL    |       |
| death   | date        | YES  |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+

/*可以使用 SHOW CREATE TABLE 语句获取创建现有表所需的 CREATE TABLE 语句*/
/*如果表上有索引，则 SHOW INDEX FROM tbl_name 会生成有关它们的信息。*/

• 选定当前要操作的数据库

mysql> USE test	#test是当前选中的数据库名称

• 创建新数据库

mysql> CREATE DATABASE menagerie;	#menagerie为新数据库名称

• 创建表格

mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),
       species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);

• 用文本文件填充表格的一行或多行

#/path/为文件路径，Windows系统换行符为\r\n
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet 
	   LINES TERMINATED BY '\r\n';	

可能会报错ERROR 3948 (42000): Loading local data is disabled; this must be enabled on both the client and server sides根据官方文档这是出于安全性考虑。
首先将local_infile置为ON，再用新的连接方式连接mysql即可执行LOAD DATA LOCAL语句。

mysql> SHOW GLOBAL VARIABLES LIKE 'local_infile';	#sql的show语句，查看全局变量的值
mysql> SET GLOBAL local_infile = ON;	#sql的set语句
mysql -u root -p --local-infile	#改用这种方式连接mysql
mysql> LOAD DATA LOCAL INFILE 'D:\pet.txt' INTO TABLE pet LINES TERMINATED BY '\r\n';	#成功

注意各列的值之间用tab分开，文本在复制粘贴后其中的tab有可能会变成数个空格，需要重新键入tab。缺省的值用\N表示。

• 将一行插入表格

#sql的insert语句
mysql> INSERT INTO pet 
	   VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);	

• 从表格中提取信息

#select语句的一般形式
SELECT what_to_select
/*what_to_select indicates what you want to see. This can be a list of columns, or * to indicate “all columns.”所谓的所有列不包括不可显示的列*/
FROM which_table
/*which_table indicates the table from which you want to retrieve data.*/
WHERE conditions_to_satisfy;
/*The WHERE clause is optional. If it is present, conditions_to_satisfy specifies one or more conditions that rows must satisfy to qualify for retrieval.*/

使用通配符*检索pet表格的所有行的所有字段

mysql> SELECT * FROM pet;

使用WHERE子句过滤数据，检索特定行
BETWEEN操作符的应用，AND操作符和OR操作符的应用
AND和OR同时出现时，AND的计算优先级更高，先计算AND后计算OR
所以组合WHERE子句注意括号的使用

mysql> SELECT * FROM pet WHERE name = 'me';	#字符串比较大小写不敏感，所以where子句是me还是ME无所谓
mysql> SELECT * FROM pet WHERE birth >= '1998-1-1';
mysql> SELECT * FROM pet WHERE species <> 'dog';
//空值检查
mysql> SELECT * FROM pet WHERE species IS NULL;
mysql> SELECT * FROM pet WHERE birth BETWEEN '1998-1-1' AND '1998-2-1';
//组合WHERE子句
mysql> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f';
mysql> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird';
mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm')
       OR (species = 'dog' AND sex = 'f');

WHERE子句的操作符

检索表格中的特定字段

mysql> SELECT name, birth FROM pet;
mysql> SELECT owner FROM pet;
mysql> SELECT DISTINCT owner FROM pet;	#在显示中合并同一列中的相同值

检索表格中的特定行和字段

mysql> SELECT name, species, birth FROM pet
       WHERE species = 'dog' OR species = 'cat';

使用DISTINCT关键字检索不同的行
此关键字指示MySQL只返回不同的值，该关键字不能部分使用
DISTINCT关键字作用于所有要检索的列，而不仅仅只作用于前置它的列

/*只有两行的age和species的值都对应一样，才算相同的行*/
mysql> SELECT DISTINCT age, species FROM test2;

使用LIMIT子句限制检索结果
第一行是行0，LIMIT 0, 1检出第一行，LIMIT 1, 1检索出第二行

/*LIMIT 5指示MySQL返回不多于5行*/
mysql> SELECT * FROM test2 LIMIT 5;
/*LIMIT 5，5可指定要检索的开始行和行数*/
mysql> SELECT * FROM test2 LIMIT 5，5;

ORDER BY子句，将结果按列排序
通常，ORDER BY子句中使用的列将是为显示所选择的列。但是，用非检索的列排序数据是完全合法的。
使用ORDER BY子句和LIMIT子句的组合可以检索出一个列中最高或最低的值

/*默认升序*/
mysql> SELECT name, birth FROM pet ORDER BY birth;
/*添加关键字DESC使结果反向排序，descend下降*/
mysql> SELECT name, birth FROM pet ORDER BY birth DESC;
/*按字符排序仍是大小写不敏感*/
mysql> SELECT name, birth FROM pet ORDER BY name;
/*可以使用BINARY强迫按字符排序时大小写敏感*/
mysql> SELECT name, birth FROM pet ORDER BY BINARY name;
/*多重排列，首先按种类升序排列，同种类再按生日降序排列*/
mysql> SELECT name, species, birth FROM pet
       ORDER BY species, birth DESC;
 /*关键字DESC只作用于其紧前方的列，即birth，而不作用于species*/
 /*检索出最年轻的*/
 mysql> SELECT name, birth FROM pet ORDER BY birth LIMIT 1;

日期相关函数

CURDATE()	#Return the current date
YEAR()	#Return the year
MONTH()	#Return the month from the date passed
DAYOFMONTH()	/*Returns the day of the month for date, in the range 1 to 31, or 0*/

/*TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)函数*/
mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
        -> 3
mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
        -> -1
mysql> SELECT TIMESTAMPDIFF(MINUTE,'2003-02-01','2003-05-01 12:05:55');
        -> 128885
/*DATE_ADD(date,INTERVAL expr unit)和DATE_SUB(date,INTERVAL expr unit)函数*/
#expr表达式被视为字符串，且可以以-开头，表示负的
#unit是一个关键字，指示表达式expr中的是时间的哪一部分
mysql> SELECT DATE_ADD('2018-05-01',INTERVAL 1 DAY);
        -> '2018-05-02'
mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
        -> '2017-05-01'
mysql> SELECT DATE_ADD('2020-12-31 23:59:59',
    ->                 INTERVAL 1 SECOND);
        -> '2021-01-01 00:00:00'
mysql> SELECT DATE_ADD('2018-12-31 23:59:59',
    ->                 INTERVAL 1 DAY);
        -> '2019-01-01 23:59:59'
mysql> SELECT DATE_ADD('2100-12-31 23:59:59',
    ->                 INTERVAL '1:1' MINUTE_SECOND);
        -> '2101-01-01 00:01:00'
mysql> SELECT DATE_SUB('2025-01-01 00:00:00',
    ->                 INTERVAL '1 1:1:1' DAY_SECOND);
        -> '2024-12-30 22:58:59'
mysql> SELECT DATE_ADD('1900-01-01 00:00:00',
    ->                 INTERVAL '-1 10' DAY_HOUR);
        -> '1899-12-30 14:00:00'
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
        -> '1997-12-02'
mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
    ->            INTERVAL '1.999999' SECOND_MICROSECOND);
        -> '1993-01-01 00:00:01.000001'

日期计算

mysql> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet;
+----------+------------+------------+------+
| name     | birth      | CURDATE()  | age  |
+----------+------------+------------+------+
| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |
| Claws    | 1994-03-17 | 2003-08-19 |    9 |
| Buffy    | 1989-05-13 | 2003-08-19 |   14 |
| Fang     | 1990-08-27 | 2003-08-19 |   12 |
| Bowser   | 1989-08-31 | 2003-08-19 |   13 |
| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |
| Whistler | 1997-12-09 | 2003-08-19 |    5 |
| Slim     | 1996-04-29 | 2003-08-19 |    7 |
| Puffball | 1999-03-30 | 2003-08-19 |    4 |
+----------+------------+------------+------+
/*将结果按名字排列*/
mysql> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet ORDER BY name;
/*按年龄排列*/
mysql> SELECT name, birth, CURDATE(),
       TIMESTAMPDIFF(YEAR,birth,CURDATE()) AS age
       FROM pet ORDER BY age;
/*where子句添加条件，NULL不能用算术比较运算符，所以death <> NULL错误*/
mysql> SELECT name, birth, death,
       TIMESTAMPDIFF(YEAR,birth,death) AS age
       FROM pet WHERE death IS NOT NULL ORDER BY age;
+--------+------------+------------+------+
| name   | birth      | death      | age  |
+--------+------------+------------+------+
| Bowser | 1989-08-31 | 1995-07-29 |    5 |
+--------+------------+------------+------+
/*MONTH()函数*/
mysql> SELECT name, birth, MONTH(birth) FROM pet;
+----------+------------+--------------+
| name     | birth      | MONTH(birth) |
+----------+------------+--------------+
| Fluffy   | 1993-02-04 |            2 |
| Claws    | 1994-03-17 |            3 |
| Buffy    | 1989-05-13 |            5 |
| Fang     | 1990-08-27 |            8 |
| Bowser   | 1989-08-31 |            8 |
| Chirpy   | 1998-09-11 |            9 |
| Whistler | 1997-12-09 |           12 |
| Slim     | 1996-04-29 |            4 |
| Puffball | 1999-03-30 |            3 |
+----------+------------+--------------+
/*如果当前是4月，查找出下个月过生日的*/
mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;
+-------+------------+
| name  | birth      |
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+
/*各个月份通用的方法，检索出下个月过生日的，下面两个语句效果一样*/
mysql> SELECT name, birth FROM pet
       WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));
mysql> SELECT name, birth FROM pet
       WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;
/*MOD()函数：MOD(N,M), N % M, N MOD M效果一样*/

• sql的LIKE模式匹配
  sql用’_‘匹配任意单个字符，用’%'匹配任意长度的字符，包括0长度的字符；
  mysql的sql模式匹配是大小写不敏感的；
  sql匹配时不要用=或者<>，要用LIKE或者NOT LIKE比较运算符代替；
  LIKE模式匹配需要被检测值的所有部分都匹配上才算匹配成功；

/*名字以字符b开头的行*/
mysql> SELECT * FROM pet WHERE name LIKE 'b%';
+--------+--------+---------+------+------------+------------+
| name   | owner  | species | sex  | birth      | death      |
+--------+--------+---------+------+------------+------------+
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
| Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

/*名字中含有字符w的行*/
mysql> SELECT * FROM pet WHERE name LIKE '%w%';
+----------+-------+---------+------+------------+------------+
| name     | owner | species | sex  | birth      | death      |
+----------+-------+---------+------+------------+------------+
| Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
| Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
+----------+-------+---------+------+------------+------------+

/*检索出名字为5个字符的行*/
mysql> SELECT * FROM pet WHERE name LIKE '_____';
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

• 使用扩展正则表达式的mysql模式匹配
  使用REGEXP_LIKE()函数；
  '.'匹配任意单个字符；
  […]匹配任何在括号中的字符，[a, b, c]匹配字符a或b或c，[a-z]匹配任何字母，[0-9]匹配任何数字；
  '*'配任意数量（包括0个）的它前面的字符；
  只要和被检测字符的任一部分匹配成功，扩展正则表达式的匹配就算成功；
  使用^匹配值的开头，$匹配值的结尾；

/*匹配以b开头的，^放在最前面*/
mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b');
+--------+--------+---------+------+------------+------------+
| name   | owner  | species | sex  | birth      | death      |
+--------+--------+---------+------+------------+------------+
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
| Bowser | Diane  | dog     | m    | 1979-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

/*若要强制正则表达式的比较区分大小写，下面三种写法均只匹配小写b*/
#使用区分大小写的排序规则
SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b' COLLATE utf8mb4_0900_as_cs);
#转为二进制比较大小
SELECT * FROM pet WHERE REGEXP_LIKE(name, BINARY '^b');
#指定c匹配控制字符
SELECT * FROM pet WHERE REGEXP_LIKE(name, '^b', 'c');

/*匹配以fy结尾的，$放在最后*/
mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'fy$');
+--------+--------+---------+------+------------+-------+
| name   | owner  | species | sex  | birth      | death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
+--------+--------+---------+------+------------+-------+

/*匹配含有w的*/
mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, 'w');
+----------+-------+---------+------+------------+------------+
| name     | owner | species | sex  | birth      | death      |
+----------+-------+---------+------+------------+------------+
| Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
| Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
+----------+-------+---------+------+------------+------------+

/*匹配长度为5个字符的*/
mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.....$');
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+
#{n}运算符意为重复五遍，这句功能与上句相同
mysql> SELECT * FROM pet WHERE REGEXP_LIKE(name, '^.{5}$');

• 计算行数
  注意如果除了COUNT(*)之外还SELECT了其他列，则需要GROUP BY子句这些列，否则会出问题；

/*计算pet表格一共有多少行*/
mysql> SELECT COUNT(*) FROM pet;

/*GROUP BY的应用*/
#同主人的归为一组，计算各组分别多少人
mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;
+--------+----------+
| owner  | COUNT(*) |
+--------+----------+
| Benny  |        2 |
| Diane  |        2 |
| Gwen   |        3 |
| Harold |        2 |
+--------+----------+
mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;
mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex;
#同种类同性别的归为一组，计算各组分别有多少人
mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;

/*限定范围*/
mysql> SELECT species, sex, COUNT(*) FROM pet
       WHERE species = 'dog' OR species = 'cat'
       GROUP BY species, sex;
mysql> SELECT species, sex, COUNT(*) FROM pet
       WHERE sex IS NOT NULL
       GROUP BY species, sex;

• 关于缺省值NULL
  缺省值NULL不能用来比较大小；
  在 MySQL 中，0或 NULL 表示 false，其他任何值表示 true；
  布尔运算的默认真值为 1；
  两个 NULL 值在 GROUP BY 中被视为相等；
  NULL在默认的升序排序中被排在最前面，
  即执行 ORDER BY 时，如果执行 ORDER BY … ASC，则首先显示 NULL 值，
  如果执行 ORDER BY … DESC，则最后显示 NULL 值；
  0和空字符串不是NULL；

/*使用 IS NULL 和 IS NOT NULL运算符判断是否是NULL*/
mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
|         0 |             1 |
+-----------+---------------+

• 修改更新表中的数据

mysql> UPDATE pet SET birth = '1989-08-31' WHERE name = 'Bowser';

• 删除表格中的所有信息

mysql> DELETE FROM pet;

• 同时检索一个数据库中的两个表格
  在FROM子句中使用INNER JOIN可以连接两个表；
  当且仅当两个表都满足ON子句的条件，该记录才能出现在结果中；
  因为名称在两个表中都出现，所以检索该列时必须指明是哪个表的名称；

/*宠物下崽时的年龄*/
mysql> SELECT pet.name,
       TIMESTAMPDIFF(YEAR,birth,date) AS age, remark
       FROM pet INNER JOIN event
         ON pet.name = event.name
       WHERE event.type = 'litter';
+--------+------+-----------------------------+
| name   | age  | remark                      |
+--------+------+-----------------------------+
| Fluffy |    2 | 4 kittens, 3 female, 1 male |
| Buffy  |    4 | 5 puppies, 2 female, 3 male |
| Buffy  |    5 | 3 puppies, 3 female         |
+--------+------+-----------------------------+

• 同一个表的连接
  表的连接不一定必须是两个或多个不同的表，单个表也行；
  有时需要将表中的记录与同一表中的其他记录进行比较，这时将表自身连接起来很有用；
  通过给表指定别名来引用列；

/*找出可配对的宠物对，即同种异性的宠物*/
mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
       FROM pet AS p1 INNER JOIN pet AS p2
         ON p1.species = p2.species
         AND p1.sex = 'f' AND p1.death IS NULL
         AND p2.sex = 'm' AND p2.death IS NULL;
+--------+------+-------+------+---------+
| name   | sex  | name  | sex  | species |
+--------+------+-------+------+---------+
| Fluffy | f    | Claws | m    | cat     |
| Buffy  | f    | Fang  | m    | dog     |
+--------+------+-------+------+---------+

• 批处理模式下使用mysql
  以上内容都是以交互方式通过命令行输入语句并查看结果，据说mysql批处理默认是关闭的，
  所以批处理主要是把要运行的语句放在文件中，再告诉mysql从脚本文件中读取输入；
  用文本文档写mysql命令，文件扩展名是txt还是sql都可以；
  结尾没有分号的语句不要乱加分号，会出错；

/*使用source或\.命令执行脚本文件*/
mysql> source D:/scripts_sql.sql
/*结尾不要加分号，否则没法打开文件*/
mysql> \. D:\scripts_sql.sql

/**/
shell> mysql -u user -p < batch-file
Enter password: ********
C:\WINDOWS\system32>mysql -u root -p < D:\scripts_sql.txt
Enter password: ******

/*在文件中捕获输出*/
shell> mysql -u user -p < batch-file > mysql.out
Enter password: ********
C:\WINDOWS\system32>mysql -u root -p < D:\scripts_sql.sql > D:\out.txt
Enter password: ******

本文截止到Examples of Common Queries之前