MySQL常用语句大全

语句

创建表后，会在/data/mysql中出现一个目录

[root@mysql mysql]# ls
auto.cnf    ....  ydh ....

使用表

root@(none) 20:20 mysql>use ydh;

查看表的结构

root@ydh 20:25 mysql>desc student_info;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
| sex   | char(10)    | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.07 sec)

创建用户并赋权（网络socket）

root@(none) 10:22 mysql>create user 'ydh'@'%' identified by '123456';
Query OK, 0 rows affected (0.01 sec)

root@(none) 10:23 mysql>grant all on *.* to 'ydh'@'%';
Query OK, 0 rows affected (0.00 sec)

create user 'ydh'@'%' identified by '123456';

1. CREATE USER：这是MySQL用于创建用户的关键字，它告诉MySQL服务器接下来的语句是用于创建用户的操作。

2. ‘ydh’@‘%’：这是要创建的新用户的用户名和主机名。在这个例子中，用户名为ydh，主机名为%。%表示允许从任何主机连接到MySQL服务器。如果要限制只能从特定主机连接到MySQL服务器，可以使用具体的IP地址或主机名代替%。

3. IDENTIFIED BY：这是MySQL用于指定用户密码的关键字，它告诉MySQL服务器接下来的参数是用于设置用户密码的。

4. ‘123456’：这是要设置的用户密码。在这个例子中，密码为123456。需要注意的是，密码必须使用单引号括起来，以避免特殊字符被解释为SQL语句的一部分。

当执行这个SQL语句后，MySQL服务器将创建一个新用户ydh，并将其密码设置为123456。该用户可以从任何主机连接到MySQL服务器，并具有默认的权限。如果需要为该用户分配特定的权限，可以使用GRANT语句进行授权。例如，可以使用GRANT语句为该用户授予SELECT、INSERT、UPDATE等权限，以允许该用户在指定的表中执行这些操作。

grant all on *.* to 'ydh'@'%';

1. GRANT ALL：这是MySQL用于授予所有权限的关键字，它告诉MySQL服务器接下来要授予该用户所有的权限。

2. ON *.*：这是MySQL用于指定授权对象的关键字，它告诉MySQL服务器接下来要授予该用户对所有数据库和表的权限。

3. TO ‘ydh’@‘%’：这是要授权的用户的用户名和主机名。在这个例子中，要授权的用户为ydh，主机名为%。%表示允许从任何主机连接到MySQL服务器。如果要限制只能从特定主机连接到MySQL服务器，可以使用具体的IP地址或主机名代替%。

当执行这个授权语句后，MySQL服务器将授予用户ydh对所有数据库和表的所有权限，包括SELECT、INSERT、UPDATE、DELETE等。需要注意的是，授予所有权限可能会存在安全风险，因为该用户可以对MySQL服务器上的所有数据库和表进行任何操作。因此，在实际应用中，应该根据需要为用户分配特定的权限，并限制其操作范围，以确保数据的安全性和完整性。

查看地址

[root@mysql ~]# ip add
    inet 192.168.2.4/24 brd 192.168.2.255 scope global 

在另外一台机器使用网络socket连接

[root@mysql ~]# mysql -uydh -p'123456' -h 192.168.2.3
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 5.7.41 MySQL Community Server (GPL)

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

ydh@(none) 10:25 mysql>

DDL

MySQL的DDL（数据定义语言）是一组用于创建、修改和删除数据库、表、索引、视图、存储过程和触发器等数据库对象的语句。下面是一些常用的MySQL DDL语句和它们的详细说明：

alter

在MySQL中，DDL（数据定义语言）用于定义和管理数据库对象，例如表、索引、视图等。其中，ALTER语句是DDL中的一种，用于修改已经存在的数据库对象的结构或属性。

ALTER语句的语法如下：

ALTER object_type object_name alter_type [alter_specification];

其中，object_type可以是TABLE、DATABASE、INDEX、VIEW等；object_name指定要修改的对象的名称；alter_type可以是ADD、MODIFY、DROP、RENAME等；alter_specification指定要进行的具体修改操作。

1. 添加列

使用ALTER TABLE语句添加新列，可以使用ADD关键字，后面跟着要添加的列名和定义该列的数据类型。例如：

ALTER TABLE mytable ADD COLUMN new_column INT;

2. 修改列

使用ALTER TABLE语句修改已存在的列，可以使用MODIFY关键字，后面跟着要修改的列名和定义该列的新数据类型。例如：

ALTER TABLE mytable MODIFY COLUMN old_column VARCHAR(50);

3. 删除列

使用ALTER TABLE语句删除已存在的列，可以使用DROP关键字，后面跟着要删除的列名。例如：

ALTER TABLE mytable DROP COLUMN old_column;

4. 重命名表

使用ALTER TABLE语句重命名已存在的表，可以使用RENAME关键字，后面跟着要修改的表名和定义该表的新名称。例如：

ALTER TABLE mytable RENAME TO newtable;

5. 更改表的存储引擎

使用ALTER TABLE语句更改已存在的表的存储引擎，可以使用ENGINE关键字，后面跟着要修改的存储引擎名称。例如：

ALTER TABLE mytable ENGINE = InnoDB;

• 更改表名

  ALTER TABLE table_name
  CHANGE old_column_name new_column_name column_definition;
  

  root@ydh 15:54 mysql>alter table t1 change  id number int;
  

• 改用户的登录密码

  alter user 'root'@'localhost' identified by  '123456';
  

• 修改表中的列名

  root@ydh 20:10 mysql>ALTER TABLE grade CHANGE COLUMN socre score int;
  

create

在MySQL中，DDL（数据定义语言）用于定义和管理数据库的结构，其中包括创建、修改和删除数据库、表、索引等对象。其中，CREATE语句是DDL中的一个重要命令，用于创建数据库对象。

CREATE语句的语法格式如下：

• 创建数据库：

  CREATE DATABASE database_name;
  

  这条语句用于创建一个新的数据库。database_name是要创建的数据库的名称。

• 创建表：

  CREATE TABLE table_name (
      column1 datatype,
      column2 datatype,
      ...
  );
  

  这条语句用于创建一个新的表。table_name是要创建的表的名称，column1, column2, …是表的列名和对应的数据类型。通过列名和数据类型的定义，可以确定表的结构。

  create table ydh.t2(id int,name varchar(10));
  

  当在别的库时，可以创建在ydh库的表。

  create table if not exists  ydh.t2 (id int ,name varchar(20));
  

  如果不存在就创建表，存在就不创建同时不会输出错误提示到屏幕上，但是会出提示。

  show warnings;
  

  查看警告消息

  create table  wang( id int not null primary key, name varchar(20) not null, sex char(1) )
  

  创建表的时候给属性值一些限制。

• 创建索引：

  CREATE INDEX index_name
  ON table_name (column1, column2, ...);
  

  这条语句用于在表中创建一个索引。index_name是索引的名称，table_name是要创建索引的表名，(column1, column2, ...)指定了要在哪些列上创建索引。

