笔记首页 >> sql >> SQL – 快速指南

SQL – 快速指南

SQL – 概述

SQL是一种操作数据库的语言；它包括数据库的创建、删除、取行、修改行等。SQL是ANSI（美国国家标准协会）的标准语言，但是SQL语言有很多不同的版本。

什么是 SQL？

SQL 是结构化查询语言，它是一种用于存储、操作和检索存储在关系数据库中的数据的计算机语言。

SQL 是关系数据库系统的标准语言。所有关系数据库管理系统 (RDMS)，如 MySQL、MS Access、Oracle、Sybase、Informix、Postgres 和 SQL Server，都使用 SQL 作为其标准数据库语言。

此外，他们使用不同的方言，例如 –

使用 T-SQL 的 MS SQL Server，
Oracle 使用 PL/SQL，
SQL 的 MS Access 版本称为 JET SQL（本机格式）等。

为什么是 SQL？

SQL 广受欢迎，因为它具有以下优点 –

允许用户访问关系数据库管理系统中的数据。
允许用户描述数据。
允许用户定义数据库中的数据并操作该数据。
允许使用 SQL 模块、库和预编译器嵌入其他语言。
允许用户创建和删除数据库和表。
允许用户在数据库中创建视图、存储过程、函数。
允许用户设置表、过程和视图的权限。

SQL 简史

1970 年– IBM 的 Edgar F. “Ted” Codd 博士被称为关系数据库之父。他描述了数据库的关系模型。
1974 – 结构化查询语言出现。
1978 – IBM 致力于开发 Codd 的想法并发布了名为 System/R 的产品。
1986 – IBM 开发了关系数据库的第一个原型并由 ANSI 标准化。第一个关系数据库是由 Relational Software 发布的，后来被称为 Oracle。

SQL进程

当您为任何 RDBMS 执行 SQL 命令时，系统会确定执行请求的最佳方式，而 SQL 引擎会确定如何解释任务。

此过程中包含各种组件。

这些组件是 –

查询调度器
优化引擎
经典查询引擎
SQL查询引擎等

经典查询引擎处理所有非 SQL 查询，但 SQL 查询引擎不会处理逻辑文件。

以下是显示 SQL 架构的简单图表 –

SQL 架构

SQL 命令

与关系数据库交互的标准 SQL 命令是 CREATE、SELECT、INSERT、UPDATE、DELETE 和 DROP。这些命令可以根据其性质分为以下几组 –

DDL – 数据定义语言

Sr.No.	命令和描述
1	CREATE 在数据库中创建新表、表的视图或其他对象。
2	ALTER 修改现有的数据库对象，例如表。
3	DROP 删除整个表、表的视图或数据库中的其他对象。

Sr.No.

命令和描述

CREATE

在数据库中创建新表、表的视图或其他对象。

ALTER

修改现有的数据库对象，例如表。

DROP

删除整个表、表的视图或数据库中的其他对象。

DML – 数据操作语言

Sr.No.	命令和描述
1	SELECT 从一个或多个表中检索某些记录。
2	INSERT 创建记录。
3	UPDATE 修改记录。
4	DELETE 删除记录。

DCL – 数据控制语言

Sr.No.	命令和描述
1	GRANT 授予用户特权。
2	REVOKE 收回用户授予的权限。

Sr.No.

命令和描述

GRANT

授予用户特权。

REVOKE

收回用户授予的权限。

SQL – RDBMS 概念

什么是关系型数据库？