• 创建视图：

  CREATE VIEW view_name AS
  SELECT column1, column2, ...
  FROM table_name
  WHERE condition;
  

  这条语句用于创建一个新的视图。view_name是视图的名称，table_name是视图所基于的表，column1, column2, ...是要包含在视图中的列，WHERE condition是一个可选的过滤条件。

• 创建存储过程：

  CREATE PROCEDURE procedure_name()
  BEGIN
      -- 存储过程的逻辑
  END;
  

  这条语句用于创建一个新的存储过程。procedure_name是存储过程的名称，在BEGIN和END之间可以编写存储过程的逻辑。

drop

DROP语句可以用于删除表、索引、视图、存储过程、触发器等对象。下面是一些常见的DROP语句的用法和解释：

• DROP TABLE：用于删除表。语法如下：

  DROP TABLE [IF EXISTS] table_name;
  

  • table_name是要删除的表的名称。
  • IF EXISTS是可选的关键字，表示如果表不存在也不会抛出错误。

• DROP INDEX：用于删除索引。语法如下：

  DROP INDEX [IF EXISTS] index_name ON table_name;
  

  • index_name是要删除的索引的名称。
  • table_name是包含索引的表的名称。
  • IF EXISTS是可选的关键字，表示如果索引不存在也不会抛出错误。

• DROP VIEW：用于删除视图。语法如下：

  DROP VIEW [IF EXISTS] view_name;
  

  • view_name是要删除的视图的名称。
  • IF EXISTS是可选的关键字，表示如果视图不存在也不会抛出错误。

• DROP PROCEDURE：用于删除存储过程。语法如下：

  DROP PROCEDURE [IF EXISTS] procedure_name;
  

  • procedure_name是要删除的存储过程的名称。
  • IF EXISTS是可选的关键字，表示如果存储过程不存在也不会抛出错误。

• DROP TRIGGER：用于删除触发器。语法如下：

  DROP TRIGGER [IF EXISTS] trigger_name;
  

  • trigger_name是要删除的触发器的名称。
  • IF EXISTS是可选的关键字，表示如果触发器不存在也不会抛出错误。

• drop database ydh

  删库

rename

在MySQL中，DDL（数据定义语言）用于创建、修改和删除数据库和数据库对象（如表、索引、视图等）。RENAME是DDL语句之一，用于重命名数据库对象。

RENAME语句用于重命名现有的数据库对象，可以是表、列、索引、视图、存储过程、触发器等。下面是RENAME语句的语法：

RENAME [TO] new_name;

在这个语法中，new_name是要为对象指定的新名称。具体的使用方法取决于要重命名的对象类型。

下面是一些示例说明了如何使用RENAME语句来重命名不同类型的对象：

1. 重命名表：

   RENAME TABLE table_name TO new_table_name;
   

   这将把名为table_name的表重命名为new_table_name。

2. 重命名列：

   ALTER TABLE table_name RENAME COLUMN column_name TO new_column_name;
   

   这将把名为table_name中的列column_name重命名为new_column_name。

3. 重命名索引：

   ALTER TABLE table_name RENAME INDEX index_name TO new_index_name;
   

   这将把名为table_name中的索引index_name重命名为new_index_name。

4. 重命名视图：

   RENAME VIEW view_name TO new_view_name;
   

   这将把名为view_name的视图重命名为new_view_name。

DML

MySQL中的DML代表数据操纵语言（Data Manipulation Language），它用于管理数据库中的数据。下面是一些常见的MySQL DML语句：

call

在MySQL中，DML（数据操作语言）是用于对数据库中的数据进行操作的语句。其中，CALL语句用于调用存储过程或函数。存储过程和函数是预先定义的一组SQL语句，它们可以接受参数并返回结果。

下面是CALL语句的语法：

CALL procedure_name(arguments);

其中，procedure_name是要调用的存储过程或函数的名称，arguments是传递给存储过程或函数的参数列表。

以下是一些关于CALL语句的详细解释和示例：

1. 调用存储过程：
   如果要调用存储过程，可以使用CALL语句，并提供所需的参数。例如，假设有一个名为GetCustomer的存储过程，它接受一个customer_id参数，并返回相应的客户信息：

   CALL GetCustomer(123);
   

   上述语句将调用名为GetCustomer的存储过程，并将参数值123传递给它。

2. 调用函数：
   如果要调用函数，也可以使用CALL语句。函数调用的语法与存储过程类似。例如，假设有一个名为CalculateTotal的函数，它接受两个参数并返回它们的总和：

   CALL CalculateTotal(10, 20);
   

   上述语句将调用名为CalculateTotal的函数，并将参数值10和20传递给它。

3. 获取存储过程或函数的返回值：
   存储过程和函数可以返回一个或多个值。要获取存储过程或函数的返回值，可以使用CALL语句并将其结果存储到变量中。例如，假设存储过程GetCustomer返回客户的姓名和地址，可以使用以下方式获取返回值：

   CALL GetCustomer(123) INTO @name, @address;
   

   上述语句将调用GetCustomer存储过程，并将返回的姓名和地址存储在变量@name和@address中。

总结来说，CALL语句用于调用存储过程或函数，并提供所需的参数。它可以用于执行一系列预定义的SQL语句，并且还可以获取存储过程或函数的返回值。

delete

在MySQL中，DML（Data Manipulation Language）的DELETE语句用于从数据库表中删除数据。DELETE语句允许你根据特定的条件删除表中的行。

DELETE语法如下所示：

DELETE FROM table_name
WHERE condition;

• DELETE FROM table_name指定要从哪个表中删除数据。
• WHERE condition是可选的，它允许你指定一个条件来限制删除的行。如果省略WHERE子句，则将删除表中的所有行。

以下是对DELETE语句的各个部分进行详细解释：

1. DELETE FROM: 这是DELETE语句的关键字和子句。它告诉MySQL你要执行删除操作，并指定要删除数据的表名。

2. table_name: 这是要删除数据的表的名称。你需要替换它为实际表名。

3. WHERE condition: 这是可选的部分，它允许你指定一个条件来限制删除的行。只有满足条件的行才会被删除。条件可以使用比较运算符（如=, <>, <, >, <=, >=）和逻辑运算符（如AND, OR, NOT）进行组合。

一些示例：

-- 删除表中的所有行
DELETE FROM table_name;

-- 删除符合条件的行
DELETE FROM table_name
WHERE condition;

-- 删除特定ID的行
DELETE FROM table_name
WHERE id = 1;

-- 删除符合多个条件的行
DELETE FROM table_name
WHERE condition1 AND condition2;

需要注意的是，DELETE语句执行后将永久性地从表中删除数据，并且无法撤销。因此，在执行DELETE语句之前，请务必谨慎，并确保你真正需要删除这些数据。在删除数据之前，最好先创建数据的备份以防止意外删除。

do

在MySQL中，DML代表数据操作语言（Data Manipulation Language），它是一组用于在数据库中执行数据操作的语句。其中，DO是MySQL的一个DML语句之一，它允许您执行一些简单的操作或计算，而无需返回任何结果。

DO语句的语法如下：

DO expr

在这里，expr是一个表达式，可以是一个函数调用、赋值操作、条件语句等。DO语句会按照给定的顺序执行expr中的操作，并且不会返回任何结果集。

下面是一些DO语句的示例：

1. 执行一个简单的计算并将结果存储在变量中：

DO @result := 2 + 3;

在这个例子中，DO语句执行了一个加法操作，并将结果存储在名为@result的用户变量中。

2. 执行一个函数调用：

DO SLEEP(5);

这个例子中的DO语句调用了MySQL的SLEEP函数，它会使当前线程休眠5秒钟。

3. 使用条件语句执行不同的操作：

DO IF (@condition = 1) THEN
    -- 执行操作1
ELSE
    -- 执行操作2
END IF;

在这个例子中，DO语句根据条件变量@condition的值执行不同的操作。

需要注意的是，DO语句通常用于执行一些简单的操作或计算，而不是用于处理复杂的查询或数据修改。如果您需要执行更复杂的操作，可能需要使用其他DML语句，如SELECT、INSERT、UPDATE或DELETE。

handler

Handler是MySQL的一个存储引擎接口，它允许开发者以编程的方式直接访问存储引擎，并对表的行进行操作。Handler提供了一组方法，可以用于遍历、读取、修改和删除表中的行。

以下是一些常用的Handler方法：

1. handler::open：打开一个表，并返回一个句柄，用于后续的操作。
2. handler::read：读取表中的下一行数据。
3. handler::update：更新当前行的数据。
4. handler::delete：删除当前行。
5. handler::insert：在表中插入一行新数据。
6. handler::index_read：根据索引读取表中的下一行数据。
7. handler::index_next：将读取指针移动到索引中的下一行。

使用Handler进行行级操作的一个典型场景是需要对大量数据进行批量处理或者数据的逐行处理。通过使用Handler，可以避免一次性将所有数据加载到内存中，而是可以按需读取和处理数据，节省内存和提高效率。

需要注意的是，Handler的功能和方法在不同的存储引擎中可能有所差异，因为每个存储引擎对于数据的组织和存储方式都有自己的实现。因此，在使用Handler之前，需要了解所使用的存储引擎对Handler的支持情况以及具体的使用方法。

另外，MySQL也提供了其他的编程接口和工具，如MySQL Connector/NET、MySQL Connector/J等，可以更方便地与MySQL数据库进行交互和操作。这些工具提供了更高级的抽象和功能，可以更快速地实现常见的数据库操作，而无需直接使用Handler接口。

insert

在MySQL中，DML代表数据操作语言（Data Manipulation Language），用于插入、更新和删除数据库中的数据。在DML中，INSERT语句用于将新的行插入到数据库表中。下面是INSERT语句的详细解释：

语法：

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

• INSERT INTO：指定要插入数据的表名。
• table_name：要插入数据的目标表的名称。
• (column1, column2, column3, ...)：指定要插入数据的列名。如果省略列名，那么将需要为所有表的列提供值。
• VALUES：用于指定要插入的值。
• (value1, value2, value3, ...)：指定要插入的实际值。它们必须与列名的顺序相对应。

示例：

INSERT INTO customers (id, name, email)
VALUES (1, 'John Doe', '[email protected]');

在上面的示例中，我们向"customers"表中插入了一行数据。我们指定了要插入的列（id、name和email），并提供了相应的值。

还有其他一些INSERT语句的用法，例如：

1. 插入多行数据：

INSERT INTO customers (id, name, email)
VALUES (1, 'John Doe', '[email protected]'),
       (2, 'Jane Smith', '[email protected]'),
       (3, 'Bob Johnson', '[email protected]');

使用逗号分隔的多个值集来一次性插入多行数据。

2. 插入选择查询的结果：

INSERT INTO customers (name, email)
SELECT name, email FROM new_customers;

这将从"new_customers"表中选择"name"和"email"列的值，并将它们插入到"customers"表中的相应列中。

注意：

• 字符串和日期类型数据应该包含在引号中
• 插入的数据大小应该在字段的规定范围内

load

在MySQL中，DML（Data Manipulation Language）是用于操作数据库中数据的一组语句。其中之一是LOAD语句，它用于将数据从外部源（如文本文件）加载到MySQL表中。LOAD语句可以非常有用，特别是当需要将大量数据批量导入数据库时。

LOAD语句的语法如下：

LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name'
    [REPLACE | IGNORE]
    INTO TABLE tbl_name
    [PARTITION (partition_name [, partition_name] ...)]
    [CHARACTER SET charset_name]
    [FIELDS
        [TERMINATED BY 'string']
        [ENCLOSED BY 'char']
        [ESCAPED BY 'char']
    ]
    [LINES
        [STARTING BY 'string']
        [TERMINATED BY 'string']
    ]
    [IGNORE number {LINES | ROWS}]
    [(col_name_or_user_var
        [, col_name_or_user_var] ...)]
    [SET col_name = expr
        [, col_name = expr] ...]

下面是LOAD语句中的各个组成部分的详细解释：

• LOW_PRIORITY：指定在数据加载期间使用低优先级。如果同时有其他读操作在进行，LOW_PRIORITY可以避免对读操作的干扰。它在后台运行，但可能导致加载时间延长。
• CONCURRENT：指定在数据加载期间允许并发插入。这对于在高负载环境下加载大量数据时非常有用。但需要注意，如果表上有触发器或外键约束，可能会导致性能下降。
• LOCAL：指定从客户端的本地文件系统加载数据，而不是从服务器文件系统加载。
• INFILE 'file_name'：指定要加载的外部数据文件的路径和文件名。
• REPLACE：如果指定了该选项，则新数据将替换表中的现有数据，如果存在相同的唯一键值。注意，这将删除现有数据，然后插入新数据。
• IGNORE：如果指定了该选项，则在加载数据时将忽略遇到的重复行，而不会导致错误。
• INTO TABLE tbl_name：指定要将数据加载到的目标表的名称。
• PARTITION (partition_name [, partition_name] ...)：如果目标表是分区表，可以指定要加载数据的特定分区。
• CHARACTER SET charset_name：指定外部数据文件中的字符集编码。
• FIELDS：用于定义字段分隔符、字段引用符和转义符的选项。
• LINES：用于定义行起始标识符和行终止标识符的选项。
• IGNORE number {LINES | ROWS}：指定要忽略的行数。
• col_name_or_user_var：指定要加载数据的目标表的列名或用户变量。
• SET col_name = expr：在加载数据时，可以使用表达式为目标表的列赋值。

这些选项可以根据需要进行组合使用，以满足特定的数据加载需求。需要注意的是，LOAD语句在加载数据时执行的是原子操作，要么全部成功，要么全部失败，不会部分成功部分失败。如果在加载数据期间出现错误，可以使用SHOW WARNINGS语句查看警告信息，并根据需要进行调整和处理。

replace

REPLACE语句用于插入或替换数据，它的工作方式类似于INSERT语句，但具有以下不同之处：

1. 如果要插入的行在表中不存在，则REPLACE语句将插入一条新记录，就像INSERT一样。

2. 如果要插入的行在表中已经存在（根据主键或唯一索引判断），则REPLACE语句将删除已存在的行，并插入一条新记录来替换它。

因此，REPLACE语句在插入数据时具有更新的能力，如果存在冲突的记录，则会覆盖它们。