RDBMS代表– [R elational d atabase中号anagement小号ystem。RDBMS 是 SQL 以及所有现代数据库系统（如 MS SQL Server、IBM DB2、Oracle、MySQL 和 Microsoft Access）的基础。

关系数据库管理系统 (RDBMS) 是基于 EF Codd 引入的关系模型的数据库管理系统 (DBMS)。

什么是表？

RDBMS 中的数据存储在称为表的数据库对象中。该表基本上是相关数据条目的集合，它由许多列和行组成。

请记住，表是关系数据库中最常见和最简单的数据存储形式。以下程序是 CUSTOMERS 表的示例 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

什么是字段？

每个表都被分解为称为字段的更小的实体。CUSTOMERS 表中的字段包括 ID、NAME、AGE、ADDRESS 和 SALARY。

字段是表中的一列，旨在维护有关表中每条记录的特定信息。

什么是记录或行？

记录也称为一行数据，它是表中存在的每个单独条目。例如，上面的 CUSTOMERS 表中有 7 条记录。以下是 CUSTOMERS 表中的单行数据或记录 –

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

记录是表中的水平实体。

什么是柱子？

列是表中的垂直实体，包含与表中特定字段关联的所有信息。

例如，CUSTOMERS 表中的一列是 ADDRESS，表示位置描述，如下所示 –

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

什么是 NULL 值？

表中的 NULL 值是字段中显示为空白的值，这意味着具有 NULL 值的字段是没有值的字段。

了解 NULL 值不同于零值或包含空格的字段非常重要。具有 NULL 值的字段是在创建记录期间留空的字段。

SQL 约束

约束是对表的数据列强制执行的规则。这些用于限制可以进入表的数据类型。这保证了数据库中数据的准确性和可靠性。

约束可以是列级别或表级别。列级约束仅应用于一列，而表级约束应用于整个表。

以下是 SQL 中可用的一些最常用的约束 –

NOT NULL Constraint – 确保列不能有 NULL 值。
DEFAULT Constraint – 当没有指定时，为列提供默认值。
UNIQUE Constraint – 确保列中的所有值都不同。
PRIMARY Key – 唯一标识数据库表中的每一行/记录。
FOREIGN Key – 唯一标识任何其他数据库表中的行/记录。
CHECK Constraint – CHECK 约束确保列中的所有值都满足某些条件。
INDEX – 用于非常快速地从数据库创建和检索数据。

数据的完整性

每个 RDBMS 都存在以下数据完整性类别 –

实体完整性 –表中没有重复的行。
域完整性 –通过限制类型、格式或值范围来强制给定列的有效条目。
参照完整性 –不能删除其他记录使用的行。
用户定义的完整性 –强制执行一些不属于实体、域或参照完整性的特定业务规则。

数据库规范化

数据库规范化是在数据库中有效组织数据的过程。这种标准化过程有两个原因 –

消除冗余数据，例如将相同的数据存储在多个表中。
确保数据依赖是有意义的。

这两个原因都是有价值的目标，因为它们减少了数据库消耗的空间量并确保数据以逻辑方式存储。规范化包含一系列指导方针，可帮助指导您创建良好的数据库结构。

规范化指南分为范式；将表单视为数据库结构的格式或布局方式。范式的目的是组织数据库结构，使其符合第一范式，然后是第二范式，最后是第三范式的规则。

你可以选择更进一步，去第四范式、第五范式等等，但一般来说，第三范式是绰绰有余的。

SQL – RDBMS 数据库

有许多流行的 RDBMS 可供使用。本教程简要概述了一些最流行的 RDBMS。这将帮助您比较它们的基本功能。

MySQL

MySQL 是一个开源的 SQL 数据库，由瑞典公司 MySQL AB 开发。MySQL 读作“my ess-que-ell”，而 SQL 读作“sequel”。

MySQL 支持许多不同的平台，包括 Microsoft Windows、主要的 Linux 发行版、UNIX 和 Mac OS X。

MySQL 有免费和付费版本，具体取决于其使用（非商业/商业）和功能。MySQL 带有一个非常快速、多线程、多用户和健壮的 SQL 数据库服务器。

历史

MySQL 的开发由 Michael Widenius 和 David Axmark 于 1994 年开始。
23 日首次内部发布^rd 1995 年 5 月。
Windows 版本于 8 日发布^th 1998 年 1 月，适用于 Windows 95 和 NT。
版本 3.23：从 2000 年 6 月开始测试，2001 年 1 月发布生产版本。
4.0 版：从 2002 年 8 月开始测试，2003 年 3 月发布（联合）。
4.1 版：从 2004 年 6 月开始测试，2004 年 10 月发布生产版本。
5.0 版：从 2005 年 3 月开始测试，2005 年 10 月发布生产版本。
Sun Microsystems 于 26 日收购了 MySQL AB^th 2008 年 2 月。
版本 5.1：生产版本 27^th 2008 年 11 月。

特征

高性能。
高可用性。
可扩展性和灵活性运行任何东西。
强大的交易支持。
Web 和数据仓库优势。
强大的数据保护。
综合应用开发。
管理轻松。
开源自由和 24 x 7 支持。
最低的总拥有成本。

微软 SQL 服务器

MS SQL Server 是由 Microsoft Inc. 开发的关系数据库管理系统。其主要查询语言是 –

查询语句
ANSI SQL

历史

1987 年 – Sybase 发布了适用于 UNIX 的 SQL Server。
1988 年 – Microsoft、Sybase 和 Aston-Tate 将 SQL Server 移植到 OS/2。
1989 年 – Microsoft、Sybase 和 Aston-Tate 发布了用于 OS/2 的 SQL Server 1.0。
1990 – SQL Server 1.1 发布，支持 Windows 3.0 客户端。
Aston – Tate 退出 SQL Server 开发。
2000 – Microsoft 发布 SQL Server 2000。
2001 – Microsoft 为 SQL Server Web Release 1 发布 XML（下载）。
2002 – Microsoft 发布 SQLXML 2.0（从 XML for SQL Server 重命名）。
2002 – Microsoft 发布 SQLXML 3.0。
2005 – Microsoft 于 2005 年 11 月 7 日发布了 SQL Server 2005。

特征

高性能
高可用性
数据库镜像
数据库快照
CLR 集成
服务代理
DDL 触发器
排名功能
基于行版本的隔离级别
XML 集成
试着抓
数据库邮件

甲骨文

它是一个非常大的基于多用户的数据库管理系统。Oracle 是由’Oracle Corporation’ 开发的关系数据库管理系统。

Oracle 致力于有效地管理其资源，即在网络中请求和发送数据的多个客户端之间的信息数据库。

它是用于客户端/服务器计算的出色数据库服务器选择。Oracle 支持客户端和服务器的所有主要操作系统，包括 MSDOS、NetWare、UnixWare、OS/2 和大多数 UNIX 版本。

历史

甲骨文始于 1977 年，庆祝其在该行业度过的 32 年（从 1977 年到 2009 年）。

1977 – Larry Ellison、Bob Miner 和 Ed Oates 成立了软件开发实验室来承担开发工作。
1979 – Oracle 2.0 版发布，成为第一个商业关系数据库和第一个 SQL 数据库。该公司更名为 Relational Software Inc. (RSI)。
1981 – RSI 开始为 Oracle 开发工具。
1982 – RSI 更名为甲骨文公司。
1983 – Oracle 发布 3.0 版，用 C 语言重写并在多个平台上运行。
1984 年 – 发布了 Oracle 4.0 版。它包含并发控制——多版本读取一致性等功能。
1985 年 – 发布了 Oracle 4.0 版。它包含并发控制——多版本读取一致性等功能。
2007 – Oracle 发布了 Oracle11g。新版本专注于更好的分区，易于迁移等。

特征

并发
读取一致性
锁定机制
静止数据库
可移植性
自管理数据库
SQL*Plus
自动售货机
调度器
资源管理器
数据仓库
物化视图
位图索引
表压缩
并行执行
分析 SQL
数据挖掘
分区

访问权限

这是最流行的微软产品之一。Microsoft Access 是入门级数据库管理软件。MS Access 数据库不仅价格低廉，而且还是适用于小型项目的强大数据库。

MS Access 使用 Jet 数据库引擎，该引擎使用特定的 SQL 语言方言（有时称为 Jet SQL）。

MS Access 附带专业版的 MS Office 软件包。MS Access 具有易于使用的直观图形界面。

1992 – Access 1.0 版发布。
1993 年 – 发布 Access 1.1 以改进包含 Access Basic 编程语言的兼容性。
最重要的转变是从 Access 97 到 Access 2000。
2007 – Access 2007，引入了一种新的数据库格式 ACCDB，它支持复杂的数据类型，例如多值和附件字段。

特征

用户可以创建表格、查询、表单和报告，并使用宏将它们连接在一起。
可选择将数据导入和导出为多种格式，包括 Excel、Outlook、ASCII、dBase、Paradox、FoxPro、SQL Server、Oracle、ODBC 等。
还有 Jet 数据库格式（Access 2007 中的 MDB 或 ACCDB），它可以在一个文件中包含应用程序和数据。这使得将整个应用程序分发给另一个用户非常方便，他们可以在断开连接的环境中运行它。
Microsoft Access 提供参数化查询。这些查询和 Access 表可以通过 DAO 或 ADO 从其他程序（如 VB6 和 .NET）中引用。
Microsoft SQL Server 的桌面版本可以与 Access 一起使用，作为 Jet 数据库引擎的替代方案。
Microsoft Access 是基于文件服务器的数据库。与客户端-服务器关系数据库管理系统 (RDBMS) 不同，Microsoft Access 不实现数据库触发器、存储过程或事务日志。

SQL – 语法

SQL 后面是一组独特的规则和指南，称为语法。本教程通过列出所有基本 SQL 语法，让您快速开始使用 SQL。

所有 SQL 语句都以任何关键字开头，例如 SELECT、INSERT、UPDATE、DELETE、ALTER、DROP、CREATE、USE、SHOW，并且所有语句都以分号 (;) 结尾。

这里需要注意的最重要的一点是 SQL 不区分大小写，这意味着 SELECT 和 select 在 SQL 语句中具有相同的含义。而 MySQL 在表名上有所不同。因此，如果您正在使用 MySQL，那么您需要给出数据库中存在的表名。

SQL 中的各种语法

本教程中给出的所有示例都已在 MySQL 服务器上进行了测试。

SQL SELECT 语句

SELECT column1, column2....columnN
FROM   table_name;

SQL DISTINCT 子句

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

SQL WHERE 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

SQL AND/OR 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

SQL IN 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

SQL BETWEEN 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

SQL LIKE 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

SQL ORDER BY 子句

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

SQL GROUP BY 子句

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

SQL 计数子句

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

SQL HAVING 子句

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQL CREATE TABLE 语句

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

SQL DROP TABLE 语句

DROP TABLE table_name;

SQL CREATE INDEX 语句

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

SQL DROP INDEX 语句

ALTER TABLE table_name
DROP INDEX index_name;

SQL DESC 语句

DESC table_name;

SQL TRUNCATE TABLE 语句

TRUNCATE TABLE table_name;

SQL ALTER TABLE 语句

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

SQL ALTER TABLE 语句（重命名）

ALTER TABLE table_name RENAME TO new_table_name;

SQL INSERT INTO 语句

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQL 更新语句

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

SQL DELETE 语句

DELETE FROM table_name
WHERE  {CONDITION};

SQL CREATE DATABASE 语句

CREATE DATABASE database_name;

SQL DROP DATABASE 语句

DROP DATABASE database_name;

SQL USE 语句

USE database_name;

SQL COMMIT 语句

COMMIT;

SQL ROLLBACK 语句

ROLLBACK;

SQL – 数据类型

SQL 数据类型是一个属性，用于指定任何对象的数据类型。每个列、变量和表达式在 SQL 中都有一个相关的数据类型。您可以在创建表时使用这些数据类型。您可以根据需要为表列选择数据类型。

SQL Server 提供六类数据类型供您使用，如下所列 –

精确数字数据类型

DATA TYPE	从	至
bigint	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
int	-2,147,483,648	2,147,483,647
smallint	-32,768	32,767
tinyint	0	255
bit	0	1
decimal	-10^38 +1	10^38 -1
numeric	-10^38 +1	10^38 -1
money	-922,337,203,685,477.5808	+922,337,203,685,477.5807
smallmoney	-214,748.3648	+214,748.3647

近似数值数据类型

DATA TYPE	从	至
float	-1.79E + 308	1.79E + 308
real	-3.40E + 38	3.40E + 38

日期和时间数据类型

DATA TYPE	从	至
datetime	1753 年 1 月 1 日	9999 年 12 月 31 日
smalldatetime	1900 年 1 月 1 日	2079 年 6 月 6 日
date	存储日期，如 1991 年 6 月 30 日
time	存储一天中的某个时间，例如下午 12:30

注意– 在这里，datetime 的精度为 3.33 毫秒，而 smalldatetime 的精度为 1 分钟。

字符串数据类型

Sr.No.	数据类型和描述
1	char 最大长度为 8,000 个字符。（固定长度的非 Unicode 字符）
2	varchar 最多 8,000 个字符。（可变长度的非 Unicode 数据）。
3	varchar(max) 最大长度为 2E + 31 个字符，可变长度非 Unicode 数据（仅限 SQL Server 2005）。
4	text 可变长度的非 Unicode 数据，最大长度为 2,147,483,647 个字符。

Unicode 字符串数据类型

Sr.No.	数据类型和描述
1	nchar 最大长度为 4,000 个字符。（固定长度 Unicode）
2	nvarchar 最大长度为 4,000 个字符。（可变长度 Unicode）
3	nvarchar(max) 最大长度为 2E + 31 个字符（仅限 SQL Server 2005）。（可变长度 Unicode）
4	ntext 最大长度为 1,073,741,823 个字符。( 可变长度 Unicode )

二进制数据类型

Sr.No.	数据类型和描述
1	binary 最大长度 8,000 字节（定长二进制数据）
2	varbinary 最大长度为 8,000 字节。（可变长度二进制数据）
3	varbinary(max) 最大长度为 2E + 31 字节（仅限 SQL Server 2005）。（变长二进制数据）
4	image 最大长度为 2,147,483,647 字节。（可变长度二进制数据）

杂项数据类型

Sr.No.	数据类型和描述
1	sql_variant 存储各种 SQL Server 支持的数据类型的值，文本、ntext 和时间戳除外。
2	timestamp 存储数据库范围的唯一编号，每次更新行时都会更新该编号
3	uniqueidentifier 存储全局唯一标识符 (GUID)
4	xml 存储 XML 数据。您可以将 xml 实例存储在列或变量中（仅限 SQL Server 2005）。
5	cursor 对游标对象的引用
6	table 存储结果集供以后处理

SQL – 运算符

SQL 中的运算符是什么？

运算符是保留字或字符，主要用于 SQL 语句的 WHERE 子句中以执行操作，例如比较和算术运算。这些运算符用于指定 SQL 语句中的条件，并用作语句中多个条件的连接词。

算术运算符
比较运算符
逻辑运算符
用于否定条件的运算符

SQL 算术运算符

假设“变量 a”为10，“变量 b”为20，那么 –

显示示例

Operator	描述	例子
+ (Addition)	在运算符的任一侧添加值。	a + b 将给 30
– (Subtraction)	从左手操作数中减去右手操作数。	a – b 将给出 -10
* (Multiplication)	将运算符两侧的值相乘。	a * b 将给出 200
/ (Division)	将左手操作数除以右手操作数。	b / a 会给 2
% (Modulus)	将左手操作数除以右手操作数并返回余数。	b % a 将给出 0

SQL 比较运算符

假设“变量 a”为10，“变量 b”为20，那么 –

显示示例

Operator	描述	例子
=	检查两个操作数的值是否相等，如果是，则条件为真。	(a = b) 不正确。
!=	检查两个操作数的值是否相等，如果值不相等则条件为真。	(a != b) 是真的。
<>	检查两个操作数的值是否相等，如果值不相等则条件为真。	(a <> b) 是真的。
>	检查左操作数的值是否大于右操作数的值，如果是，则条件为真。	(a > b) 不正确。
<	检查左操作数的值是否小于右操作数的值，如果是，则条件为真。	(a < b) 是真的。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件成立。	(a >= b) 不是真的。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件成立。	(a <= b) 是真的。
!<	检查左操作数的值是否不小于右操作数的值，如果是则条件成立。	(a !< b) 是假的。
!>	检查左操作数的值是否不大于右操作数的值，如果是，则条件为真。	(a !> b) 是真的。

SQL 逻辑运算符

这是 SQL 中可用的所有逻辑运算符的列表。

显示示例

Sr.No.	运算符和描述
1	ALL ALL 运算符用于将一个值与另一个值集中的所有值进行比较。
2	AND AND 运算符允许在 SQL 语句的 WHERE 子句中存在多个条件。
3	ANY ANY 运算符用于根据条件将值与列表中的任何适用值进行比较。
4	BETWEEN BETWEEN 运算符用于在给定最小值和最大值的情况下搜索一组值中的值。
5	EXISTS EXISTS 运算符用于搜索指定表中是否存在满足特定条件的行。
6	IN IN 运算符用于将值与已指定的文字值列表进行比较。
7	LIKE LIKE 运算符用于使用通配符运算符将值与相似值进行比较。
8	NOT NOT 运算符颠倒了与它一起使用的逻辑运算符的含义。例如：NOT EXISTS、NOT BETWEEN、NOT IN 等。这是一个否定运算符。
9	OR OR 运算符用于在 SQL 语句的 WHERE 子句中组合多个条件。
10	IS NULL NULL 运算符用于将值与 NULL 值进行比较。
11	UNIQUE UNIQUE 运算符搜索指定表的每一行的唯一性（无重复）。

SQL – 表达式

表达式是一个或多个值、运算符和计算结果的 SQL 函数的组合。这些 SQL EXPRESSION 就像公式一样，它们是用查询语言编写的。您还可以使用它们来查询数据库中的特定数据集。

句法

考虑 SELECT 语句的基本语法如下 –

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

有不同类型的 SQL 表达式，如下所述 –

布尔值
数字
日期

现在让我们详细讨论其中的每一个。

布尔表达式

SQL 布尔表达式基于匹配单个值来获取数据。以下是语法 –

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

考虑具有以下记录的 CUSTOMERS 表 –

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

下表是一个简单的例子，展示了各种 SQL 布尔表达式的用法 –

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

数值表达式

这些表达式用于在任何查询中执行任何数学运算。以下是语法 –

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

这里， numeric_expression 用于数学表达式或任何公式。以下是一个简单的例子，展示了 SQL 数字表达式的用法 –

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

有几个内置函数，如 avg()、sum()、count() 等，用于对表或特定表列执行所谓的聚合数据计算。

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

日期表达式

日期表达式返回当前系统日期和时间值 –

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

另一个日期表达式如下所示 –

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL – 创建数据库

SQL CREATE DATABASE语句用于创建新的 SQL 数据库。

句法

此 CREATE DATABASE 语句的基本语法如下 –

CREATE DATABASE DatabaseName;

在 RDBMS 中，数据库名称始终应该是唯一的。

例子

如果你想创建一个新的数据库 <testDB>，那么 CREATE DATABASE 语句将如下所示 –

SQL> CREATE DATABASE testDB;

在创建任何数据库之前，请确保您具有管理员权限。创建数据库后，您可以在数据库列表中检查它，如下所示 –

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL – 删除或删除数据库

SQL DROP DATABASE语句用于删除 SQL 模式中的现有数据库。

句法

DROP DATABASE 语句的基本语法如下 –

DROP DATABASE DatabaseName;

在 RDBMS 中，数据库名称始终应该是唯一的。

例子

如果要删除现有数据库 <testDB>，则 DROP DATABASE 语句如下所示 –

SQL> DROP DATABASE testDB;

注意– 在使用此操作之前要小心，因为删除现有数据库会导致数据库中存储的完整信息丢失。

在删除任何数据库之前，请确保您具有管理员权限。删除数据库后，您可以在数据库列表中检查它，如下所示 –

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

SQL – SELECT 数据库，USE 语句

如果 SQL Schema 中有多个数据库，那么在开始操作之前，您需要选择一个将执行所有操作的数据库。

SQL USE语句用于选择 SQL 模式中的任何现有数据库。

句法

USE 语句的基本语法如下所示 –

USE DatabaseName;

在 RDBMS 中，数据库名称始终应该是唯一的。

例子

您可以检查可用的数据库，如下所示 –

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

现在，如果您想使用 AMROOD 数据库，那么您可以执行以下 SQL 命令并开始使用 AMROOD 数据库。

SQL> USE AMROOD;

SQL – 创建表

创建基本表涉及命名表并定义其列和每列的数据类型。

SQL CREATE TABLE语句用于创建新表。

句法

CREATE TABLE 语句的基本语法如下 –

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE 是告诉数据库系统你想做什么的关键字。在这种情况下，您要创建一个新表。表的唯一名称或标识符遵循 CREATE TABLE 语句。

然后括号中是定义表中每一列的列表以及它是什么类型的数据类型。通过以下示例，语法变得更加清晰。

可以使用 CREATE TABLE 语句和 SELECT 语句的组合来创建现有表的副本。您可以在使用另一个表创建表中查看完整的详细信息。

例子

以下代码块是一个示例，它创建一个以 ID 作为主键的 CUSTOMERS 表，NOT NULL 是约束，表明在此表中创建记录时这些字段不能为 NULL –

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

您可以通过查看 SQL 服务器显示的消息来验证您的表是否已成功创建，否则您可以使用DESC命令如下 –

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

现在，您的数据库中有 CUSTOMERS 表，您可以使用它来存储与客户相关的所需信息。

SQL – 删除或删除表

SQL DROP TABLE语句用于删除表定义以及该表的所有数据、索引、触发器、约束和权限规范。

注意– 使用此命令时应该非常小心，因为一旦删除了一个表，那么该表中的所有可用信息也将永远丢失。

句法

此 DROP TABLE 语句的基本语法如下 –

DROP TABLE table_name;

例子

让我们首先验证 CUSTOMERS 表，然后我们将从数据库中删除它，如下所示 –

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

这意味着 CUSTOMERS 表在数据库中可用，所以现在让我们删除它，如下所示。

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

现在，如果您尝试使用 DESC 命令，则会出现以下错误 –

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

在这里，TEST 是我们在示例中使用的数据库名称。

SQL – 插入查询

SQL INSERT INTO语句用于向数据库中的表添加新的数据行。

句法

INSERT INTO 语句有两种基本语法，如下所示。

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

此处，column1、column2、column3、…columnN 是表中要插入数据的列的名称。

如果要为表的所有列添加值，则可能不需要在 SQL 查询中指定列名称。但请确保值的顺序与表中的列顺序相同。

在SQL INSERT INTO语法将如下-

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

例子

以下语句将在 CUSTOMERS 表中创建六个记录。

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

您可以使用第二种语法在 CUSTOMERS 表中创建记录，如下所示。

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

以上所有语句都会在 CUSTOMERS 表中生成以下记录，如下所示。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

使用另一张表填充一张表

您可以通过另一个表的 select 语句将数据填充到一个表中；假设另一个表有一组字段，这些字段是填充第一个表所必需的。

这是语法 –

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL – 选择查询

SQL SELECT语句用于从数据库表中获取数据，该表以结果表的形式返回该数据。这些结果表称为结果集。

句法

SELECT 语句的基本语法如下 –

SELECT column1, column2, columnN FROM table_name;

此处，column1、column2… 是要获取其值的表的字段。如果要获取字段中可用的所有字段，则可以使用以下语法。

SELECT * FROM table_name;

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码是一个示例，它将获取 CUSTOMERS 表中可用客户的 ID、姓名和薪水字段。

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

这将产生以下结果 –

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

如果要获取 CUSTOMERS 表的所有字段，则应使用以下查询。

SQL> SELECT * FROM CUSTOMERS;

这将产生如下所示的结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL – WHERE 子句

SQL WHERE子句用于在从单个表或通过连接多个表获取数据时指定条件。如果满足给定条件，则仅从表中返回特定值。您应该使用 WHERE 子句来过滤记录并仅获取必要的记录。

WHERE 子句不仅用于 SELECT 语句，还用于 UPDATE、DELETE 语句等，我们将在后续章节中进行检查。

句法

带有 WHERE 子句的 SELECT 语句的基本语法如下所示。

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

您可以使用比较或逻辑运算符（如 >、<、=、LIKE、NOT等）来指定条件。以下示例将使这个概念更加清晰。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码是一个示例，它将从 CUSTOMERS 表中获取 ID、姓名和薪水字段，其中薪水大于 2000 –

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

这将产生以下结果 –

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

以下查询是一个示例，它将从 CUSTOMERS 表中获取名为Hardik的客户的 ID、Name 和 Salary 字段。

在这里，重要的是要注意所有的字符串都应该放在单引号 (”) 内。而在上面的例子中，数值应该不带任何引号。

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

这将产生以下结果 –

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

SQL – AND 和 OR 连接运算符

SQL AND & OR运算符用于组合多个条件以缩小 SQL 语句中的数据范围。这两个运算符称为连接运算符。

这些运算符提供了一种在同一 SQL 语句中与不同运算符进行多次比较的方法。

AND 运算符

在与运营商允许多个条件在SQL语句中存在的WHERE子句。

句法

带有 WHERE 子句的 AND 运算符的基本语法如下 –

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

您可以使用 AND 运算符组合 N 个条件。对于 SQL 语句要执行的操作，无论是事务还是查询，由 AND 分隔的所有条件都必须为 TRUE。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是一个示例，它将从 CUSTOMERS 表中获取 ID、姓名和薪水字段，其中薪水大于 2000 且年龄小于 25 岁 –

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

这将产生以下结果 –

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

OR 运算符

OR 运算符用于在 SQL 语句的 WHERE 子句中组合多个条件。

句法

带有 WHERE 子句的 OR 运算符的基本语法如下 –

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

您可以使用 OR 运算符组合 N 个条件。对于 SQL 语句要执行的操作，无论是事务还是查询，由 OR 分隔的唯一条件之一必须为 TRUE。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码块有一个查询，它将从 CUSTOMERS 表中获取 ID、姓名和薪水字段，其中薪水大于 2000 或年龄小于 25 岁。

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

这将产生以下结果 –

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

SQL – 更新查询

SQL UPDATE Query 用于修改表中的现有记录。您可以在 UPDATE 查询中使用 WHERE 子句来更新所选行，否则所有行都会受到影响。

句法

带有 WHERE 子句的 UPDATE 查询的基本语法如下：

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

您可以使用 AND 或 OR 运算符组合 N 个条件。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下查询将更新表中 ID 号为 6 的客户的 ADDRESS。

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

现在，CUSTOMERS 表将有以下记录 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

如果要修改 CUSTOMERS 表中的所有 ADDRESS 和 SALARY 列值，则不需要使用 WHERE 子句，因为 UPDATE 查询就足够了，如以下代码块所示。

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

现在，CUSTOMERS 表将有以下记录 –

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL – 删除查询

SQL DELETE 查询用于从表中删除现有记录。

您可以在 DELETE 查询中使用 WHERE 子句来删除选定的行，否则所有记录都将被删除。

句法

带有 WHERE 子句的 DELETE 查询的基本语法如下：

DELETE FROM table_name
WHERE [condition];

您可以使用 AND 或 OR 运算符组合 N 个条件。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

下面的代码有一个查询，它将删除一个客户，其 ID 为 6。

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

现在，CUSTOMERS 表将具有以下记录。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

如果你想从 CUSTOMERS 表中删除所有记录，你不需要使用 WHERE 子句，DELETE 查询如下 –

SQL> DELETE FROM CUSTOMERS;

现在，CUSTOMERS 表将没有任何记录。

SQL – LIKE 子句

SQL LIKE子句用于使用通配符将值与相似值进行比较。有两个通配符与 LIKE 运算符结合使用。

百分号 (%)
下划线 (_)

百分号代表零、一个或多个字符。下划线代表单个数字或字符。这些符号可以组合使用。

句法

% 和 _ 的基本语法如下 –

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

您可以使用 AND 或 OR 运算符组合 N 个条件。这里，XXXX 可以是任何数字或字符串值。

例子

下表有几个示例，显示了 WHERE 部分具有不同的 LIKE 子句，其中包含 ‘%’ 和 ‘_’ 运算符 –

Sr.No.	声明和说明
1	WHERE SALARY LIKE ‘200%’ 查找任何以 200 开头的值。
2	WHERE SALARY LIKE ‘%200%’ 查找在任何位置具有 200 的任何值。
3	WHERE SALARY LIKE ‘_00%’ 查找在第二个和第三个位置具有 00 的任何值。
4	WHERE SALARY LIKE ‘2_%_%’ 查找任何以 2 开头且长度至少为 3 个字符的值。
5	WHERE SALARY LIKE ‘%2’ 查找任何以 2 结尾的值。
6	WHERE SALARY LIKE ‘_2%3’ 查找第二个位置为 2 并以 3 结尾的任何值。
7	WHERE SALARY LIKE ‘2___3’ 查找以 2 开头并以 3 结尾的五位数字中的任何值。

让我们举一个真实的例子，考虑具有如下记录的 CUSTOMERS 表。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是一个示例，它将显示 CUSTOMERS 表中的所有记录，其中 SALARY 以 200 开头。

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL – TOP、LIMIT 或 ROWNUM 子句

SQL TOP子句用于从表中获取 TOP N 条记录或 X% 的记录。

注意– 所有数据库都不支持 TOP 子句。例如 MySQL 支持LIMIT子句来获取有限数量的记录，而 Oracle 使用ROWNUM命令来获取有限数量的记录。

句法

带有 SELECT 语句的 TOP 子句的基本语法如下。

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下查询是 SQL 服务器上的一个示例，它将从 CUSTOMERS 表中获取前 3 条记录。

SQL> SELECT TOP 3 * FROM CUSTOMERS;

这将产生以下结果 –

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

如果您使用的是 MySQL 服务器，那么这里是一个等效的示例 –

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

这将产生以下结果 –

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

如果您使用的是 Oracle 服务器，则以下代码块具有等效示例。

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

这将产生以下结果 –

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL – ORDER BY 子句

SQL ORDER BY子句用于根据一列或多列按升序或降序对数据进行排序。某些数据库默认按升序对查询结果进行排序。

句法

ORDER BY 子句的基本语法如下 –

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

您可以在 ORDER BY 子句中使用多个列。确保您用来对该列进行排序的任何列都应该在列列表中。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码块有一个示例，它将按 NAME 和 SALARY 按升序对结果进行排序 –

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

下面的代码块有一个示例，它将按 NAME 按降序对结果进行排序。

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL – 分组依据

SQL GROUP BY子句与 SELECT 语句配合使用，以将相同的数据分组。此 GROUP BY 子句在 SELECT 语句中的 WHERE 子句之后，并在 ORDER BY 子句之前。

句法

GROUP BY 子句的基本语法显示在以下代码块中。GROUP BY 子句必须跟在 WHERE 子句中的条件之后，并且必须在 ORDER BY 子句之前（如果使用）。

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

例子

考虑 CUSTOMERS 表有以下记录 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

如果您想知道每个客户的工资总额，那么 GROUP BY 查询将如下所示。

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

这将产生以下结果 –

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

现在，让我们看一个表，其中 CUSTOMERS 表具有以下重复名称的记录 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

现在，如果您想知道每个客户的工资总额，那么 GROUP BY 查询将如下所示 –

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

这将产生以下结果 –

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL – 不同的关键字

SQL DISTINCT关键字与 SELECT 语句结合使用以消除所有重复记录并仅获取唯一记录。

可能会出现一个表中有多个重复记录的情况。在获取此类记录时，只获取那些唯一记录而不是获取重复记录更有意义。

句法

消除重复记录的 DISTINCT 关键字的基本语法如下 –

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

首先，让我们看看下面的 SELECT 查询如何返回重复的工资记录。

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

这将产生以下结果，其中薪水 (2000) 出现两次，这是原始表中的重复记录。

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

现在，让我们在上面的 SELECT 查询中使用 DISTINCT 关键字，然后查看结果。

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

这将产生以下结果，其中我们没有任何重复条目。

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL – 排序结果

SQL ORDER BY子句用于根据一列或多列按升序或降序对数据进行排序。某些数据库默认按升序对查询结果进行排序。

句法

用于按升序或降序对结果进行排序的 ORDER BY 子句的基本语法如下 –

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

您可以在 ORDER BY 子句中使用多个列。确保您使用的任何列进行排序，该列都应该在列列表中。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是一个示例，它将按 NAME 和 SALARY 按升序对结果进行排序。

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

下面的代码块有一个示例，它将按 NAME 按降序对结果进行排序。

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

要以自己的首选顺序获取行，使用的 SELECT 查询如下 –

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

这将首先按照您自己的偏好顺序按 ADDRESS 对客户进行排序，并按照其余地址的自然顺序对客户进行排序。此外，其余地址将按逆字母顺序排序。

SQL – 约束

约束是对表的数据列强制执行的规则。这些用于限制可以进入表的数据类型。这保证了数据库中数据的准确性和可靠性。

约束可以在列级别或表级别。列级约束仅应用于一列，而表级约束应用于整个表。

以下是 SQL 中可用的一些最常用的约束。这些约束已经在SQL – RDBMS 概念一章中讨论过，但此时有必要对它们进行修改。

NOT NULL Constraint – 确保列不能有 NULL 值。
DEFAULT Constraint – 当没有指定时，为列提供默认值。
UNIQUE Constraint – 确保列中的所有值都不同。
PRIMARY Key – 唯一标识数据库表中的每一行/记录。
FOREIGN Key – 唯一标识任何给定数据库表中的行/记录。
CHECK Constraint – CHECK 约束确保列中的所有值满足某些条件。
INDEX – 用于非常快速地从数据库创建和检索数据。

可以在使用 CREATE TABLE 语句创建表时指定约束，或者即使在创建表之后也可以使用 ALTER TABLE 语句创建约束。

删除约束

可以使用带有 DROP CONSTRAINT 选项的 ALTER TABLE 命令删除您定义的任何约束。

例如，要删除 EMPLOYEES 表中的主键约束，可以使用以下命令。

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

某些实现可能提供用于删除某些约束的快捷方式。例如，要删除 Oracle 中某个表的主键约束，可以使用以下命令。

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

某些实现允许您禁用约束。您可能希望暂时禁用约束，然后再启用它，而不是从数据库中永久删除约束。

完整性约束

完整性约束用于确保关系数据库中数据的准确性和一致性。数据完整性是通过参照完整性的概念在关系数据库中处理的。

有多种类型的完整性约束在参照完整性 (RI) 中起作用。这些约束包括主键、外键、唯一约束和上面提到的其他约束。

SQL – 使用连接

SQL Joins子句用于合并来自数据库中两个或多个表的记录。JOIN 是一种通过使用每个表的公共值来组合来自两个表的字段的方法。

考虑以下两个表 –

表 1 – 客户表

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

表 2 – 订单表

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

现在，让我们在 SELECT 语句中加入这两个表，如下所示。

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

这将产生以下结果。

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

在这里，值得注意的是连接是在 WHERE 子句中执行的。几种运算符可用于连接表，例如 =、<、>、<>、<=、>=、!=、BETWEEN、LIKE 和 NOT；它们都可以用来连接表。然而，最常见的运算符是等于符号。

SQL 中有不同类型的连接可用 –

INNER JOIN – 当两个表都匹配时返回行。
LEFT JOIN – 返回左表中的所有行，即使右表中没有匹配项。
RIGHT JOIN – 返回右表中的所有行，即使左表中没有匹配项。
FULL JOIN – 当其中一个表中有匹配项时返回行。
SELF JOIN – 用于将表连接到自身，就好像该表是两个表，临时重命名 SQL 语句中的至少一个表。
CARTESIAN JOIN – 返回来自两个或多个连接表的记录集的笛卡尔积。

现在让我们详细讨论这些连接中的每一个。

SQL – 联合条款

SQL UNION 子句/运算符用于组合两个或多个 SELECT 语句的结果而不返回任何重复的行。

要使用此 UNION 子句，每个 SELECT 语句必须具有

选择的列数相同
列数相同的表达式
相同的数据类型和
让它们按相同的顺序

但它们不必具有相同的长度。

句法

UNION子句的基本语法如下 –

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

在这里，给定的条件可以是基于您的要求的任何给定的表达式。

例子

考虑以下两个表。

表 1 – 客户表如下。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

表 2 – 订单表如下。

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

现在，让我们在 SELECT 语句中加入这两个表，如下所示 –

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

这将产生以下结果 –

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

UNION ALL 条款

UNION ALL 运算符用于组合包括重复行在内的两个 SELECT 语句的结果。

适用于 UNION 子句的相同规则将适用于 UNION ALL 运算符。

句法

UNION ALL的基本语法如下。

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

在这里，给定的条件可以是基于您的要求的任何给定的表达式。

例子

考虑以下两个表，

表 1 – 客户表如下。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

表 2 – ORDERS 表如下。

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

现在，让我们在 SELECT 语句中加入这两个表，如下所示 –

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

这将产生以下结果 –

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

还有另外两个子句（即运算符），它们类似于 UNION 子句。

SQL INTERSECT 子句– 这用于组合两个 SELECT 语句，但仅从第一个 SELECT 语句中返回与第二个 SELECT 语句中的行相同的行。
SQL EXCEPT Clause – 这结合了两个 SELECT 语句，并从第一个 SELECT 语句返回第二个 SELECT 语句未返回的行。

SQL – NULL 值

SQL NULL是用于表示缺失值的术语。表中的 NULL 值是字段中显示为空白的值。

具有 NULL 值的字段是没有值的字段。了解 NULL 值不同于零值或包含空格的字段非常重要。

句法

创建表时NULL的基本语法。

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

此处，NOT NULL表示该列应始终接受给定数据类型的显式值。有两列我们没有使用 NOT NULL，这意味着这些列可能是 NULL。

具有 NULL 值的字段是在记录创建期间留空的字段。

例子

选择数据时，NULL 值可能会导致问题。但是，因为在将未知值与任何其他值进行比较时，结果始终是未知的并且不包含在结果中。您必须使用IS NULL或IS NOT NULL运算符来检查 NULL 值。

考虑以下 CUSTOMERS 表具有如下所示的记录。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

现在，以下是IS NOT NULL运算符的用法。

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

现在，以下是IS NULL运算符的用法。

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

这将产生以下结果 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL – 别名语法

您可以通过提供另一个称为Alias 的名称来临时重命名表或列。表别名的用途是重命名特定 SQL 语句中的表。重命名是临时更改，数据库中的实际表名不会更改。列别名用于为特定 SQL 查询重命名表的列。

句法

表别名的基本语法如下。

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

列别名的基本语法如下。

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

例子

考虑以下两个表。

表 1 – 客户表如下。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

表 2 – 订单表如下。

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

现在，以下代码块显示了表别名的用法。

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

这将产生以下结果。

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

以下是列别名的用法。

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

这将产生以下结果。

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL – 索引

索引是数据库搜索引擎可以用来加速数据检索的特殊查找表。简单地说，索引是指向表中数据的指针。数据库中的索引与书后的索引非常相似。

例如，如果您想参考一本书中讨论某个主题的所有页面，您首先参考索引，该索引按字母顺序列出所有主题，然后参考一个或多个特定页码。

索引有助于加快SELECT查询和WHERE子句的速度，但它会减慢数据输入（使用UPDATE和INSERT语句）的速度。可以在不影响数据的情况下创建或删除索引。

创建索引涉及CREATE INDEX语句，该语句允许您命名索引、指定表和要索引的列，以及指示索引是按升序还是降序排列。

索引也可以是唯一的，就像UNIQUE约束一样，因为索引可以防止存在索引的列或列组合中的重复条目。

CREATE INDEX 命令

CREATE INDEX的基本语法如下。

CREATE INDEX index_name ON table_name;

单列索引

单列索引仅基于一个表列创建。基本语法如下。

CREATE INDEX index_name
ON table_name (column_name);

唯一索引

唯一索引不仅用于性能，还用于数据完整性。唯一索引不允许将任何重复值插入到表中。基本语法如下。

CREATE UNIQUE INDEX index_name
on table_name (column_name);

综合指数

复合索引是在表的两列或更多列上建立的索引。其基本语法如下。

CREATE INDEX index_name
on table_name (column1, column2);

无论是创建单列索引还是复合索引，都要考虑在查询的 WHERE 子句中可能经常使用的列作为过滤条件。

如果只使用一列，则应该选择单列索引。如果 WHERE 子句中经常使用两列或更多列作为过滤器，则复合索引将是最佳选择。

隐式索引

隐式索引是在创建对象时由数据库服务器自动创建的索引。索引是为主键约束和唯一约束自动创建的。

DROP INDEX 命令

可以使用 SQL DROP命令删除索引。删除索引时应该小心，因为性能可能会降低或提高。

基本语法如下 –

DROP INDEX index_name;

您可以查看INDEX 约束章节以查看有关索引的一些实际示例。

什么时候应该避免索引？

尽管索引旨在提高数据库的性能，但有时也应避免使用索引。

以下指南指示何时应重新考虑使用索引。

不应在小表上使用索引。
具有频繁、大批量更新或插入操作的表。
不应在包含大量 NULL 值的列上使用索引。
不应为频繁操作的列编制索引。

SQL – ALTER TABLE 命令

SQL ALTER TABLE命令用于添加、删除或修改现有表中的列。您还应该使用 ALTER TABLE 命令在现有表上添加和删除各种约束。

句法

在现有表中添加新列的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name ADD column_name datatype;

在现有表中删除列的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name DROP COLUMN column_name;

用于更改表中列的数据类型的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

向表中的列添加NOT NULL约束的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

ALTER TABLE 将UNIQUE CONSTRAINT 添加到表的基本语法如下。

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

向表添加检查约束的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

向表添加主键约束的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

从表中删除约束的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

如果您使用的是 MySQL，代码如下 –

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

从表中删除 PRIMARY KEY约束的 ALTER TABLE 命令的基本语法如下。

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

如果您使用的是 MySQL，代码如下 –

ALTER TABLE table_name 
DROP PRIMARY KEY;

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是向现有表添加新列的示例–

ALTER TABLE CUSTOMERS ADD SEX char(1);

现在，CUSTOMERS 表已更改，SELECT 语句将输出以下内容。

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

以下是从现有表中删除性别列的示例。

ALTER TABLE CUSTOMERS DROP SEX;

现在，CUSTOMERS 表已更改，以下将是 SELECT 语句的输出。

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

SQL – TRUNCATE TABLE 命令

SQL TRUNCATE TABLE命令用于从现有表中删除完整数据。

您也可以使用 DROP TABLE 命令删除完整的表，但它会从数据库中删除完整的表结构，如果您希望存储一些数据，则需要再次重新创建此表。

句法

TRUNCATE TABLE命令的基本语法如下。

TRUNCATE TABLE  table_name;

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是截断命令的示例。

SQL > TRUNCATE TABLE CUSTOMERS;

现在，CUSTOMERS 表被截断，SELECT 语句的输出将如下面的代码块所示 –

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL – 使用视图

视图只不过是存储在数据库中并具有关联名称的 SQL 语句。视图实际上是预定义 SQL 查询形式的表的组合。

视图可以包含表的所有行或从表中选择行。可以从一个或多个表创建视图，这取决于编写的 SQL 查询来创建视图。

视图是一种虚拟表，允许用户执行以下操作 –

以用户或用户类别认为自然或直观的方式构建数据。
以这样一种方式限制对数据的访问，即用户可以看到和（有时）修改他们需要的内容，而不再需要更多内容。
汇总可用于生成报告的各种表格中的数据。

创建视图

数据库视图是使用CREATE VIEW语句创建的。可以从单个表、多个表或另一个视图创建视图。

要创建视图，用户必须根据具体实现具有相应的系统权限。

基本的CREATE VIEW语法如下 –

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

您可以按照在普通 SQL SELECT 查询中使用它们的类似方式在 SELECT 语句中包含多个表。

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是从 CUSTOMERS 表创建视图的示例。此视图将用于从 CUSTOMERS 表中获取客户姓名和年龄。

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

现在，您可以使用与查询实际表类似的方式来查询 CUSTOMERS_VIEW。以下是相同的示例。

SQL > SELECT * FROM CUSTOMERS_VIEW;

这将产生以下结果。

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

带检查选项

WITH CHECK OPTION 是一个 CREATE VIEW 语句选项。WITH CHECK OPTION 的目的是确保所有 UPDATE 和 INSERT 满足视图定义中的条件。

如果它们不满足条件，则 UPDATE 或 INSERT 返回错误。

以下代码块有一个使用 WITH CHECK OPTION 创建相同视图 CUSTOMERS_VIEW 的示例。

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

在这种情况下，WITH CHECK OPTION 应该拒绝在视图的 AGE 列中输入任何 NULL 值，因为视图是由在 AGE 列中没有 NULL 值的数据定义的。

更新视图

可以在下面给出的某些条件下更新视图 –

SELECT 子句不能包含关键字 DISTINCT。
SELECT 子句可能不包含汇总函数。
SELECT 子句可能不包含集合函数。
SELECT 子句可能不包含集合运算符。
SELECT 子句不能包含 ORDER BY 子句。
FROM 子句不能包含多个表。
WHERE 子句不能包含子查询。
查询可能不包含 GROUP BY 或 HAVING。
可能不会更新计算列。
基表中的所有 NOT NULL 列都必须包含在视图中，以便 INSERT 查询起作用。

因此，如果视图满足上述所有规则，则可以更新该视图。下面的代码块有一个例子来更新 Ramesh 的年龄。

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

这将最终更新基表 CUSTOMERS 并且同样会反映在视图本身中。现在，尝试查询基表，SELECT 语句将产生以下结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

在视图中插入行

可以将数据行插入到视图中。适用于 UPDATE 命令的相同规则也适用于 INSERT 命令。

在这里，我们不能在 CUSTOMERS_VIEW 中插入行，因为我们没有在此视图中包含所有 NOT NULL 列，否则您可以在视图中插入行，就像在表中插入行一样。

将行删除到视图中

可以从视图中删除数据行。适用于 UPDATE 和 INSERT 命令的相同规则适用于 DELETE 命令。

以下是删除 AGE = 22 的记录的示例。

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

这最终会从基表 CUSTOMERS 中删除一行，并且同样会反映在视图本身中。现在，尝试查询基表，SELECT 语句将产生以下结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

删除视图

显然，在您拥有视图的地方，如果不再需要该视图，则需要一种方法来删除该视图。语法非常简单，如下所示 –

DROP VIEW view_name;

以下是从 CUSTOMERS 表中删除 CUSTOMERS_VIEW 的示例。

DROP VIEW CUSTOMERS_VIEW;

SQL – 有子句

在HAVING子句允许您指定滤波器组的结果出现在搜索结果的条件。

WHERE 子句在选定的列上放置条件，而 HAVING 子句在由 GROUP BY 子句创建的组上放置条件。

句法

以下代码块显示了 HAVING 子句在查询中的位置。

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

HAVING 子句必须跟在查询中的 GROUP BY 子句之后，并且如果使用，还必须在 ORDER BY 子句之前。以下代码块具有 SELECT 语句的语法，包括 HAVING 子句 –

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

例子

考虑具有以下记录的 CUSTOMERS 表。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是一个示例，它将显示大于或等于 2 的类似年龄计数的记录。

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

这将产生以下结果 –

+----+--------+-----+---------+---------+
| 身份证 | 姓名 | 年龄 | 地址 | 工资|
+----+--------+-----+---------+---------+
| 2 | 希兰 | 25 | 德里 | 1500.00 |
+----+--------+-----+---------+---------+

SQL – 事务

事务是针对数据库执行的工作单元。事务是按逻辑顺序完成的工作单元或序列，无论是由用户手动完成还是由某种数据库程序自动完成。

事务是对数据库的一个或多个更改的传播。例如，如果您正在创建记录或更新记录或从表中删除记录，则您正在对该表执行事务。控制这些事务以确保数据完整性和处理数据库错误非常重要。

实际上，您会将许多 SQL 查询组合到一个组中，并将作为事务的一部分一起执行所有这些查询。

交易属性

事务具有以下四个标准属性，通常由首字母缩写词ACID 表示。

原子性– 确保工作单元内的所有操作都成功完成。否则，事务将在故障点中止，并且所有先前的操作都将回滚到它们之前的状态。
一致性– 确保数据库在成功提交的事务后正确更改状态。
隔离– 使交易能够独立运行且彼此透明。
持久性– 确保在系统故障的情况下提交的事务的结果或影响仍然存在。

交易控制

以下命令用于控制事务。

COMMIT – 保存更改。
ROLLBACK – 回滚更改。
SAVEPOINT – 在要回滚的事务组中创建点。
SET TRANSACTION – 在交易上放置一个名称。

事务控制命令

事务控制命令仅与DML 命令一起使用，例如 – INSERT、UPDATE 和 DELETE。在创建表或删除表时不能使用它们，因为这些操作是在数据库中自动提交的。

提交命令

COMMIT 命令是用于将事务调用的更改保存到数据库的事务命令。

COMMIT 命令是用于将事务调用的更改保存到数据库的事务命令。COMMIT 命令将自上次 COMMIT 或 ROLLBACK 命令以来的所有事务保存到数据库中。

COMMIT 命令的语法如下。

COMMIT;

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

下面是一个示例，它将从表中删除那些年龄 = 25 的记录，然后提交数据库中的更改。

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

因此，表中的两行将被删除，SELECT 语句将产生以下结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

ROLLBACK 命令

ROLLBACK 命令是用于撤消尚未保存到数据库的事务的事务性命令。此命令只能用于撤消自上次发出 COMMIT 或 ROLLBACK 命令以来的事务。

ROLLBACK 命令的语法如下 –

ROLLBACK;

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下是一个示例，它将从表中删除那些年龄 = 25 的记录，然后回滚数据库中的更改。

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

因此，删除操作不会影响表，SELECT 语句会产生以下结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SAVEPOINT 命令

SAVEPOINT 是事务中的一个点，当您可以将事务回滚到某个点而不回滚整个事务时。

SAVEPOINT 命令的语法如下所示。

SAVEPOINT SAVEPOINT_NAME;

此命令仅用于在所有事务性语句中创建 SAVEPOINT。ROLLBACK 命令用于撤消一组事务。

回滚到 SAVEPOINT 的语法如下所示。

ROLLBACK TO SAVEPOINT_NAME;

以下是您计划从 CUSTOMERS 表中删除三个不同记录的示例。您希望在每次删除之前创建一个 SAVEPOINT，以便您可以随时回滚到任何 SAVEPOINT 以将适当的数据返回到其原始状态。

例子

考虑具有以下记录的 CUSTOMERS 表。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码块包含一系列操作。

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

既然三个删除已经发生，让我们假设您已经改变主意并决定回滚到您标识为 SP2 的 SAVEPOINT。因为 SP2 是在第一次删除后创建的，所以最后两次删除被撤消 –

SQL> ROLLBACK TO SP2;
Rollback complete.

请注意，自从您回滚到 SP2 后，只发生了第一次删除。

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

RELEASE SAVEPOINT 命令

RELEASE SAVEPOINT 命令用于删除您创建的 SAVEPOINT。

RELEASE SAVEPOINT 命令的语法如下。

RELEASE SAVEPOINT SAVEPOINT_NAME;

一旦 SAVEPOINT 被释放，您就不能再使用 ROLLBACK 命令来撤消自上次 SAVEPOINT 以来执行的事务。

SET TRANSACTION 命令

SET TRANSACTION 命令可用于启动数据库事务。此命令用于指定后续事务的特征。例如，您可以将事务指定为只读或读写。

SET TRANSACTION 命令的语法如下。

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL – 通配符运算符

我们已经讨论过 SQL LIKE 运算符，该运算符用于使用通配符运算符将值与相似值进行比较。

SQL 支持两个通配符与 LIKE 运算符结合使用，下表对其进行了详细说明。

Sr.No.	通配符和描述
1	The percent sign (%) 匹配一个或多个字符。注意– MS Access 使用星号 (*) 通配符而不是百分号 (%) 通配符。
2	The underscore (_) 匹配一个字符。注意– MS Access 使用问号 (?) 而不是下划线 (_) 来匹配任何一个字符。

Sr.No.

通配符和描述

The percent sign (%)

匹配一个或多个字符。

注意– MS Access 使用星号 (*) 通配符而不是百分号 (%) 通配符。

The underscore (_)

匹配一个字符。

注意– MS Access 使用问号 (?) 而不是下划线 (_) 来匹配任何一个字符。

百分号代表零、一个或多个字符。下划线代表单个数字或字符。这些符号可以组合使用。

句法

‘%’ 和 ‘_’ 运算符的基本语法如下。

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

您可以使用 AND 或 OR 运算符组合 N 个条件。这里，XXXX 可以是任何数字或字符串值。

例子

下表有许多示例显示 WHERE 部分具有不同的 LIKE 子句，其中包含“%”和“_”运算符。

Sr.No.	声明和说明
1	WHERE SALARY LIKE ‘200%’ 查找任何以 200 开头的值。
2	WHERE SALARY LIKE ‘%200%’ 查找在任何位置具有 200 的任何值。
3	WHERE SALARY LIKE ‘_00%’ 查找在第二个和第三个位置具有 00 的任何值。
4	WHERE SALARY LIKE ‘2_%_%’ 查找任何以 2 开头且长度至少为 3 个字符的值。
5	WHERE SALARY LIKE ‘%2’ 查找任何以 2 结尾的值。
6	WHERE SALARY LIKE ‘_2%3’ 查找第二个位置为 2 并以 3 结尾的任何值。
7	WHERE SALARY LIKE ‘2___3’ 查找以 2 开头并以 3 结尾的五位数字中的任何值。

让我们举一个真实的例子，考虑具有以下记录的 CUSTOMERS 表。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

以下代码块是一个示例，它将显示 CUSTOMERS 表中 SALARY 以 200 开头的所有记录。

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

这将产生以下结果。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL – 日期函数

下表列出了可通过 SQL 使用的所有重要的日期和时间相关函数。您的 RDBMS 还支持各种其他功能。给定的列表基于 MySQL RDBMS。

Sr.No.	功能说明
1	ADDDATE() 添加日期
2	ADDTIME() 添加时间
3	CONVERT_TZ() 从一个时区转换为另一个时区
4	CURDATE() 返回当前日期
5	CURRENT_DATE(), CURRENT_DATE CURDATE() 的同义词
6	CURRENT_TIME(), CURRENT_TIME CURTIME() 的同义词
7	CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP NOW() 的同义词
8	CURTIME() 返回当前时间
9	DATE_ADD() 添加两个日期
10	DATE_FORMAT() 按指定格式日期
11	DATE_SUB() 减去两个日期
12	DATE() 提取日期或日期时间表达式的日期部分
13	DATEDIFF() 减去两个日期
14	DAY() DAYOFMONTH() 的同义词
15	DAYNAME() 返回工作日的名称
16	DAYOFMONTH() 返回月份中的第几天 (1-31)
17	DAYOFWEEK() 返回参数的工作日索引
18	DAYOFYEAR() 返回一年中的第几天 (1-366)
19	EXTRACT 提取日期的一部分
20	FROM_DAYS() 将天数转换为日期
21	FROM_UNIXTIME() 将日期格式化为 UNIX 时间戳
22	HOUR() 提取小时
23	LAST_DAY 返回参数的月份的最后一天
24	LOCALTIME(), LOCALTIME NOW() 的同义词
25	LOCALTIMESTAMP, LOCALTIMESTAMP() NOW() 的同义词
26	MAKEDATE() 从年份和年份中的某一天创建一个日期
27	MAKETIME 找时间（）
28	MICROSECOND() 从参数返回微秒
29	MINUTE() 从参数返回分钟
30	MONTH() 返回从过去的日期开始的月份
31	MONTHNAME() 返回月份的名称
32	NOW() 返回当前日期和时间
33	PERIOD_ADD() 将期间添加到年月
34	PERIOD_DIFF() 返回期间之间的月数
35	QUARTER() 从日期参数返回季度
36	SEC_TO_TIME() 将秒转换为“HH:MM:SS”格式
37	SECOND() 返回第二个 (0-59)
38	STR_TO_DATE() 将字符串转换为日期
39	SUBDATE() 当使用三个参数调用时，DATE_SUB() 的同义词
40	SUBTIME() 减去时间
41	SYSDATE() 返回函数执行的时间
42	TIME_FORMAT() 格式为时间
43	TIME_TO_SEC() 返回转换为秒的参数
44	TIME() 提取传递的表达式的时间部分
45	TIMEDIFF() 减去时间
46	TIMESTAMP() 此函数使用单个参数返回日期或日期时间表达式。有两个参数，参数的总和
47	TIMESTAMPADD() 向日期时间表达式添加一个间隔
48	TIMESTAMPDIFF() 从日期时间表达式中减去一个间隔
49	TO_DAYS() 返回转换为天的日期参数
50	UNIX_TIMESTAMP() 返回 UNIX 时间戳
51	UTC_DATE() 返回当前 UTC 日期
52	UTC_TIME() 返回当前 UTC 时间
53	UTC_TIMESTAMP() 返回当前 UTC 日期和时间
54	WEEK() 返回周数
55	WEEKDAY() 返回工作日索引
56	WEEKOFYEAR() 返回日期的日历周 (1-53)
57	YEAR() 返回年份
58	YEARWEEK() 返回年和周

添加日期（日期，间隔表达式单位），添加日期（表达式，天数）

当使用第二个参数的 INTERVAL 形式调用时，ADDDATE() 是 DATE_ADD() 的同义词。相关函数 SUBDATE() 是 DATE_SUB() 的同义词。有关 INTERVAL 单元参数的信息，请参阅 DATE_ADD() 的讨论。

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

当使用第二个参数的 days 形式调用时，MySQL 将其视为要添加到 expr 的整数天数。

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

添加时间（expr1，expr2）

ADDTIME() 将 expr2 添加到 expr1 并返回结果。expr1 是时间或日期时间表达式，而 expr2 是时间表达式。

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ(dt,from_tz,to_tz)

这会将日期时间值 dt 从 from_tz 给定的时区转换为 to_tz 给定的时区，并返回结果值。如果参数无效，此函数将返回 NULL。

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE()

将当前日期作为 ‘YYYY-MM-DD’ 或 YYYYMMDD 格式的值返回，具体取决于函数是在字符串中还是在数字上下文中使用。

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE 和 CURRENT_DATE()

CURRENT_DATE 和 CURRENT_DATE() 是 CURDATE() 的同义词

时间（）

返回当前时间作为 ‘HH:MM:SS’ 或 HHMMSS 格式的值，具体取决于函数是在字符串中还是在数字上下文中使用。该值以当前时区表示。

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME 和 CURRENT_TIME()

CURRENT_TIME 和 CURRENT_TIME() 是 CURTIME() 的同义词。

CURRENT_TIMESTAMP 和 CURRENT_TIMESTAMP()

CURRENT_TIMESTAMP 和 CURRENT_TIMESTAMP() 是 NOW() 的同义词。

日期(expr)

提取日期或日期时间表达式 expr 的日期部分。

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF(expr1,expr2)

DATEDIFF() 返回 expr1 。expr2 表示为从一个日期到另一个日期的天数。expr1 和 expr2 都是日期或日期和时间表达式。计算中仅使用值的日期部分。

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD（日期，INTERVAL expr 单位），DATE_SUB（日期，INTERVAL expr 单位）

这些函数执行日期算术。该日期是一个DATETIME或DATE值，指定开始日期。的EXPR是指定要被添加或从起始日期中减去的时间间隔值的表达式。expr 是一个字符串；对于负间隔，它可能以“-”开头。

甲单元是指示在其中表达应被解释为单位的关键字。

该INTERVAL关键字和指定符是不区分大小写的单元。

下表显示了每个单位值的 expr 参数的预期形式。

unit Value	预期的 exprFormat
MICROSECOND	微秒
SECOND	秒
MINUTE	分钟
HOUR	小时
DAY	天
WEEK	周
MONTH	月
QUARTER	季度
YEAR	年
SECOND_MICROSECOND	‘秒.微秒’
MINUTE_MICROSECOND	‘分钟.微秒’
MINUTE_SECOND	‘分钟：秒’
HOUR_MICROSECOND	‘小时.微秒’
HOUR_SECOND	‘小时：分钟：秒’
HOUR_MINUTE	‘小时：分钟’
DAY_MICROSECOND	‘天.微秒’
DAY_SECOND	‘天小时：分钟：秒’
DAY_MINUTE	‘天小时：分钟’
DAY_HOUR	‘天数’
YEAR_MONTH	‘年-月’

值QUARTER和WEEK可从 MySQL 5.0.0 获得。版本。

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT（日期，格式）

此命令根据格式字符串格式化日期值。

可以在格式字符串中使用以下说明符。‘%’ 字符需要在格式说明符字符之前。

Sr.No.	说明符和说明
1	%a 缩写的工作日名称（Sun..Sat）
2	%b 缩写的月份名称（Jan..Dec）
3	%c 月份，数字 (0..12)
4	%D 带英文后缀的月份中的第几天（0th、1st、2nd、3rd、.）
5	%d 月份中的第几天，数字 (00..31)
6	%e 月份中的第几天，数字 (0..31)
7	%f 微秒 (000000..999999)
8	%H 小时 (00..23)
9	%h 小时 (01..12)
10	%I 小时 (01..12)
11	%i 分钟，数字 (00..59)
12	%j 一年中的第几天 (001..366)
13	%k 小时 (0..23)
14	%l 小时 (1..12)
15	%M 月份名称（一月..十二月）
16	%m 月份，数字 (00..12)
17	%p 上午或下午
18	%r 时间，12 小时制（hh:mm:ss 后跟 AM 或 PM）
19	%S 秒 (00..59)
20	%s 秒 (00..59)
21	%T 时间，24 小时制（时:分:秒）
22	%U 周 (00..53)，其中星期日是一周的第一天
23	%u 周 (00..53)，其中星期一是一周的第一天
24	%V 周 (01..53)，其中星期日是一周的第一天；与 %X 一起使用
25	%v 周 (01..53)，其中星期一是一周的第一天；与 %x 一起使用
26	%W 工作日名称（星期日..星期六）
27	%w 星期几（0=星期日..6=星期六）
28	%X 周的年份，其中星期日是一周的第一天，数字，四位数字；与 %V 一起使用
29	%x 一周的年份，其中星期一是一周的第一天，数字，四位数字；与 %v 一起使用
30	%Y 年份，数字，四位数字
31	%y 年份，数字（两位数）
32	%% 文字 .%。特点
33	%x x，对于任何.x。上面没有列出

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB（日期，INTERVAL expr 单位）

这类似于 DATE_ADD() 函数。

DAY（日期）

DAY() 是 DAYOFMONTH() 函数的同义词。

DAYNAME（日期）

返回日期的工作日名称。

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH（日期）

返回日期的月份中的第几天，范围为 0 到 31。

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK（日期）

返回日期的工作日索引（1 = 星期日，2 = 星期一，.，7 = 星期六）。这些索引值对应于 ODBC 标准。

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR（日期）

为日期返回一年中的第几天，范围为 1 到 366。

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

提取（单位从日期）

EXTRACT() 函数使用与 DATE_ADD() 或 DATE_SUB() 相同类型的单位说明符，但从日期中提取部分而不是执行日期算术。

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS(N)

给定一个天数 N，返回一个 DATE 值。

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

注意– 在旧日期上谨慎使用 FROM_DAYS()。它不适用于公历 (1582) 出现之前的值。

FROM_UNIXTIME(unix_timestamp)

FROM_UNIXTIME（unix_timestamp，格式）

以 ‘YYYY-MM-DD HH:MM:SS 或 YYYYMMDDHHMMSS 格式的值返回unix_timestamp参数的表示形式，具体取决于函数是在字符串中还是在数字上下文中使用。该值以当前时区表示。unix_timestamp 参数是一个内部时间戳值，由UNIX_TIMESTAMP()函数生成。

如果给出了格式，则结果将根据格式字符串进行格式化，其使用方式与DATE_FORMAT()函数的条目中列出的方式相同。

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

小时（时间）

返回时间的小时。对于时间值，返回值的范围是 0 到 23。但是，TIME 值的范围实际上要大得多，因此 HOUR 可以返回大于 23 的值。

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY（日期）

获取日期或日期时间值并返回该月最后一天的相应值。如果参数无效，则返回 NULL。

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME 和 LOCALTIME()

LOCALTIME 和 LOCALTIME() 是 NOW() 的同义词。

LOCALTIMESTAMP 和 LOCALTIMESTAMP()

LOCALTIMESTAMP 和 LOCALTIMESTAMP() 是 NOW() 的同义词。

MAKEDATE（年，年日）

返回日期，给定年份和年份值。dayofyear 值必须大于 0，否则结果将为 NULL。

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME（小时，分钟，秒）

返回根据小时、分钟和秒参数计算的时间值。

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

微秒(expr)

将时间或日期时间表达式 (expr) 中的微秒作为 0 到 999999 范围内的数字返回。

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

分钟（时间）

返回时间的分钟，范围为 0 到 59。

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTH（日期）

返回日期的月份，范围为 0 到 12。

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME(日期)

返回日期的月份全名。

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

现在（）

返回当前日期和时间作为 ‘YYYY-MM-DD HH:MM:SS’ 或 YYYYMMDDHHMMSS 格式的值，具体取决于函数是在字符串还是数字上下文中使用。该值以当前时区表示。

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD(P,N)

将 N 个月添加到周期 P（格式为 YYMM 或 YYYYMM）。返回格式为 YYYYMM 的值。请注意，期间参数 P 不是日期值。

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF(P1,P2)

返回期间 P1 和 P2 之间的月数。这些周期 P1 和 P2 的格式应为 YYMM 或 YYYYMM。请注意，期间参数 P1 和 P2 不是日期值。

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

季度（日期）

返回日期的一年中的季度，范围为 1 到 4。

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

第二次）

返回时间的秒数，范围为 0 到 59。

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME（秒）

返回秒参数，转换为小时、分钟和秒，作为 ‘HH:MM:SS’ 或 HHMMSS 格式的值，取决于函数是在字符串还是数字上下文中使用。

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE（字符串，格式）

这是 DATE_FORMAT() 函数的反函数。它需要一个字符串 str 和一个格式字符串格式。如果格式字符串同时包含日期和时间部分，则 STR_TO_DATE() 函数将返回 DATETIME 值。否则，如果字符串仅包含日期或时间部分，则它返回 DATE 或 TIME 值。

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE(date,INTERVAL expr unit) and SUBDATE(expr,days)

当使用第二个参数的 INTERVAL 形式调用时，SUBDATE() 是 DATE_SUB() 的同义词。有关 INTERVAL 单元参数的信息，请参阅 DATE_ADD() 的讨论。

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

子时间（expr1，expr2）

SUBTIME() 函数返回 expr1 。expr2 表示为与 expr1 格式相同的值。expr1 值是时间或日期时间表达式，而 expr2 值是时间表达式。

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

系统日期()

返回当前日期和时间作为 ‘YYYY-MM-DD HH:MM:SS’ 或 YYYYMMDDHHMMSS 格式的值，具体取决于函数是在字符串中还是在数字上下文中使用。

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

时间(expr)

提取时间或日期时间表达式expr的时间部分并将其作为字符串返回。

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF(expr1,expr2)

TIMEDIFF() 函数返回 expr1 。expr2 表示为时间值。这些 expr1 和 expr2 值是时间或日期和时间表达式，但两者的类型必须相同。

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

时间戳(expr), 时间戳(expr1,expr2)

使用单个参数，此函数将日期或日期时间表达式 expr 作为日期时间值返回。使用两个参数，它将时间表达式 expr2 添加到日期或日期时间表达式expr1并将结果作为日期时间值返回。

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD（单位，间隔，datetime_expr）

此函数将整数表达式间隔添加到日期或日期时间表达式datetime_expr。间隔的单位由 unit 参数给出，它应该是以下值之一 –

FRAC_SECOND
第二，分钟
小时，天
星期
月
季度或
年

可以使用所示的关键字之一或带有 SQL_TSI_ 前缀来指定单位值。

例如，DAY 和 SQL_TSI_DAY 都是合法的。

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)