REPLACE语句的基本语法如下：

REPLACE INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);

其中，table_name是要进行操作的表名，column1, column2, ...是要插入数据的列名，value1, value2, ...是要插入的具体数值。

需要注意的是，REPLACE语句要求目标表至少具有一个主键或唯一索引，这样才能判断行是否已经存在。否则，REPLACE语句将按照普通的INSERT语句进行操作，而不会执行替换操作。

另外，当使用REPLACE语句替换已存在的行时，MySQL会进行以下操作：

1. 删除已存在的行。

2. 插入新行。

因此，如果有其他与已存在行相关联的数据，这些数据也会被删除。这是REPLACE和UPDATE语句之间的一个重要区别。UPDATE语句只会更新已存在行的数据，而不会删除任何数据。

需要谨慎使用REPLACE语句，特别是在涉及与其他表关联的数据时。如果需要保留已存在行的相关数据，应该使用UPDATE语句进行更新操作。

select

SELECT语句是最常用的DML语句之一，用于从数据库表中检索数据。下面是SELECT语句的详细解释和一些常见用法：

• 基本语法：

  SELECT 列名1, 列名2, ... FROM 表名 WHERE 条件;
  

• 列名：表示要检索的列的名称。可以使用通配符(*)来选择所有列。

• 表名：表示要从中检索数据的表的名称。

• WHERE条件：用于过滤数据的条件表达式。可以使用比较操作符（如=、<>、<、>、<=、>=）、逻辑操作符（如AND、OR、NOT）以及通配符（如LIKE）进行条件过滤。

• 示例：

  -- 选择所有列的数据
  SELECT * FROM 表名;
  
  -- 选择特定列的数据
  SELECT 列名1, 列名2 FROM 表名;
  
  -- 选择符合条件的数据
  SELECT * FROM 表名 WHERE 列名 = 值;
  
  -- 使用逻辑操作符
  SELECT * FROM 表名 WHERE 列名1 = 值1 AND 列名2 <> 值2;
  
  -- 使用通配符进行模糊匹配
  SELECT * FROM 表名 WHERE 列名 LIKE '值%';
  

• 结果集排序：

  SELECT * FROM 表名 ORDER BY 列名 [ASC|DESC];
  

  可以使用ORDER BY子句对结果集进行排序。默认情况下，按升序（ASC）对数据进行排序，也可以使用降序（DESC）进行排序。

• 结果集限制：

  SELECT * FROM 表名 LIMIT 行数 OFFSET 偏移量;
  

  使用LIMIT关键字可以限制返回的行数。OFFSET可选，用于指定从结果集中的哪个位置开始返回行。

• 聚合函数：

  SELECT 聚合函数(列名) FROM 表名;
  

  可以使用聚合函数（如COUNT、SUM、AVG、MIN、MAX）对数据进行统计计算。

• select database();

  查询当前数据库

subqueries

子查询（subquery）是DML语句中的一个重要概念，它是嵌套在其他查询语句中的查询。

子查询可以嵌套在SELECT、INSERT、UPDATE和DELETE语句中，用于提供更复杂的查询和操作功能。下面详细解释MySQL中DML中的子查询用法：

1. SELECT语句中的子查询：
   子查询可以用作SELECT语句中的列子查询或表子查询。列子查询返回一个单一的值，作为SELECT语句中的一列数据。表子查询返回一个结果集，作为SELECT语句中的一个表。

   示例1：列子查询

   SELECT column1, (SELECT column2 FROM table2 WHERE condition) AS column3 FROM table1;
   

   示例2：表子查询

   SELECT column1, column2 FROM (SELECT column3, column4 FROM table2) AS subquery_table WHERE condition;
   

2. INSERT语句中的子查询：
   子查询可以用作INSERT语句中的值来源，可以从其他表中检索数据并插入到目标表中。

   示例：

   INSERT INTO table1 (column1, column2)
   SELECT column3, column4 FROM table2 WHERE condition;
   

3. UPDATE语句中的子查询：
   子查询可以用作UPDATE语句中的条件或更新的值来源。

   示例1：作为条件

   UPDATE table1 SET column1 = value WHERE column2 IN (SELECT column3 FROM table2 WHERE condition);
   

   示例2：作为更新的值来源

   UPDATE table1 SET column1 = (SELECT column2 FROM table2 WHERE condition) WHERE condition2;
   

4. DELETE语句中的子查询：
   子查询可以用作DELETE语句中的条件，用于指定要删除的行。

   示例：

   DELETE FROM table1 WHERE column1 IN (SELECT column2 FROM table2 WHERE condition);
   

子查询的优点是可以使查询更具灵活性和复杂性，可以嵌套多个子查询以实现更复杂的操作。然而，过多的子查询可能会影响查询性能，因此在使用子查询时应注意优化查询语句，避免性能问题。

upadte

UPDATE是DML的一种操作，用于修改数据库表中的现有数据。下面是对MySQL中UPDATE语句的详细解释：

语法：

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

• table_name：指定要更新数据的表名。
• SET：指定要更新的列和对应的新值。
• column1 = value1, column2 = value2, ...：指定要更新的列和它们的新值。可以更新多个列，每个列和值之间使用等号（=）分隔，不同列之间使用逗号（,）分隔。
• WHERE：可选的，用于指定更新数据的条件。只有满足条件的行才会被更新。如果没有指定WHERE子句，将更新表中的所有行。

示例：
假设有一个名为users的表，包含id、name和age列。我们可以使用UPDATE语句来更新表中的数据：

UPDATE users
SET name = 'John', age = 30
WHERE id = 1;

上述示例将表users中id为1的行的name列更新为’John’，age列更新为30。

注意事项：

• 如果不提供WHERE子句，将会更新表中的所有行，这可能导致意外修改大量数据。
• 使用WHERE子句可以精确指定要更新的行，避免对整个表进行更新。
• 在SET子句中，可以使用表达式、函数或者其他列的值来计算新值。
• 可以一次性更新多个列，每个列和新值之间使用等号（=）进行分隔。
• 更新操作会直接修改数据库中的数据，请谨慎使用，并确保在执行之前备份重要数据。

truncate

在MySQL中，DDL（数据定义语言）用于定义和管理数据库对象，如表、索引、视图等。其中，TRUNCATE语句是DDL语句之一，用于删除表中的所有数据。

TRUNCATE TABLE语句的作用是快速清空表中的数据，但保留表的结构、索引和约束等定义。与DELETE语句不同，TRUNCATE TABLE语句不会记录每一行删除的操作日志，因此执行速度更快。这使得TRUNCATE TABLE语句在需要删除表中所有数据时是一种高效的选择。

下面是TRUNCATE TABLE语句的语法：

TRUNCATE TABLE table_name;

其中，table_name是要清空数据的表名。

需要注意以下几点：

1. TRUNCATE TABLE语句将删除表中的所有行，而不是仅删除部分行。因此，在执行此语句之前，应谨慎备份或确认数据不再需要。

2. TRUNCATE TABLE语句将重置自增列（如果有的话），使下一次插入的数据从起始值开始。

3. TRUNCATE TABLE语句不会触发与表相关联的触发器（Trigger）。

4. TRUNCATE TABLE语句的执行权限要求与DELETE语句相同。

5. TRUNCATE TABLE语句不能用于视图，只能用于表。

总之，TRUNCATE TABLE语句是一种快速清空表数据的方法，适用于需要删除表中所有数据而不关心逐行删除的情况。但请务必在执行此语句之前进行数据备份或确认数据不再需要。

truncate和delete区别

MySQL的delete和truncate有以下主要区别:

1. delete删除指定的记录, truncate清空整个表。
2. delete影响行数,可以返回删除的记录数量。truncate不返回影响的行数。
3. delete支持where条件,可以 selectively删除记录。truncate清空整张表。
4. delete可以被回滚（会产生二进制日志）,支持事务。truncate是一个非事务性操作, committed后无法回滚（不会产生二进制日志）。
5. truncate效率更高,对于大表速度比delete快很多。
6. truncate清空表后,自动重新设置自增列。delete不会影响auto_increment的值。
7. 使用truncate后,需要重新创建表的约束(constraints)和触发器(triggers)。

用法:

• delete删除指定记录:

delete from table_name where condition;

• truncate清空整张表:

truncate table table_name;

一般来说:

• 如果要选择性的删除表中的某些记录,使用delete。
• 如果要清空一张大表的数据(不删除表结构),使用truncate。 truncate效率更高。

insert和replace区别

insert 和replace的区别主要有:

1. insert用于向表中插入新记录。replace用于替换表中的已存在记录。
2. insert不会替换已存在的记录,如果有重复的主键或唯一索引,则插入失败。replace会先删除已存在的记录,然后插入新记录。
3. insert可以插入多条记录,使用值列表。replace只能替换一条记录。
4. insert不影响其他非重复唯一索引。replace会删除已存在的记录,然后插入新记录,会影响其他索引。
5. insert默认不更新自动增长编号,replace会重新设定自动增长编号。

用法:

• insert插入:

INSERT INTO table_name (column1, column2, column3,...)
VALUES (value1, value2, value3,...)

• replace替换:

REPLACE INTO table_name (column1, column2, column3,...) 
VALUES (value1, value2, value3,...)

一般来说:

• 如果要向表中插入全新记录,使用insert。
• 如果要替换已存在的记录(根据主键或唯一索引),使用replace。 replace相当于先delete该条记录,然后再insert一条相同的记录。

所以:

• 如果只是更新记录内容,而不是完全替换一条记录,最好使用update语句。
• 如果要批量插入记录,使用insert更高效。

DQL

MySQL的DQL（Data Query Language）是指用于执行数据查询操作的语言，主要用于从数据库中检索数据。

DQL包括了一系列的关键字、子句和函数，用于指定查询的逻辑和条件。以下是MySQL中常用的DQL关键字和子句的详细介绍：

1. SELECT：用于指定要查询的字段列表。可以选择查询所有字段（使用星号 *）或指定具体的字段名。

2. FROM：用于指定要查询的表名或表的联接。可以查询单个表或多个表的联接结果。

3. WHERE：用于指定查询的筛选条件。可以使用各种条件操作符（例如等于、大于、小于等）来筛选满足特定条件的数据。

4. GROUP BY：用于按照指定的字段进行分组。可以将数据按照某个或多个字段的值进行分组，通常用于配合聚合函数进行数据统计。

5. HAVING：对分组后的结果进行筛选。可以使用条件表达式筛选满足特定条件的分组数据。

6. ORDER BY：用于指定查询结果的排序方式。可以按照一个或多个字段进行升序（ASC）或降序（DESC）排序。

7. LIMIT：用于限制返回结果的数量，用于分页或限制返回行数。可以指定从查询结果中的哪一行开始，以及返回的行数。

除了关键字和子句，MySQL的DQL还支持各种内置函数和运算符，用于处理查询结果、转换数据类型、进行数学计算等。

通过组合使用这些关键字、子句和函数，你可以构建复杂的查询语句，从数据库中获取特定条件下的数据、进行数据统计和分组、排序结果等。

SELECT

WHERE

在MySQL中，WHERE 子句是用于在查询语句中指定筛选条件的关键字。它用于从表中选择满足特定条件的数据行，并将其包含在结果集中。

语法：

SELECT column1, column2, ...
FROM table_name
WHERE condition;

WHERE condition;

• SELECT：指定要查询的列名或使用通配符 * 查询所有列。
• FROM：指定要查询的表名。
• WHERE：用于指定筛选条件。

在 WHERE 子句中，可以使用各种比较操作符和逻辑操作符来构建条件表达式。这些操作符用于比较列与值之间的关系，或比较列与列之间的关系，以确定是否满足特定的条件。

条件：

比较运算符	功能
>	大于
>=	大于等于
<	小于
<=	小于等于
=	等于
<> 或 !=	不等于
BETWEEN … AND …	在某个范围内（含最小、最大值）
IN(…)	在in之后的列表中的值，多选一
LIKE 占位符	模糊匹配（_匹配单个字符，%匹配任意个字符）
IS NULL	是NULL

逻辑运算符	功能
AND 或 &&	并且（多个条件同时成立）
OR 或 ||	或者（多个条件任意一个成立）
NOT 或 !	非，不是
xor	异或

还可以使用正则

例子

SELECT * 
FROM employees
WHERE age > 25 AND salary > 50000;

上述查询使用了两个条件，筛选出年龄大于25且薪资大于50000的员工数据。

between…and使用

SELECT PLAYERNO,BIRTH_DATE 
FROM PLAYERS
WHERE YEAR(BIRTH_DATE) BETWEEN 1962 AND	1964;

in、not in

SELECT PLAYERNO,BIRTH_DATE 
FROM PLAYERS
WHERE YEAR(BIRTH_DATE) IN(1965,1963,1970);

SELECT PLAYERNO,BIRTH_DATE 
FROM PLAYERS
WHERE YEAR(BIRTH_DATE) NOT IN(1965,1963,1970);

like

在MySQL中，LIKE 是一种用于模式匹配的操作符，常用于在查询中比较字符串。

LIKE 操作符通常与通配符一起使用，以确定一个字符串是否与给定的模式相匹配。以下是常用的通配符：

1. 百分号（%）：表示任意字符序列（包括零个字符或多个字符）。

• 例如：'abc%' 匹配以 “abc” 开头的任意字符序列。

2. 下划线（_）：表示单个字符的任意位置。

• 例如：'a_c' 匹配以 “a” 开头、以 “c” 结尾的三个字符的序列。

在某些情况下，如果要在模式中使用通配符字符 % 或 _ 本身，而不是作为通配符，需要进行转义。在MySQL中，可以使用 \ 进行转义。

在使用 LIKE 操作符时，可以在查询中将通配符放置在待匹配的字符串中，以进行模式匹配。以下是几个示例：

1. 匹配以特定字符串开头的值：

SELECT column_name
FROM table_name
WHERE column_name LIKE 'abc%';

2. 匹配以特定字符串结尾的值：

SELECT column_name
FROM table_name
WHERE column_name LIKE '%xyz';

3. 匹配包含特定字符串的值：

SELECT column_name
FROM table_name
WHERE column_name LIKE '%def%';