返回日期或日期时间表达式 datetime_expr1 和 datetime_expr2 之间的整数差。结果的单位由 unit 参数给出。单位的合法值与 TIMESTAMPADD() 函数说明中列出的值相同。

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT（时间，格式）

此函数的使用方式与 DATE_FORMAT() 函数类似，但格式字符串可能仅包含小时、分钟和秒的格式说明符。

如果时间值包含大于 23 的小时部分，则 % H和 % k小时格式说明符生成的值大于通常的 0 到 23 范围。其他小时格式说明符生成小时值模 12。

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC（时间）

返回转换为秒的时间参数。

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

今天的日期）

给定一个日期，返回一个天数（自 0 年以来的天数）。

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP(), UNIX_TIMESTAMP(日期)

如果不带参数调用，此函数返回一个 Unix 时间戳（自 ‘1970-01-01 00:00:00’ UTC 以来的秒数）作为无符号整数。如果使用日期参数调用 UNIX_TIMESTAMP()，它会返回参数值作为自 ‘1970-01-01 00:00:00’ UTC 以来的秒数。date 可以是 DATE 字符串、DATETIME 字符串、TIMESTAMP 或格式为 YYMMDD 或 YYYYMMDD 的数字。

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE()

返回当前 UTC 日期作为 ‘YYYY-MM-DD’ 或 YYYYMMDD 格式的值，具体取决于函数是在字符串还是数字上下文中使用。

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME()

返回当前 UTC 时间作为 ‘HH:MM:SS’ 或 HHMMSS 格式的值，具体取决于函数是在字符串还是数字上下文中使用。

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP()

以“YYYY-MM-DD HH:MM:SS”或YYYYMMDDHHMMSS 格式的值返回当前UTC 日期和时间，具体取决于函数是在字符串中还是在数字上下文中使用。

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

周（日期[，模式]）

此函数返回日期的周数。WEEK() 的两个参数形式允许您指定一周是从星期日还是星期一开始，以及返回值应该在 0 到 53 或 1 到 53 的范围内。如果省略了 mode 参数，使用 default_week_format 系统变量的值

Mode	一周的第一天	范围	第 1 周是第一周。
0	星期日	0-53	今年有一个星期天
1	周一	0-53	今年有超过 3 天
2	星期日	1-53	今年有一个星期天
3	周一	1-53	今年有超过 3 天
4	星期日	0-53	今年有超过 3 天
5	周一	0-53	今年有一个星期一
6	星期日	1-53	今年有超过 3 天
7	周一	1-53	今年有一个星期一

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

工作日（日期）

返回日期的工作日索引（0 = 星期一，1 = 星期二，. 6 = 星期日）。

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR（日期）

将日期的日历周作为 1 到 53 范围内的数字返回。WEEKOFYEAR() 是与 WEEK(date,3) 等效的兼容函数。

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