4. 使用下划线进行单个字符匹配：

SELECT column_name
FROM table_name
WHERE column_name LIKE 'a_c';

需要注意的是，LIKE 操作符默认是不区分大小写的，如果要进行大小写敏感的匹配，可以使用 COLLATE 子句指定区分大小写的字符集。

regexp

在MySQL中，REGEXP 是一种用于执行正则表达式匹配的操作符。它用于比较一个字符串是否与指定的正则表达式模式匹配。

REGEXP 操作符的语法如下：

SELECT column_name(s)
FROM table_name
WHERE column_name REGEXP pattern;

其中，column_name 是要比较的列名，table_name 是要查询的表名，pattern 是要匹配的正则表达式模式。

正则表达式是一种用于模式匹配和搜索的强大工具，可以使用各种元字符和模式修饰符来定义匹配规则。在 MySQL 中，使用基于 POSIX 扩展的正则表达式语法。

以下是一些常见的正则表达式元字符和模式修饰符的示例：

• .：匹配任意单个字符。
• *：匹配前一个元素零次或多次。
• +：匹配前一个元素一次或多次。
• ?：匹配前一个元素零次或一次。
• ^：匹配输入字符串的开始位置。
• $：匹配输入字符串的结束位置。
• [...]：匹配方括号内的任意一个字符。
• (a|b)：匹配 a 或 b。

例如，以下是几个使用 REGEXP 进行正则表达式匹配的示例：

1. 匹配以数字开头的字符串：

   SELECT column_name
   FROM table_name
   WHERE column_name REGEXP '^[0-9]';
   

2. 匹配包含指定单词的字符串：

   SELECT column_name
   FROM table_name
   WHERE column_name REGEXP '[[:<:]]word[[:>:]]';
   

3. 匹配以特定模式结尾的字符串：

   SELECT column_name
   FROM table_name
   WHERE column_name REGEXP 'pattern$';
   

需要注意的是，正则表达式模式区分大小写。如果希望进行不区分大小写的匹配，可以在 REGEXP 前面添加 BINARY 关键字。

FROM

GROUP BY

在MySQL中，分组查询（Group By）用于将结果集按照一个或多个列的值进行分组，并对每个组应用聚合函数，如求和、计数、平均值等。分组查询常用于统计和汇总数据。

下面是分组查询的基本语法：

SELECT column1, column2, ..., aggregate_function(column)
FROM table_name
WHERE conditions
GROUP BY column1, column2, ...

其中，column1, column2, ... 是你要选择的列名，aggregate_function(column) 是对某一列应用的聚合函数（如SUM、COUNT、AVG等），table_name 是要查询的表名，conditions 是可选的筛选条件。

以下是一个示例，演示如何使用分组查询计算每个部门的平均工资：

SELECT department, AVG(salary) AS average_salary
FROM employees
GROUP BY department;

上述查询从名为 employees 的表中选择了 department 列和 salary 列，并对 salary 列应用了聚合函数 AVG。然后，根据 department 列对结果进行分组，最后得到每个部门的平均工资。

注意事项：

• 分组查询中可以同时使用多个列进行分组，只需在 GROUP BY 子句中指定相应的列名即可。
• 除了聚合函数之外，SELECT 子句中列名必须是分组列或聚合函数的结果列。
• 可以使用 HAVING 子句对分组后的结果进行进一步筛选。

例如，以下查询演示了如何筛选出平均工资大于 5000 的部门：

SELECT department, AVG(salary) AS average_salary
FROM employees
GROUP BY department
HAVING average_salary > 5000;

SELECT playerno,SUM(amount) FROM PENALTIES GROUP BY playerno ORDER BY SUM(amount) DESC

HAVING

在MySQL中，HAVING 子句用于在查询结果上应用筛选条件，对分组后的数据进行筛选。它通常与 GROUP BY 子句一起使用，用于对聚合函数的结果进行过滤。

以下是 HAVING 子句的详细解释：

语法：

SELECT column1, column2, ...
FROM table_name
GROUP BY column1, column2, ...
HAVING condition;

• SELECT：指定要查询的列名或使用通配符 * 查询所有列。
• FROM：指定要查询的表名。
• GROUP BY：用于对结果进行分组的列或表达式。
• HAVING：用于指定筛选条件。

HAVING 子句类似于 WHERE 子句，但它是在分组后应用于分组结果的。它允许你对分组的结果使用聚合函数，并筛选满足特定条件的分组。

例如，以下是一个使用 HAVING 子句的示例：

SELECT category, COUNT(*) as count
FROM products
GROUP BY category
HAVING count > 5;

上述示例中，查询了 products 表中的不同产品类别，并使用 GROUP BY 对它们进行分组。然后使用 HAVING 子句筛选出产品数超过5个的分组。

需要注意的是，HAVING 子句只能在使用 GROUP BY 进行分组操作时使用。它对分组结果进行筛选，而不是对原始数据行进行筛选。如果不使用 GROUP BY 子句，HAVING 子句将不起作用。

使用 HAVING 子句可以对聚合函数的结果进行进一步筛选，以满足特定的条件。它允许对分组后的数据进行筛选，并从中选择满足条件的分组结果。

例子

有多少球员住在Stratford并且性别是男性的，输出数量和名字？

SELECT town,COUNT(*) ,GROUP_CONCAT(NAME) FROM PLAYERS 
	GROUP BY TOWN
	HAVING TOWN = "Stratford"

ORDER BY

在MySQL中，ORDER BY 子句用于对查询结果进行排序，按照指定的列或表达式的值进行升序或降序排列。ORDER BY 子句通常紧跟在 SELECT 语句的最后。

以下是 ORDER BY 子句的详细介绍：

语法：

SELECT column1, column2, ...
FROM table_name
ORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...;

• SELECT：指定要查询的列名或使用通配符 * 查询所有列。
• FROM：指定要查询的表名。
• ORDER BY：用于指定排序的列或表达式，以及排序的顺序。

在 ORDER BY 子句中，可以指定一个或多个列作为排序的依据。每个列可以单独指定升序（ASC，默认）或降序（DESC）排序方式。如果没有指定排序方式，默认为升序排序。

例如，以下是几个使用 ORDER BY 进行排序的示例：

1. 按照单个列进行排序：

   SELECT name, age, city
   FROM customers
   ORDER BY age DESC;
   

   上述示例将按照 age 列的降序对结果进行排序。

2. 按照多个列进行排序：

   SELECT name, age, city
   FROM customers
   ORDER BY city ASC, age DESC;
   

   上述示例将首先按照 city 列的升序排序，然后在相同的 city 值下按照 age 列的降序排序。

需要注意的是，可以根据具体需求在 ORDER BY 子句中指定任意数量的列。排序的顺序是从左到右依次应用的，即先按照第一个列排序，再按照第二个列排序，以此类推。

注意

只有在group by出现的字段才能在select选择，其他的需要聚合函数

例子

查询每个城市的名称和球员的数量

SELECT town,COUNT(*) FROM PLAYERS GROUP BY town

LIMIT

在MySQL中，LIMIT 子句用于限制查询结果返回的行数。它通常与 SELECT 语句一起使用，用于分页或限制结果集大小。

以下是 LIMIT 子句的详细介绍：

语法：

SELECT column1, column2, ...
FROM table_name
LIMIT offset, count;

• SELECT：指定要查询的列名或使用通配符 * 查询所有列。
• FROM：指定要查询的表名。
• LIMIT：用于指定限制条件。

LIMIT 子句中有两个参数：

• offset：指定从结果集中的哪一行开始返回数据（偏移量），默认从第一行开始。
• count：指定要返回的行数。

例如，以下是几个使用 LIMIT 进行结果集限制的示例：

1. 返回前 n 行：

   SELECT * FROM table_name LIMIT n;
   

   上述示例将返回查询结果中的前 n 行数据。

2. 返回从 m 行开始的 n 行数据：

   SELECT * FROM table_name LIMIT m, n;
   

   上述示例将返回从第 m+1 行开始的 n 行数据。

LIMIT 子句对于分页查询非常有用，可以将大的结果集划分为多个页面显示。通过指定偏移量和行数，可以选择要返回的特定数据范围。

需要注意的是，LIMIT 子句在排序之前应用。因此，如果没有指定排序规则，结果集的顺序可能是不确定的。

总结来说，LIMIT 子句用于限制查询结果返回的行数。它通过指定偏移量和行数来选择要返回的特定数据范围。在分页查询和结果集限制方面，LIMIT 子句是一个非常有用的工具。

例子

得到球员编号最低的5个球员的编号和名字，从第4个球员开始

SELECT playerno,NAME FROM PLAYERS
ORDER BY playerno
LIMIT 3,5

该查询语句将从 PLAYERS 表中选择 playerno 和 NAME 两列的数据，并按照 playerno 列的升序进行排序。然后，从排序后的结果中跳过前 3 行，返回接下来的 5 行数据作为最终的结果集。

和子查询连用

4个最低的罚款额的平均值是多少？

SELECT AVG(amount) FROM
(SELECT DISTINCT amount FROM PENALTIES
ORDER BY amount
LIMIT 4) result;

该查询语句首先从 PENALTIES 表中选择不重复的 amount 列值，并按照升序进行排序，然后仅返回前 4 行数据。接下来，针对这个结果集进行平均值计算，并将平均值作为最终结果返回。

为什么一定要有别名的原因

在该查询语句中，将子查询 (SELECT DISTINCT amount FROM PENALTIES ORDER BY amount LIMIT 4) 命名为 result 是为了将其作为一个临时表或视图，并为其创建一个可引用的别名。这样可以在外部查询中引用该子查询的结果。

where和having区别

MySQL中的WHERE和HAVING都是用于在查询中过滤数据的子句，但它们在使用和适用范围上有一些区别。

1. WHERE子句：

   • WHERE子句用于在查询中过滤行数据，它出现在SELECT语句中的FROM子句之后和GROUP BY子句之前。
   • WHERE子句可以包含条件表达式，用于筛选满足特定条件的行。
   • WHERE子句中使用的条件表达式可以包含列名、运算符（如=、<>、<、>、LIKE等）和常量值。
   • WHERE子句可以使用逻辑运算符（如AND、OR、NOT）将多个条件组合起来。

2. HAVING子句：

   • HAVING子句用于在查询中过滤分组后的数据，它出现在GROUP BY子句之后和ORDER BY子句之前。
   • HAVING子句可以包含条件表达式，用于筛选满足特定条件的分组。
   • HAVING子句中使用的条件表达式可以包含聚合函数（如SUM、AVG、COUNT等）、列名、运算符和常量值。
   • HAVING子句可以使用逻辑运算符将多个条件组合起来。

主要区别：

• WHERE子句在查询执行之前进行过滤，它作用于原始数据表中的行，排除不符合条件的行。而HAVING子句在数据分组之后进行过滤，它作用于分组后的结果集，排除不符合条件的分组。
• WHERE子句可以在任何查询中使用，无论是否有分组操作。而HAVING子句只能在包含GROUP BY子句的查询中使用。
• WHERE子句中的条件可以包含任何列，包括聚合函数的参数列。而HAVING子句中的条件只能使用聚合函数和分组后的列。

简而言之，WHERE用于筛选行数据，HAVING用于筛选分组后的数据。如果没有分组操作，通常使用WHERE子句；如果有分组操作，需要对分组进行过滤时，使用HAVING子句。

• 执行顺序：where > 聚合函数 > having
• 分组之后，查询的字段一般为聚合函数和分组字段，查询其他字段无任何意义

其他

show

下面是SHOW语句的几种常见用法和它们的详解：

• SHOW DATABASES;
  这个语句用于显示所有可用的数据库。它返回一个结果集，其中包含数据库的名称列表。

• SHOW TABLES;
  这个语句用于显示当前数据库中的所有表。它返回一个结果集，其中包含表的名称列表。

• SHOW COLUMNS FROM table_name;
  这个语句用于显示指定表的列信息。它返回一个结果集，其中包含列的名称、数据类型、长度、是否允许NULL值等信息。

• SHOW INDEX FROM table_name;
  这个语句用于显示指定表的索引信息。它返回一个结果集，其中包含索引的名称、所属表、列名等信息。

• SHOW CREATE TABLE table_name;
  这个语句用于显示创建指定表的DDL语句。它返回一个结果集，其中包含创建表的完整DDL语句。

• SHOW PROCESSLIST;
  这个语句用于显示当前数据库服务器上的所有活动连接和它们的相关信息。它返回一个结果集，其中包含连接ID、用户、执行的查询等信息。

• SHOW VARIABLES;
  这个语句用于显示当前数据库服务器的配置变量信息。它返回一个结果集，其中包含变量的名称和值。

• show create database ydh;

  MySQL将返回一个包含名为"ydh"的数据库创建语句的结果集。

desc

在MySQL中，DESC（Describe）是一种DDL（数据定义语言）命令，用于显示表结构的详细信息。DESC命令用于显示表的列名、数据类型、默认值、是否为NULL、键信息等，以便更好地了解表的结构和内容。

以下是DESC命令的常见用法和示例：

1. 显示表结构

使用DESC语句可以显示指定表的结构。例如：

DESC mytable;

上述语句将显示mytable表的结构，包括列名、数据类型、默认值、是否为NULL、键信息等。

2. 显示视图结构

使用DESC语句也可以显示指定视图的结构。例如：

DESC myview;

上述语句将显示myview视图的结构，包括列名、数据类型、默认值、是否为NULL等。

需要注意的是，DESC命令用于显示表或视图的结构信息，但并不执行任何实际的操作。在使用DESC命令时，应该确保指定正确的表或视图名称，并注意表或视图的大小写、引号等细节。

use

USE 是一种特殊的 DML 语句，用于选择当前要操作的数据库。

USE 语句的语法如下：

USE database_name;

其中，database_name 是要选择的数据库的名称。

USE 语句的作用是将当前会话的默认数据库更改为指定的数据库。一旦执行了 USE 语句，后续的 DML 语句将在指定的数据库上执行，除非另外指定了数据库的名称。

例如，假设我们有两个数据库：db1 和 db2。如果我们想在 db1 中执行操作，我们可以使用以下语句：