年（日期）

返回日期的年份，范围为 1000 到 9999，或 0 为 .zero。日期。

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK（日期），YEARWEEK（日期，模式）

返回日期的年和周。mode 参数的工作方式与 WEEK() 函数的 mode 参数完全一样。结果中的年份可能与年份的第一周和最后一周的日期参数中的年份不同。

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

注意– 周数与 WEEK() 函数为可选参数 0 或 1 返回 (0) 的数不同，因为 WEEK() 然后返回给定年份上下文中的周数。

SQL – 临时表

什么是临时表？

有 RDBMS，它支持临时表。临时表是一项很棒的功能，它允许您使用与典型 SQL Server 表相同的选择、更新和联接功能来存储和处理中间结果。

在某些情况下，临时表对于保存临时数据可能非常有用。对于临时表应该知道的最重要的事情是当当前客户端会话终止时它们将被删除。

临时表在 MySQL 3.23 版本以后可用。如果您使用的 MySQL 版本低于 3.23，则不能使用临时表，但可以使用堆表。

如前所述，临时表只会在会话处于活动状态时持续存在。如果您在 PHP 脚本中运行代码，则在脚本执行完毕后，临时表将自动销毁。如果您通过MySQL客户端程序连接到MySQL数据库服务器，那么临时表将一直存在，直到您关闭客户端或手动销毁该表。

例子

这是一个示例，向您展示了临时表的用法。

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

当您发出 SHOW TABLES 命令时，您的临时表将不会在列表中列出。现在，如果您退出 MySQL 会话，然后发出 SELECT 命令，您将发现数据库中没有可用数据。甚至您的临时表也不存在。

删除临时表

默认情况下，当您的数据库连接终止时，MySQL 会删除所有临时表。尽管如此，如果您想在两者之间删除它们，那么您可以通过发出DROP TABLE命令来实现。

以下是删除临时表的示例。

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL – 克隆表

可能存在一种情况，当您需要表的精确副本而 CREATE TABLE … 或 SELECT… 命令不适合您的目的时，因为副本必须包含相同的索引、默认值等。

如果您使用的是 MySQL RDBMS，则可以通过遵循以下步骤来处理这种情况 –

使用 SHOW CREATE TABLE 命令获取指定源表的结构、索引和所有内容的 CREATE TABLE 语句。
修改语句，将表名更改为克隆表的表名并执行该语句。这样，您将拥有一个精确的克隆表。
或者，如果您还需要复制表内容，也可以发出 INSERT INTO 或 SELECT 语句。

例子

尝试以下示例为TUTORIALS_TBL创建一个克隆表，其结构如下 –

步骤 1 – 获取有关表格的完整结构。

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