USE db1;

现在，任何后续的 DML 语句（如 SELECT、INSERT、UPDATE、DELETE 等）将默认在 db1 数据库上执行。如果我们希望在 db2 数据库上执行操作，我们可以再次使用 USE 语句切换到 db2：

USE db2;

需要注意的是，USE 语句只影响当前会话中的默认数据库，对其他会话没有影响。当会话结束时，默认数据库将重置为连接时的默认数据库。

使用 USE 语句可以方便地切换数据库，避免在每个 DML 语句中都指定数据库名称。

comment

在MySQL中，COMMENT是一种用于给数据库对象（如表、列、索引等）添加注释或描述的功能。注释对于理解数据库结构、目的和用途非常有帮助，特别是在多人协作或维护大型数据库时。

在MySQL中，可以使用COMMENT关键字来添加注释。下面是一些常见的用法和示例：

1. 表注释：可以在创建表时或者修改表时为表添加注释。

   • 创建表时添加注释：

     CREATE TABLE my_table (
       id INT,
       name VARCHAR(50)
     ) COMMENT 'This is my table';
     

   • 修改表时添加注释：

     ALTER TABLE my_table COMMENT 'This is my table';
     

2. 列注释：可以在创建表时或者修改表时为表中的列添加注释。

   • 创建表时添加注释：

     CREATE TABLE my_table (
       id INT COMMENT 'Unique identifier',
       name VARCHAR(50) COMMENT 'Name of the entity'
     );
     

   • 修改表时添加注释：

     ALTER TABLE my_table MODIFY COLUMN id INT COMMENT 'Unique identifier';
     

3. 索引注释：可以为索引添加注释，帮助理解索引的作用或用途。

   • 创建索引时添加注释：

     CREATE INDEX index_name ON my_table (column_name) COMMENT 'Index for efficient searching';
     

4. 视图注释：可以为视图添加注释，描述视图的目的和功能。

   • 创建视图时添加注释：

     CREATE VIEW my_view AS SELECT * FROM my_table COMMENT 'This is my view';
     

5. 存储过程和函数注释：可以为存储过程和函数添加注释，提供说明和使用方法。

   • 创建存储过程时添加注释：

     CREATE PROCEDURE my_procedure() COMMENT 'This is my stored procedure'
     BEGIN
       -- Procedure logic goes here
     END;
     

   • 创建函数时添加注释：

     CREATE FUNCTION my_function() RETURNS INT COMMENT 'This is my function'
     BEGIN
       -- Function logic goes here
     END;
     

可以使用SHOW CREATE TABLE语句或查询INFORMATION_SCHEMA数据库中的相应表来查看数据库对象的注释信息。例如，要查看表注释，可以运行以下查询：

SELECT TABLE_COMMENT
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA = 'your_database_name'
  AND TABLE_NAME = 'your_table_name';

注释对于文档化数据库结构、提高代码可读性和协作非常有用。它们可以帮助开发人员更好地理解数据库对象的用途和设计意图。

engine

MySQL是一种流行的关系型数据库管理系统，它提供了多种存储引擎（Engine）供用户选择。存储引擎是MySQL用于存储、检索和管理数据的组件。每个存储引擎都有其特定的功能、优势和限制，允许用户根据应用程序的需求选择最适合的引擎。

以下是MySQL中一些常见的存储引擎：

1. MyISAM：这是MySQL的默认存储引擎，在早期版本中使用较为广泛。它使用表级锁定（table-level locking）来控制并发访问，适用于读密集型应用。MyISAM不支持事务处理和崩溃恢复，但具有较高的性能和较小的存储空间需求。

   1. 使用myisam

   root@ydh 20:36 mysql>create table test(id int,name varchar(10)) engine=myisam;
   Query OK, 0 rows affected (0.01 sec)
   
   

   [root@mysql ydh]# ls
   db.opt  student_info.frm  student_info.ibd  test.frm  test.MYD  test.MYI
   

   • test.frm: 表结构文件，frame框架
   • test.MYD ：存放数据
   • test.MYI：存储索引

   索引

   索引在数据库中起到了重要的作用，它们提供了一种快速访问数据库表中数据的方式。索引是特殊的数据结构，用于加快数据库查询的速度和性能。当你执行查询时，数据库可以利用索引来快速定位和检索符合查询条件的数据，而不需要逐行扫描整个表

2. InnoDB：这是MySQL的另一个常用存储引擎，也是默认的事务性存储引擎。InnoDB支持行级锁定（row-level locking），提供了高度的并发性能和事务支持。它具有较好的崩溃恢复机制和数据完整性保护，并支持外键约束。

3. MEMORY：（基于hash）也称为HEAP，它将数据存储在内存中，以提供快速的读写访问。MEMORY存储引擎适用于临时表、缓存和其他需要快速访问的数据。但是，由于数据存储在内存中，它对于大量数据的存储有限制。

4. csv： 是一个文本文件，里面的字段以逗号作为分割符号 --》文件存储的文件 --》数据分析

   • [root@mysql ~]# awk -F: 'OFS=","{print $1,$2,$3,$5}' /etc/passwd >test_csv.csv
     

   • 指定引擎

   • CREATE TABLE table_name (
       column1 datatype,
       column2 datatype,
       ...
     ) ENGINE = engine_name;
     
     

要在MySQL中选择存储引擎，你可以在创建表时使用ENGINE关键字指定引擎类型，或者在配置文件中设置默认引擎。此外，你还可以使用ALTER TABLE语句更改现有表的存储引擎。

别名

在MySQL中，别名（Alias）是一种给表名、列名或表达式指定临时名称的方法。使用别名可以简化查询语句、提高可读性，并允许对结果集中的列进行重命名（可以不接as）。

别名可以在SELECT语句和FROM子句中使用，如下所示：

1. 列别名：

   • 列别名用于给查询结果中的列指定一个临时名称。使用别名可以更改列名，使其更具描述性或可读性。

   例如，在SELECT语句中，可以使用AS关键字或直接使用空格来为列指定别名：

   SELECT column_name AS alias_name
   FROM table_name;
   
   -- 或者
   
   SELECT column_name alias_name
   FROM table_name;
   

2. 表别名：

   • 表别名用于为查询语句中的表指定一个临时名称，以便在查询中更简洁地引用表。

   例如，在FROM子句中，可以使用AS关键字或直接使用空格来为表指定别名：

   SELECT column_name
   FROM table_name AS alias_name;
   
   -- 或者
   
   SELECT column_name
   FROM table_name alias_name;
   

   使用表别名后，可以在查询中使用别名来引用表，而不是完整的表名。

3. 列表达式别名：

   • 除了给列和表指定别名外，还可以给列表达式（如计算表达式或函数表达式）指定别名。

   例如，使用计算表达式：

   SELECT column1 + column2 AS result
   FROM table_name;
   

   在上述示例中，通过计算表达式将column1和column2相加，并将结果命名为result作为查询结果的列名。

使用别名可以使查询结果更易读，同时在复杂的查询语句中可以简化引用和处理列和表。别名的作用仅限于查询语句的执行期间，不会对数据库中的实际结构和数据产生影响。