步骤 2 – 重命名此表并创建另一个表。

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

第 3 步– 执行第 2步后，您将在数据库中克隆一个表。如果要从旧表复制数据，则可以使用 INSERT INTO… SELECT 语句来完成。

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

最后，您将拥有您想要的精确克隆表。

SQL – 子查询

子查询或内部查询或嵌套查询是另一个 SQL 查询中的查询并嵌入在 WHERE 子句中。

子查询用于返回将在主查询中用作条件的数据，以进一步限制要检索的数据。

子查询可以与 SELECT、INSERT、UPDATE 和 DELETE 语句以及 =、<、>、>=、<=、IN、BETWEEN 等运算符一起使用。

子查询必须遵循一些规则 –

子查询必须括在括号内。
一个子查询在 SELECT 子句中只能有一个列，除非子查询的主查询中有多个列以比较其选定的列。
尽管主查询可以使用 ORDER BY，但不能在子查询中使用 ORDER BY 命令。GROUP BY 命令可用于执行与子查询中的 ORDER BY 相同的功能。
返回多行的子查询只能与多个值运算符（例如 IN 运算符）一起使用。
SELECT 列表不能包含对评估为 BLOB、ARRAY、CLOB 或 NCLOB 的值的任何引用。
子查询不能立即包含在集合函数中。
BETWEEN 运算符不能与子查询一起使用。但是，可以在子查询中使用 BETWEEN 运算符。

带有 SELECT 语句的子查询

子查询最常与 SELECT 语句一起使用。基本语法如下 –

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

例子

考虑具有以下记录的 CUSTOMERS 表 –

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

现在，让我们使用 SELECT 语句检查以下子查询。

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

这将产生以下结果。

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

带有 INSERT 语句的子查询

子查询也可以与 INSERT 语句一起使用。INSERT 语句使用从子查询返回的数据插入到另一个表中。子查询中选定的数据可以使用任何字符、日期或数字函数进行修改。

基本语法如下。

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

例子

考虑一个与 CUSTOMERS 表结构相似的表 CUSTOMERS_BKP。现在要将完整的 CUSTOMERS 表复制到 CUSTOMERS_BKP 表中，您可以使用以下语法。

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

带有 UPDATE 语句的子查询

子查询可以与 UPDATE 语句结合使用。使用带有 UPDATE 语句的子查询时，可以更新表中的单列或多列。

基本语法如下。

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

例子

假设我们有 CUSTOMERS_BKP 表可用，它是 CUSTOMERS 表的备份。以下示例将 CUSTOMERS 表中所有 AGE 大于或等于 27 的客户的 SALARY 更新 0.25 倍。

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

这将影响两行，最终 CUSTOMERS 表将具有以下记录。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

带有 DELETE 语句的子查询

子查询可以与 DELETE 语句结合使用，就像上面提到的任何其他语句一样。

基本语法如下。

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

例子

假设我们有一个 CUSTOMERS_BKP 表可用，它是 CUSTOMERS 表的备份。以下示例从 CUSTOMERS 表中删除所有 AGE 大于或等于 27 的客户的记录。

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

这将影响两行，最终 CUSTOMERS 表将具有以下记录。

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL – 使用序列

序列是一组按需要按顺序生成的整数 1, 2, 3, …。序列在数据库中经常使用，因为许多应用程序要求表中的每一行都包含一个唯一值，而序列提供了一种简单的方法来生成它们。

本章介绍如何在 MySQL 中使用序列。

使用 AUTO_INCREMENT 列

在 MySQL 中使用序列的最简单方法是将列定义为 AUTO_INCREMENT 并将其余部分留给 MySQL 处理。

例子

试试下面的例子。这将创建一个表，然后它将在该表中插入几行，其中不需要提供记录 ID，因为它由 MySQL 自动递增。

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

获取 AUTO_INCREMENT 值

LAST_INSERT_ID( ) 是一个 SQL 函数，因此您可以在任何了解如何发出 SQL 语句的客户端中使用它。否则 PERL 和 PHP 脚本提供专有函数来检索最后一条记录的自动递增值。

PERL 示例

使用mysql_insertid属性获取查询生成的 AUTO_INCREMENT 值。此属性可通过数据库句柄或语句句柄访问，具体取决于您发出查询的方式。以下示例通过数据库句柄引用它。

$dbh->do ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')");
my $seq = $dbh->{mysql_insertid};

PHP 示例

发出生成 AUTO_INCREMENT 值的查询后，通过调用mysql_insert_id()函数检索该值。

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

重新编号现有序列

可能会出现这样的情况：您已从表中删除了许多记录，并且您想对所有记录重新排序。这可以通过使用一个简单的技巧来完成，但是您应该非常小心地执行此操作并检查您的表是否与另一个表有连接。

如果您确定对 AUTO_INCREMENT 列重新排序是不可避免的，那么这样做的方法是从表中删除该列，然后再次添加它。

以下示例显示如何使用此技术对昆虫表中的 id 值重新编号。

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

以特定值启动序列

默认情况下，MySQL 将从 1 开始序列，但您也可以在创建表时指定任何其他数字。

以下代码块有一个示例，其中 MySQL 将从 100 开始序列。

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

或者，您可以创建表，然后使用 ALTER TABLE 设置初始序列值。

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL – 处理重复项

可能会出现一个表中有多个重复记录的情况。在获取此类记录时，只获取唯一记录而不是获取重复记录更有意义。

我们已经讨论过的 SQL DISTINCT关键字与 SELECT 语句结合使用以消除所有重复记录并仅获取唯一记录。

句法

用于消除重复记录的 DISTINCT 关键字的基本语法如下。

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

例子

考虑具有以下记录的 CUSTOMERS 表。

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

首先，让我们看看以下 SELECT 查询如何返回重复的工资记录。

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

这将产生以下结果，其中 2000 的工资出现两次，这是原始表中的重复记录。

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

现在，让我们在上面的 SELECT 查询中使用 DISTINCT 关键字并查看结果。

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

这将产生以下结果，其中我们没有任何重复条目。

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL – 注入

如果您通过网页获取用户输入并将其插入到 SQL 数据库中，则您可能会对称为SQL 注入的安全问题敞开心扉。本章将教您如何帮助防止这种情况发生，并帮助您保护服务器端脚本（如 PERL 脚本）中的脚本和 SQL 语句。

注入通常发生在您向用户询问输入时，例如他们的姓名，而不是姓名，他们给您一条 SQL 语句，您将在不知不觉中在数据库上运行该语句。永远不要相信用户提供的数据，只有在验证后才处理这些数据；通常，这是通过模式匹配完成的。

在下面的示例中，名称被限制为字母数字字符加下划线和 8 到 20 个字符之间的长度（根据需要修改这些规则）。

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) {
   $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

为了演示这个问题，请考虑以下摘录 –

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

该函数调用应该从 CUSTOMERS 表中检索一条记录，其中名称列与用户指定的名称相匹配。在正常情况下，$name将只包含字母数字字符和空格，例如字符串 ilia。但是在这里，通过向 $name 附加一个全新的查询，对数据库的调用变成了灾难；注入的 DELETE 查询从 CUSTOMERS 表中删除所有记录。

幸运的是，如果您使用 MySQL，mysql_query()函数不允许查询堆叠或在单个函数调用中执行多个 SQL 查询。如果您尝试堆叠查询，调用将失败。

但是，其他 PHP 数据库扩展，例如SQLite和PostgreSQL，可以愉快地执行堆叠查询，执行一个字符串中提供的所有查询并造成严重的安全问题。

防止 SQL 注入

您可以在 PERL 和 PHP 等脚本语言中巧妙地处理所有转义字符。PHP 的 MySQL 扩展提供了函数mysql_real_escape_string()来转义 MySQL 特有的输入字符。

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name);
}
$name = mysql_real_escape_string($name);
mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

LIKE 窘境

为了解决 LIKE 困境，自定义转义机制必须将用户提供的 ‘%’ 和 ‘_’ 字符转换为文字。使用addcslashes()，该函数可让您指定要转义的字符范围。

$sub = addcslashes(mysql_real_escape_string("%str"), "%_");
// $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL – 数据库调优

成为数据库专家或专家数据库管理员需要时间。这一切都源于在各种数据库设计方面的丰富经验和良好的培训。

但以下列表可能有助于初学者获得良好的数据库性能 –

使用本教程中 RDBMS 概念章节中解释的 3BNF 数据库设计。
避免数字到字符的转换，因为数字和字符的比较方式不同，会导致性能下降。
使用 SELECT 语句时，只获取所需的任何信息，避免在 SELECT 查询中使用 *，因为它会不必要地加载系统。
在您经常进行搜索操作的所有表上仔细创建索引。避免在搜索操作较少而插入和更新操作较多的表上建立索引。
当 WHERE 子句中的列没有与之关联的索引时，就会发生全表扫描。您可以通过在用作 SQL 语句的 WHERE 子句中的条件的列上创建索引来避免全表扫描。
对具有实数和日期/时间值的等式运算符要非常小心。这两者都可能有肉眼不明显的细微差异，但无法完全匹配，从而阻止您的查询返回行。
明智地使用模式匹配。LIKE COL% 是有效的 WHERE 条件，将返回的集合减少到仅那些数据以字符串 COL 开头的记录。但是，COL%Y 不会进一步减少返回的结果集，因为无法有效评估 %Y。进行评估的工作量太大，无法考虑。在这种情况下，使用了 COL%，但丢弃了 %Y。出于同样的原因，前导通配符 %COL 可以有效地防止使用整个过滤器。
微调您的 SQL 查询，检查查询（和子查询）的结构、SQL 语法，以发现您的表是否设计为支持快速数据操作并以最佳方式编写查询，从而使您的 DBMS 能够有效地操作数据.
对于定期执行的查询，请尝试使用过程。过程是一组潜在的大型 SQL 语句。过程由数据库引擎编译然后执行。与 SQL 语句不同，数据库引擎在执行过程之前不需要对其进行优化。
如果可能，请避免在查询中使用逻辑运算符 OR。OR 不可避免地会减慢几乎所有针对大表的查询速度。
您可以通过删除索引来优化批量数据加载。想象一下有数千行的历史表。那个历史表也可能有一个或多个索引。当您想到索引时，您通常会想到更快的表访问，但在批量加载的情况下，您可以通过删除索引来受益。
执行批处理事务时，在创建相当数量的记录后执行 COMMIT，而不是在每次创建记录后创建它们。
计划定期对数据库进行碎片整理，即使这样做意味着制定每周例行程序。

内置调优工具

Oracle 有许多用于管理 SQL 语句性能的工具，但其中两个非常流行。这两个工具是 –

解释计划– 工具识别执行 SQL 语句时将采用的访问路径。
tkprof – 通过在 SQL 语句处理的每个阶段所用的时间来衡量性能。

如果您只想测量 Oracle 中查询所用的时间，可以使用 SQL*Plus 命令 SET TIMING ON。

有关上述工具和数据库碎片整理的更多详细信息，请查看您的 RDBMS 文档。