SQL的特点

综合统一  	

SQL集定义语言、数据操作语言、数据控制语言的功能于一体，语言风格统一，可以独立完成数据库生命周期中的全部活动。

定义和修改、删除关系模式，定义和删除视图，插入数据，创建数据库。
对数据库中的数据进行查询和更新。
数据库重构和维护。
数据库安全性、完整性控制，以及事物控制。
嵌入式SQL和动态SQL。


高度非过程化
面向集合的操作方式
以同一种语言结构提供多种使用方式
语言简洁、易学易用

数据定义

	

	    
属性
    	
操作方式
 
	
	

	    
创建
	    
删除
	    
修改
	
	

	    
模式
	    
CREATE SCHEMA
	    
DROP SCHEMA
	    
 
	
	

	    
表
	    
CREATE TABLE
	    
DROP TABLE
	    
ALTER TABLE
	
	

	    
视图
	    
CREATE VIEW
	    
DROP VIEW
	    
 
	
	

	    
索引
	    
CREATE INDEX
	    
DROP INDEX
	    
ALTER INDEX
	

模式的定义与删除

定义模式

CREATE SCHEMA <模式名> AUTHORIZATION <用户名>[<表定义子句>|<视图定义子句>|<授权定义子句>];

如果没有指定<模式名>，那么<模式名>隐含为<用户名>。

定义模式实际上定义了一个命名空间，在这个空间中可以进一步吧定义该模式包含的数据库对象（基本表、视图、索引等）。
删除模式

DROP SCHEMA <模式名> <CASCADE | RESTRICT>;

CASCADE 和 RESTRICT两者必选其一。

选择了 CASCADE（级联），表示在删除模式的同时把该模式中的所有数据库对象全部删除；

选择了 RESTRICT （限制），表示如果该模式中已经定义了下属的数据库对象（如表、视图等），则拒绝该删除语句的执行。只有当该模式中没有任何下属对象时才能执行 DROP SCHEMA 语句。

基本表的定义、删除与修改

定义基本表
CREATE TABLE <表名> (<列名> <数据类型> [列级完整性约束条件]
					[,<列名> <数据类型> [列级完整性约束条件]]
					……
					[,<表级完整性约束条件>]);


数据类型

常见数据类型：



数据类型
含义




CHAR(n),CHARACTER(n)
长度为 n 的定长字符串


VARCHAR(n), CHARACTERVARYING(n)
最长长度为 n 的变长字符串


CLOB
字符串大对象


BLOB
二进制大对象


INT, INTEGER
长整数（4字节）


SMALLINT
短整数（2字节）


BIGINT
大整数（8字节）


NUMERIC(p, d)
定点数，由 p 位数字（不包括符号、小数点）组成，小数点后面有 d 位数


DECIMAL(p, d), DEC(p, d)
同NUMERIC


REAL
取决于机器精度的单精度浮点数


DOUBLE PRECISION
取决于机器精度的双精度浮点数


FLOAT(n)
可选精度的浮点数，精度至少为 n 位数字


BOOLEAN
逻辑布尔量


DATE
日期，包含年、月、日，格式为 YYYY-MM-DD


TIME
时间，包含一日的时、分、秒，格式为HH : MM : SS


TIMESTAMP
时间戳类型


INTERVAL
时间间隔类型




模式与表

每一个基本表都属于某一个模式，一个模式可包含多个基本表。
修改基本表
ALTER TABLE <表名>
[ADD [COLUMN] <新列名> <数据类型> [完整性约束]]
[ADD <表级完整性约束>]
[DROP [COLUMN] <列名> [CASCADE | RESTRICT]]
[DROP CONSTRAINT<完整性约束名> [RESTRICT | CASCADE]]
[ALTER COLUMN <列名> <数据类型>];

其中<表名>是要修改的基本表。

ADD 子句用于增加新列、新的列级完整性约束条件和新的表级完整性约束条件。

DROP COLUMN 子句用于删除表中的列，如果指定了 CASCADE 短语，则自动删除引用了该列的其他对象，比如视图；如果指定了 RESTRICT 短语，则如果该列被其他对象引用，RDBMS 将拒绝删除该列。

DROP CONSTRAINT 子句用于删除指定的完整性约束条件。

ALTER COLUMN 子句用于修改原有的列定义，包括修改列名和数据类型。
删除基本表

DROP TABLE <表名> [RESTRICT | CASCADE];

若选择 RESTRICT，则该表的删除是有限制条件的。欲删除的基本表不能被其他表的约束所引用（如CHECK，FOREIGN KEY等约束）不能有视图，不能有触发器，不能有存储过程或函数等。如果存在这些依赖该表的对象，则此表不能被删除。

若选择 CASCADE，则该表的删除没有限制条件。在删除基本表的同时，相关的依赖对象，例如视图，都将被一起删除。

默认情况是 RESTRICT。

注意：不同的数据库产品在遵循 SQL 标准的基础上具体实现细节和处理策略会与标准有差别。

索引的建立与删除

当表的数据量比较大是，查询操作会比较耗时。建立索引是加快查询速度的有效手段。

数据库索引有多种类型，常见索引包括顺序文件上的索引、B+树索引、hash索引、位图索引等。

索引虽然能够加速数据库查询，但需要占用一定的存储空间，当基本表更新事，索引要进行相应的维护，这些都会增加数据库的负担，因此要更具实际应用的需要有选择的创建索引。


创建索引
CREATE [UNIQUE] [CLUSTER] INDEX <索引名>
ON [表名](<列名>[<次序>][,<列名>[<次序>]]…);

其中，<表名>是要建立的基本表的名字。索引可以建立在该表的一列或多列上，各列名之间用逗号分隔。每个<列名>后面还可以用<次序>指定索引的排列次序，可选 ASC（升序）或 DESC（降序），默认值为ASC。

UNIQUE 表明此索引的每一个索引值只对应唯一的数据记录。

CLUSTER 表示要建立的索引是聚簇索引。
修改索引

ALTER INDEX <旧索引名> RENAME TO <新索引名>;
删除索引

DROP INDEX <索引名>;

数据查询
数据查询是数据库的核心操作。SQL提供了 SELECT 语句进行数据查询。其一般格式为：

SELECT [ALL | DISTINCT] <目标列表达式> [,<目标列表达式>]…
FROM <表名或视图名> [,<表名或视图名>…]|(<SELECT语句>)[AS]<别名>
[WHERE <条件表达式>]
[GROUP BY <列名1>[HAVING <条件表达式>]]
[ORDER BY <列名2> [ASC | DESC]];


整个 SELECT 语句的含义是，根据 WHERE 子句的表达式从 FROM 子句指定的基本表、视图或派生表中找出满足条件的元组，再按 SELECT 子句中的目标列表达式选出元组中的属性值形成结果表。

如果有 GROUP BY 子句，则将结果按<列名 1>的值进行分组，该属性列值相等的元组为一个组。通常会在每组中作用聚集函数。如果GROUP BY 子句带 HAVING 短语，则只有满足指定条件的组才予以输出。

如果有 ORDER BY 子句，则结果表还要按<列名 2>的值的升序或降序排序。

单表查询

选择表中的若干列

查询指定列

SELECT col1, col2 FROM table;
查询全部列

SELECT * FROM table;
查询经过计算的值

SELECT 100-col1, 2*col2 FROM table;


选择表中的若干元组


消除取值重复的行

SELECT DISTINCT col1 FROM table;


查询满足条件的元组

查询满足指定条件的元组可以通过 WHERE 子句实现。




查询条件
谓词




比较
=, >, <, >=, <=, !=, <>, !>, !<; NOT + 上述比较运算符


确定范围
BETWEEN AND, NOT BETWEEN AND


确定集合
IN, NIT IN


字符匹配
LIKE, NOT LIKE


空值
IS NULL, IS NOT NULL


多重条件（逻辑运算）
AND, OR, NOT


重点注意字符匹配

[NOT] LIKE ‘<匹配串>’ [ESCAPE ‘<转码字符>’]

% 表示匹配任意长度的字符串
_ 代表任意单个字符




ORDER BY 子句
聚集函数



常用聚集函数
功能




COUNT(*)
统计元组个数


COUNT([DISTINCT | ALL] <列名>)
统计一列中值的个数


SUM([DISTINCT | ALL] <列名>)
计算一列值的总和（此列必须是数值型）


AVG([DISTINCT | ALL] <列名>)
计算一列值的平均值（此列必须是数值型）


MAX([DISTINCT | ALL] <列名>)
求一列值中的最大值


MIN([DISTINCT | ALL] <列名>)
求一列值中的最小值



如果指定 DISTINCT 短语，则表示在计算时要取消指定列中的重复值。默认为 ALL。

当聚集函数遇到空值时，除COUNT(*)外，都跳过空值而只处理非空值。


GROUP BY 子句

GROUP BY 子句将查询结果按某一列或多列的值分组，值相等的一组。

对查询结果分组的目的是为了细化聚集函数的作用对象。如果未对查询结果分组，聚集函数将作用于整个查询结果。分组后聚集函数将作用于每一个组，即每一组都有一个函数值。

连接查询

等值与非等值连接查询

连接查询的 WHERE 子句中用来连接两个表的条件称为连接条件或连接谓词，其一般格式为

[<表名 1>.] <列名 1> <比较运算符> [<表名 2>.] <列名 2>

当连接运算符为=时，称为等值连接。使用其他运算符称为非等值连接。

若在等值连接中把目标列中重复的属性列去掉则为自然连接。

*连接谓词中的列名称为连接字段。*连接条件中的各连接字段类型必须是可比的，但名字不必相同。
自身连接

连接操作不仅可以在两个表之间进行，也可以是一个表与其自己进行连接，称为表的自身连接
外连接

左外连接：列出左边关系中所有的元组。

table1 LEFT OUTER JOIN table2 ON(连接条件)

右外连接：列出右边关系中所有的元组。

table1 RIGHT OUTER JOIN table2 ON(连接条件)
多表连接

嵌套查询
在 SQL 语言中，一个 SELECT-FROM-WHERE 语句称为一个查询块。将一个查询块嵌套在另一个查询块的 WHERE 子句或 HAVING 短语的条件中的查询称为嵌套查询。

带有 IN 谓词的子查询

例如：
SELECT Sname
FROM Student
WHERE Sno IN (
			SELECT Sno
			FROM SC
			WHERE Cno=‘2’);

有些嵌套查询可以用连接运算替代，有些是不能替代的。
带有比较运算符的子查询

当用户能确切知道内层查询返回的是单个值时，可以用>, <, =, >=, <= !=, <>等比较运算符。
带有 ANY（SOME）或 ALL 谓词的子查询



谓词
语义




>ANY
大于子查询结果中的某个值


>ALL
大于子查询结果中的所有值


<ANY
小于子查询结果中的某个值


<ALL
小于子查询结果中的所有值


>=ANY
大于等于子查询结果中的某个值


>=ALL
大于等于子查询结果中的所有值


<=ANY
小于等于子查询结果中的某个值


<=ALL
小于等于子查询结果中的所有值


=ANY
等于子查询结果中的某个值


=ALL
等于子查询结果中的所有值（通常没有实际意义）


!=(或<>) ANY
不等于子查询结果中的某个值


!=(或<>) ALL
不等于子查询结果中的任何一个值




带有 EXISTS 谓词的子查询	

带有 EXISTS 谓词的子查询不返回任何数据，只产生逻辑真值“true” 或逻辑假值“false”。

若内层查询结果为空，则外层的 WHERE 子句返回真值，否则返回假值。

集合查询

SELECT 语句的查询结果是元组的集合，所以多个 SELECT 语句的结果可进行集合操作。主要包括并操作 UNION、交操作INTERSECT 和差操作EXCEPT。

参加集合操作的各查询结果的列数必须相同；对应项的数据类型也必须相同

基于派生表的查询
子查询不仅可以出现在WHERE 子句中，还可以出现在 FROM 子句中，这时子查询生成的临时派生表成为主查询的查询对象。
SELECT Sno, Cno
FROM SC, (SELECT Sno, Avg(Grade) FROM SC GROUP BY Sno)
		AS Avg_sc(avg_sno, avg_grade)
WHERE SC.Sno = Avg_sc.avg_sno AND SC.Grade >= Avg_sc.avg_grade;


通过 FROM 子句生成派生表时，AS关键字可以省略，但必须为派生关系指定一个别名。

SELECT 语句的一般格式
数据查询是数据库的核心操作。SQL提供了 SELECT 语句进行数据查询。其一般格式为：

SELECT [ALL | DISTINCT] <目标列表达式> [,<目标列表达式>]…
FROM <表名或视图名> [,<表名或视图名>…]|(<SELECT语句>)[AS]<别名>
[WHERE <条件表达式>]
[GROUP BY <列名1>[HAVING <条件表达式>]]
[ORDER BY <列名2> [ASC | DESC]];


目标列表达式的可选格式






<表名>.*
COUNT([DISTINCT | ALL] *)
[<表名>.] <属性列名表达式> [, [<表名>.] <属性列名表达式>]…

其中，<属性列名表达式>可以是由属性列、作用于属性列的聚集函数和常量的任意算术运算（+，-，*，/）组成的运算公式。


聚集函数的一般格式


WHERE 子句的条件表达式的可选格式



数据更新
插入数据

插入元组
INSERT INTO <表名> [(<属性列1> [,<属性列2>]...)]
VALUES (<常量1>, [,<常量2>]...);

其功能是将新元组插入指定表中。其中新元组的属性列1 的值为常量1 ，属性列2 的值为常量2 ，…。INTO 子句中没有出现的属性列，新元组在这些列上将取空值。但必须注意的是，在表定义时说明了NOT NULL 的属性列不能取空值，否则会出错。

如果 INTO 子句中没有指明任何属性列名，则新插入的元组必须在每个属性列上均有值。
插入子查询结果
INSERT INTO <表名> [(<属性列1>[,<属性列2>...])]
子查询;



修改数据
UPDATE <表名>
SET <列名>=<表达式> [,<列名>=<表达式>] ...
[WHERE <条件>];

删除数据
DELETE FROM <表名>
[WHERE <条件>];

DELETE 语句删除的是表中的数据，而不是关于表的定义。
视图
定义视图

创建视图
CREATE VIEW <视图名> [(<列名> [,<列名>]...)]
AS <子查询>
[WITH CHECK OPTION];

组成视图的属性列名或者全部省略或者全部指定，没有第三种选择。

以下三种情况下必须明确指定组成视图的所有列名：

某个目标列不是单纯的属性名，而是聚集函数或列表达式。
多表连接时选出了几个同名列作为视图的字段。
需要在视图中为某个列启用新的更合适的名字。

DBMS 执行 CREATE VIEW 语句的结构只是把视图的定义存入数据字典，并不执行其中的 SELECT 语句。


删除视图

DROP VIEW <视图名> [CASCADE];

视图删除后视图的定义将从数据字典中删除。如果该视图上还导出了其他视图，则使用 CASCADE 级联删除语句把该视图和由它导出的所有视图一起删除。

查询视图
视图定义后，用户就可以像对基本表一样对视图表进行查询。


关系数据库管理系统执行对视图的查询时，首先进行有效性检查，检查查询中涉及的表、视图等是否存在。如果存在，则从数据字典中取出视图的定义，把定义中的子查询和用户的查询结合起来，转换成等价的对基本表的查询，然后再执行修正了的查询。这一转换过程称为 视图消除。

目前多数关系数据库系统对行列子集视图的查询均能进行正确转换。但对非行列子集视图的查询就不一定能做转换了。

更新视图
更新视图是通过视图来插入(INSERT)、删除(DELETE)、和修改(UPDATE)数据


由于视图是不存在存储数据的虚表，因此对视图的更新最终要转换为对基本表的更新。

像查询视图那样，对视图的更新操作也是通过视图小姐，转换为对基本表的更新操作。

一般的，行列子集视图是可更新的。

视图的作用

简化用户的操作
使用户能以多种角度看待同一数据
视图对重构数据库提供了一定程度的逻辑独立性
视图能够对机密数据提供安全保护
适当利用视图可以更清晰地表达查询

开发工作中我们常用的数据库大致分为关系型数据库和非关系型数据库两种，那这两种到底是什么呢？

1.关系型数据库

所谓关系型数据库，是建立在关系模型基础上的数据库。

关系模型由关系数据结构、关系操作集合、关系完整性约束三部分组成。

标准数据查询语言SQL就是一种基于关系数据库的语言，这种语言执行对关系数据库中数据的检索和操作。

简单说，关系型数据库是由多张能互相联接的二维行列表格组成的数据库。当前主流的关系型数据库有Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL等。

优点：

1、易于维护：都是使用表结构，格式一致；

2、使用方便：SQL语言通用，可用于复杂查询；

3、复杂操作：支持SQL，可用于一个表以及多个表之间非常复杂的查询。
缺点：

1、读写性能比较差，尤其是海量数据的高效率读写；

2、固定的表结构，灵活度稍欠；

3、高并发读写需求，传统关系型数据库来说，硬盘I/O是一个很大的瓶颈。

常见的关系型数据库



Oracle:

属于大型数据库，采用标准的SQL结构化查询语言，支持多种数据类型，提供面向对象存储的数据支持，除此之外，它还具有很好的并行处理功能，收费比较昂贵。

SQL Server：

微软全家桶的一员，常搭配微软下开发语言使用）

MySql：

目前属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择 MySQL 作为网站数据库。

2.非关系型数据库



非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合，可以是文档或者键值对等。
优点：

1、格式灵活：存储数据的格式可以是key --》value、文档、图片等等，使用灵活，应用场景广泛，而关系型数据库则只支持基础类型。

2、速度快：nosql可以使用硬盘或者随机存储器作为载体，而关系型数据库只能使用硬盘；

3、高扩展性；

4、成本低：nosql数据库部署简单，基本都是开源软件。

缺点：

1、不提供sql支持，学习和使用成本较高；

2、无事务处理；

3、数据结构相对复杂，复杂查询方面稍欠。

非关系型数据库的分类和比较：

1、文档型

2、key-value型

3、列式数据库

4、图形数据库

 







Redis就是一种典型的 KRY-VALUE 型数据库

一、关系数据库与非关系型数据库概述
1、关系型数据库

关系型数据库是一个结构化的数据库，创建在关系模型（二维表格模型）基础上，一般面向于记录。

SQL 语句（标准数据查询语言）就是一种基于关系型数据库的语言，用于执行对关系型数据库中数据的检索和操作。

主流的关系型数据库包括 Oracle、MySQL、SQL Server、Microsoft Access、DB2 等。

2、非关系型数据库

NoSQL(NoSQL = Not Only SQL )，意思是“不仅仅是 SQL”，是非关系型数据库的总称。

除了主流的关系型数据库外的数据库，都认为是非关系型。

主流的 NoSQL 数据库有 Redis、MongBD、Hbase、CouhDB 等。

二、关系数据库与非关系型数据库区别
1、数据存储方式不同

关系型和非关系型数据库的主要差异是数据存储的方式。关系型数据天然就是表格式的，因此存储在数据表的行和列中。数据表可以彼此关联协作存储，也很容易提取数据。

与其相反，非关系型数据不适合存储在数据表的行和列中，而是大块组合在一起。非关系型数据通常存储在数据集中，就像文档、键值对或者图结构。你的数据及其特性是选择数据存储和提取方式的首要影响因素。
2、扩展方式不同

SQL和NoSQL数据库最大的差别可能是在扩展方式上，要支持日益增长的需求当然要扩展。

要支持更多并发量，SQL数据库是纵向扩展，也就是说提高处理能力，使用速度更快速的计算机，这样处理相同的数据集就更快了。因为数据存储在关系表中，操作的性能瓶颈可能涉及很多个表，这都需要通过提高计算机性能来客服。虽然SQL数据库有很大扩展空间，但最终肯定会达到纵向扩展的上限。

而NoSQL数据库是横向扩展的。因为非关系型数据存储天然就是分布式的，NoSQL数据库的扩展可以通过给资源池添加更多普通的数据库服务器(节点)来分担负载。
3、对事务性的支持不同

如果数据操作需要高事务性或者复杂数据查询需要控制执行计划，那么传统的SQL数据库从性能和稳定性方面考虑是你的最佳选择。SQL数据库支持对事务原子性细粒度控制，并且易于回滚事务。

虽然NoSQL数据库也可以使用事务操作，但稳定性方面没法和关系型数据库比较，所以它们真正闪亮的价值是在操作的扩展性和大数据量处理方面。
三、非关系型数据库产生背景
可用于应对 Web2.0 纯动态网站类型的三高问题。

（1）High performance——对数据库高并发读写需求

（2）Huge Storage——对海量数据高效存储与访问需求

（3）High Scalability && High Availability——对数据库高可扩展性与高可用性需求
关系型数据库和非关系型数据库都有各自的特点与应用场景，两者的紧密结合将会给Web2.0的数据库发展带来新的思路。让关系数据库关注在关系上，非关系型数据库关注在存储上。例如，在读写分离的MySQL数据库环境中,可以把经常访问的数据存储在非关系型数据库中，提升访问速度。
总结：

关系型数据库：

实例–>数据库–>表(table)–>记录行(row)、数据字段(column)
非关系型数据库：

实例–>数据库–>集合(collection)–>键值对(key-value)

非关系型数据库不需要手动建数据库和集合（表）。
四、Redis简介
Redis 是一个开源的、使用 C 语言编写的 NoSQL 数据库。

Redis 基于内存运行并支持持久化，采用key-value（键值对）的存储形式，是目前分布式架构中不可或缺的一环。
Redis服务器程序是单进程模型，也就是在一台服务器上可以同时启动多个Redis进程，Redis的实际处理速度则是完全依靠于主进程的执行效率。若在服务器上只运行一个Redis进程，当多个客户端同时访问时，服务器的处理能力是会有一定程度的下降；若在同一台服务器上开启多个Redis进程，Redis在提高并发处理能力的同时会给服务器的CPU造成很大压力。即：在实际生产环境中，需要根据实际的需求来决定开启多少个Redis进程。若对高并发要求更高一些，可能会考虑在同一台服务器上开启多个进程。若 CPU 资源比较紧张，采用单进程即可。
1、Redis 优点

（1）具有极高的数据读写速度：数据读取的速度最高可达到 110000 次/s，数据写入速度最高可达到 81000 次/s。

（2）支持丰富的数据类型：支持 key-value、Strings、Lists、Hashes、Sets 及 Ordered Sets 等数据类型操作。

（3）支持数据的持久化：可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

（4）原子性：Redis 所有操作都是原子性的。

（5）支持数据备份：即 master-salve 模式的数据备份。
Redis作为基于内存运行的数据库，缓存是其最常应用的场景之一。除此之外，Redis常见应用场景还包括获取最新N个数据的操作、排行榜类应用、计数器应用、存储关系、实时分析系统、日志记录。
五、Redis 安装部署
systemctl stop firewalld
setenforce 0

yum install -y gcc gcc-c++ make

tar zxvf redis-5.0.7.tar.gz -C /opt/

cd /opt/redis-5.0.7/
make
make PREFIX=/usr/local/redis install


cd /opt/redis-5.0.7/utils
./install_server.sh
……
慢慢回车
Please select the redis executable path []
手动输入
/usr/local/redis/bin/redis-server


Selected config:
Port           : 6379								#默认侦听端口为6379
Config file    : /etc/redis/6379.conf				#配置文件路径
Log file       : /var/log/redis_6379.log			#日志文件路径
Data dir       : /var/lib/redis/6379				#数据文件路径
Executable     : /usr/local/redis/bin/redis-server	#可执行文件路径
Cli Executable : /usr/local/bin/redis-cli			#客户端命令工具

ln -s /usr/local/redis/bin/* /usr/local/bin/

/etc/init.d/redis_6379 stop				#停止
/etc/init.d/redis_6379 start			#启动
/etc/init.d/redis_6379 restart			#重启
/etc/init.d/redis_6379 status			#状态



修改配置 /etc/redis/6379.conf 参数

vim /etc/redis/6379.conf

70行，添加 监听的主机地址
bind 127.0.0.1 192.168.184.10				

93行，Redis默认的监听端口
port 6379									

137行，启用守护进程
daemonize yes							

159行，指定 PID 文件
pidfile /var/run/redis_6379.pid				

167行，日志级别
loglevel notice								

172行，指定日志文件
logfile /var/log/redis_6379.log				

/etc/init.d/redis_6379 restart


六、Redis 命令工具
redis-server		用于启动 Redis 的工具
redis-benchmark		用于检测 Redis 在本机的运行效率
redis-check-aof		修复 AOF 持久化文件
redis-check-rdb		修复 RDB 持久化文件
redis-cli	 		Redis命令行工具

1、redis-cli 命令行工具
语法：redis-cli -h host -p port -a password



若不添加任何选项表示，则使用 127.0.0.1:6379 连接本机上的 Redis 数据库
redis-cli -h 192.168.184.10 -p 6379

2、redis-benchmark 测试工具

redis-benchmark 是官方自带的 Redis 性能测试工具，可以有效的测试 Redis 服务的性能。

基本的测试语法：redis-benchmark [选项] [选项值]。



向 IP 地址为 192.168.184.10、端口为 6379 的 Redis 服务器发送 100 个并发连接与 100000 个请求测试性能
redis-benchmark -h 192.168.184.10 -p 6379 -c 100 -n 100000



测试存取大小为 100 字节的数据包的性能
redis-benchmark -h 192.168.184.10 -p 6379 -q -d 100



测试本机上 Redis 服务在进行 set 与 lpush 操作时的性能
redis-benchmark -t set,lpush -n 100000 -q



3、Redis 数据库常用命令
set		存放数据，命令格式为 set key value
get		获取数据，命令格式为 get key
keys 	命令可以取符合规则的键值列表，通常情况可以结合*、?等选项来使用。
exists 	命令可以判断键值是否存在。
del 	命令可以删除当前数据库的指定 key。
type 	命令可以获取 key 对应的 value 值类型。


keys *
keys h*
keys a?
keys a??


exists teacher
exists haha


rename 命令是对已有 key 进行重命名。（覆盖）
命令格式：rename 源key 目标key

例：
keys a*
rename a22 a2
keys a*
get a1
get a2
rename a1 a2
keys a*
get a2

renamenx 命令的作用是对已有 key 进行重命名，并检测新名是否存在，如果目标 key 存在则不进行重命名。（不覆盖）
命令格式：renamenx 源key 目标key
例:
keys h*
renamenx h1 h2
keys h*
renamenx h1 h4
keys h*


dbsize 命令的作用是查看当前数据库中 key 的数目。
例：
keys *
dbsize

使用config set requirepass password命令设置密码
使用config get requirepass命令查看密码（一旦设置密码，必须先验证通过密码，否则所有操作不可用）
例：
config set requirepass 123123
auth 123123
config get requirepass
quit
redis-cli
keys *
auth 123123
keys *



4、Redis 多数据库常用命令

Redis 支持多数据库，Redis 默认情况下包含 16 个数据库，数据库名称是用数字 0-15 来依次命名的。

多数据库相互独立，互不干扰。

————————————————

多数据库间切换
命令格式：select 序号

使用 redis-cli 连接 Redis 数据库后，默认使用的是序号为 0 的数据库。
127.0.0.1:6379> select 10			#切换至序号为 10 的数据库
127.0.0.1:6379[10]> select 15		#切换至序号为 15 的数据库
127.0.0.1:6379[15]> select 0		#切换至序号为 0 的数据库

多数据库间移动数据
格式：move 键值 序号
例：
set lic kiki
get lic

select 5
get lic

select 0
move lic 5
get lic

select 5
get lic


清除数据库内数据
FLUSHDB ：清空当前数据库数据
FLUSHALL ：清空所有数据库的数据，慎用！

七、Redis 高可用
在web服务器中，高可用是指服务器可以正常访问的时间，衡量的标准是在多长时间内可以提供正常服务（99.9%、99.99%、99.999%等等）。

但是在Redis语境中，高可用的含义似乎要宽泛一些，除了保证提供正常服务（如主从分离、快速容灾技术），还需要考虑数据容量的扩展、数据安全不会丢失等。
在Redis中，实现高可用的技术主要包括持久化、主从复制、哨兵和集群，下面分别说明它们的作用，以及解决了什么样的问题。
●持久化：持久化是最简单的高可用方法(有时甚至不被归为高可用的手段)，主要作用是数据备份，即将数据存储在硬盘，保证数据不会因进程退出而丢失。
●主从复制：主从复制是高可用Redis的基础，哨兵和集群都是在主从复制基础上实现高可用的。主从复制主要实现了数据的多机备份，以及对于读操作的负载均衡和简单的故障恢复。缺陷：故障恢复无法自动化；写操作无法负载均衡；存储能力受到单机的限制。
●哨兵：在主从复制的基础上，哨兵实现了自动化的故障恢复。缺陷：写操作无法负载均衡；存储能力受到单机的限制。
●集群：通过集群，Redis解决了写操作无法负载均衡，以及存储能力受到单机限制的问题，实现了较为完善的高可用方案。
八、Redis 持久化
持久化的功能：Redis是内存数据库，数据都是存储在内存中，为了避免服务器断电等原因导致Redis进程异常退出后数据的永久丢失，需要定期将Redis中的数据以某种形式（数据或命令）从内存保存到硬盘；当下次Redis重启时，利用持久化文件实现数据恢复。除此之外，为了进行灾难备份，可以将持久化文件拷贝到一个远程位置。
九、Redis 提供两种方式进行持久化
●RDB 持久化：原理是将 Reids在内存中的数据库记录定时保存到磁盘上。

●AOF 持久化（append only file）：原理是将 Reids 的操作日志以追加的方式写入文件，类似于MySQL的binlog。
由于AOF持久化的实时性更好，即当进程意外退出时丢失的数据更少，因此AOF是目前主流的持久化方式，不过RDB持久化仍然有其用武之地。

1、RDB 持久化

RDB持久化是指在指定的时间间隔内将内存中当前进程中的数据生成快照保存到硬盘(因此也称作快照持久化)，用二进制压缩存储，保存的文件后缀是rdb；当Redis重新启动时，可以读取快照文件恢复数据。

1、触发条件

RDB持久化的触发分为手动触发和自动触发两种。
（1）手动触发

save命令和bgsave命令都可以生成RDB文件。

save命令会阻塞Redis服务器进程，直到RDB文件创建完毕为止，在Redis服务器阻塞期间，服务器不能处理任何命令请求。

而bgsave命令会创建一个子进程，由子进程来负责创建RDB文件，父进程(即Redis主进程)则继续处理请求。
bgsave命令执行过程中，只有fork子进程时会阻塞服务器，而对于save命令，整个过程都会阻塞服务器，因此save已基本被废弃，线上环境要杜绝save的使用。
（2）自动触发

在自动触发RDB持久化时，Redis也会选择bgsave而不是save来进行持久化。
save m n

自动触发最常见的情况是在配置文件中通过save m n，指定当m秒内发生n次变化时，会触发bgsave。
vim /etc/redis/6379.conf

219行以下三个save条件满足任意一个时，都会引起bgsave的调用
save 900 1 ：当时间到900秒时，如果redis数据发生了至少1次变化，则执行bgsave
save 300 10 ：当时间到300秒时，如果redis数据发生了至少10次变化，则执行bgsave
save 60 10000 ：当时间到60秒时，如果redis数据发生了至少10000次变化，则执行bgsave


254行指定RDB文件名
dbfilename dump.rdb

264行指定RDB文件和AOF文件所在目录
dir /var/lib/redis/6379

242行是否开启RDB文件压缩
rdbcompression yes

2、执行流程

（1）Redis父进程首先判断：当前是否在执行save，或bgsave/bgrewriteaof的子进程，如果在执行则bgsave命令直接返回。 bgsave/bgrewriteaof的子进程不能同时执行，主要是基于性能方面的考虑：两个并发的子进程同时执行大量的磁盘写操作，可能引起严重的性能问题。

（2）父进程执行fork操作创建子进程，这个过程中父进程是阻塞的，Redis不能执行来自客户端的任何命令

（3）父进程fork后，bgsave命令返回”Background saving started”信息并不再阻塞父进程，并可以响应其他命令

（4）子进程创建RDB文件，根据父进程内存快照生成临时快照文件，完成后对原有文件进行原子替换

（5）子进程发送信号给父进程表示完成，父进程更新统计信息
3、启动时加载

RDB文件的载入工作是在服务器启动时自动执行的，并没有专门的命令。但是由于AOF的优先级更高，因此当AOF开启时，Redis会优先载入 AOF文件来恢复数据；只有当AOF关闭时，才会在Redis服务器启动时检测RDB文件，并自动载入。服务器载入RDB文件期间处于阻塞状态，直到载入完成为止。

Redis载入RDB文件时，会对RDB文件进行校验，如果文件损坏，则日志中会打印错误，Redis启动失败。

2、AOF 持久化

RDB持久化是将进程数据写入文件，而AOF持久化，则是将Redis执行的每次写、删除命令记录到单独的日志文件中，查询操作不会记录； 当Redis重启时再次执行AOF文件中的命令来恢复数据。

与RDB相比，AOF的实时性更好，因此已成为主流的持久化方案。
1、 开启AOF

Redis服务器默认开启RDB，关闭AOF；要开启AOF，需要在配置文件中配置：
vim /etc/redis/6379.conf

700行修改，开启AOF
appendonly yes

704行指定AOF文件名称
appendfilename "appendonly.aof"

796行是否忽略最后一条可能存在问题的指令`
aof-load-truncated yes

/etc/init.d/redis_6379 restart

2、执行流程

由于需要记录Redis的每条写命令，因此AOF不需要触发，下面介绍AOF的执行流程。
AOF的执行流程包括：

●命令追加(append)：将Redis的写命令追加到缓冲区aof_buf；

●文件写入(write)和文件同步(sync)：根据不同的同步策略将aof_buf中的内容同步到硬盘；

●文件重写(rewrite)：定期重写AOF文件，达到压缩的目的。
（1）命令追加(append)

Redis先将写命令追加到缓冲区，而不是直接写入文件，主要是为了避免每次有写命令都直接写入硬盘，导致硬盘IO成为Redis负载的瓶颈。

命令追加的格式是Redis命令请求的协议格式，它是一种纯文本格式，具有兼容性好、可读性强、容易处理、操作简单避免二次开销等优点。在AOF文件中，除了用于指定数据库的select命令（如select 0为选中0号数据库）是由Redis添加的，其他都是客户端发送来的写命令。
（2）文件写入(write)和文件同步(sync)

Redis提供了多种AOF缓存区的同步文件策略，策略涉及到操作系统的write函数和fsync函数，说明如下：

为了提高文件写入效率，在现代操作系统中，当用户调用write函数将数据写入文件时，操作系统通常会将数据暂存到一个内存缓冲区里，当缓冲区被填满或超过了指定时限后，才真正将缓冲区的数据写入到硬盘里。这样的操作虽然提高了效率，但也带来了安全问题：如果计算机停机，内存缓冲区中的数据会丢失；因此系统同时提供了fsync、fdatasync等同步函数，可以强制操作系统立刻将缓冲区中的数据写入到硬盘里，从而确保数据的安全性。
AOF缓存区的同步文件策略存在三种同步方式，它们分别是：
vim /etc/redis/6379.conf

729

●appendfsync always： 命令写入aof_buf后立即调用系统fsync操作同步到AOF文件，fsync完成后线程返回。这种情况下，每次有写命令都要同步到AOF文件，硬盘IO成为性能瓶颈，Redis只能支持大约几百TPS写入，严重降低了Redis的性能；即便是使用固态硬盘（SSD），每秒大约也只能处理几万个命令，而且会大大降低SSD的寿命。
●appendfsync no： 命令写入aof_buf后调用系统write操作，不对AOF文件做fsync同步；同步由操作系统负责，通常同步周期为30秒。这种情况下，文件同步的时间不可控，且缓冲区中堆积的数据会很多，数据安全性无法保证。
●appendfsync everysec： 命令写入aof_buf后调用系统write操作，write完成后线程返回；fsync同步文件操作由专门的线程每秒调用一次。everysec是前述两种策略的折中，是性能和数据安全性的平衡，因此是Redis的默认配置，也是我们推荐的配置。

（3）文件重写(rewrite)

随着时间流逝，Redis服务器执行的写命令越来越多，AOF文件也会越来越大；过大的AOF文件不仅会影响服务器的正常运行，也会导致数据恢复需要的时间过长。
文件重写是指定期重写AOF文件，减小AOF文件的体积。需要注意的是，AOF重写是把Redis进程内的数据转化为写命令，同步到新的AOF文件；不会对旧的AOF文件进行任何读取、写入操作!
关于文件重写需要注意的另一点是：对于AOF持久化来说，文件重写虽然是强烈推荐的，但并不是必须的；即使没有文件重写，数据也可以被持久化并在Redis启动的时候导入；因此在一些实现中，会关闭自动的文件重写，然后通过定时任务在每天的某一时刻定时执行。
文件重写之所以能够压缩AOF文件，原因在于：

●过期的数据不再写入文件

●无效的命令不再写入文件：如有些数据被重复设值(set mykey v1, set mykey v2)、有些数据被删除了(sadd myset v1, del myset)等。

●多条命令可以合并为一个：如sadd myset v1, sadd myset v2, sadd myset v3可以合并为sadd myset v1 v2 v3。
通过上述内容可以看出，由于重写后AOF执行的命令减少了，文件重写既可以减少文件占用的空间，也可以加快恢复速度。

文件重写的触发，分为手动触发和自动触发：

●手动触发：直接调用bgrewriteaof命令，该命令的执行与bgsave有些类似：都是fork子进程进行具体的工作，且都只有在fork时阻塞。

●自动触发：通过设置auto-aof-rewrite-min-size选项和auto-aof-rewrite-percentage选项来自动执行BGREWRITEAOF。 只有当auto-aof-rewrite-min-size和auto-aof-rewrite-percentage两个选项同时满足时，才会自动触发AOF重写，即bgrewriteaof操作。
vim /etc/redis/6379.conf

771

●auto-aof-rewrite-percentage 100 ：当前AOF文件大小(即aof_current_size)是上次日志重写时AOF文件大小(aof_base_size)两倍时，发生BGREWRITEAOF操作

●auto-aof-rewrite-min-size 64mb ：当前AOF文件执行BGREWRITEAOF命令的最小值，避免刚开始启动Reids时由于文件尺寸较小导致频繁的BGREWRITEAOF
关于文件重写的流程，有两点需要特别注意：(1)重写由父进程fork子进程进行；(2)重写期间Redis执行的写命令，需要追加到新的AOF文件中，为此Redis引入了aof_rewrite_buf缓存。
文件重写的流程如下

（1）Redis父进程首先判断当前是否存在正在执行bgsave/bgrewriteaof的子进程，如果存在则bgrewriteaof命令直接返回，如果存在 bgsave命令则等bgsave执行完成后再执行。

（2）父进程执行fork操作创建子进程，这个过程中父进程是阻塞的。

（3.1）父进程fork后，bgrewriteaof命令返回”Background append only file rewrite started”信息并不再阻塞父进程， 并可以响应其他命令。Redis的所有写命令依然写入AOF缓冲区，并根据appendfsync策略同步到硬盘，保证原有AOF机制的正确。

（3.2）由于fork操作使用写时复制技术，子进程只能共享fork操作时的内存数据。由于父进程依然在响应命令，因此Redis使用AOF重写缓冲区(aof_rewrite_buf)保存这部分数据，防止新AOF文件生成期间丢失这部分数据。也就是说，bgrewriteaof执行期间，Redis的写命令同时追加到aof_buf和aof_rewirte_buf两个缓冲区。

（4）子进程根据内存快照，按照命令合并规则写入到新的AOF文件。

（5.1）子进程写完新的AOF文件后，向父进程发信号，父进程更新统计信息，具体可以通过info persistence查看。

（5.2）父进程把AOF重写缓冲区的数据写入到新的AOF文件，这样就保证了新AOF文件所保存的数据库状态和服务器当前状态一致。

（5.3）使用新的AOF文件替换老文件，完成AOF重写。
3、启动时加载

当AOF开启时，Redis启动时会优先载入AOF文件来恢复数据；只有当AOF关闭时，才会载入RDB文件恢复数据。

当AOF开启，但AOF文件不存在时，即使RDB文件存在也不会加载。

Redis载入AOF文件时，会对AOF文件进行校验，如果文件损坏，则日志中会打印错误，Redis启动失败。但如果是AOF文件结尾不完整(机器突然宕机等容易导致文件尾部不完整)，且aof-load-truncated参数开启，则日志中会输出警告，Redis忽略掉AOF文件的尾部，启动成功。aof-load-truncated参数默认是开启的。

3、RDB和AOF的优缺点

●RDB持久化

优点：RDB文件紧凑，体积小，网络传输快，适合全量复制；恢复速度比AOF快很多。当然，与AOF相比，RDB最重要的优点之一是对性能的影响相对较小。
缺点：RDB文件的致命缺点在于其数据快照的持久化方式决定了必然做不到实时持久化，而在数据越来越重要的今天，数据的大量丢失很多时候是无法接受的，因此AOF持久化成为主流。此外，RDB文件需要满足特定格式，兼容性差（如老版本的Redis不兼容新版本的RDB文件）。

对于RDB持久化，一方面是bgsave在进行fork操作时Redis主进程会阻塞，另一方面，子进程向硬盘写数据也会带来IO压力。
●AOF持久化

与RDB持久化相对应，AOF的优点在于支持秒级持久化、兼容性好，缺点是文件大、恢复速度慢、对性能影响大。

对于AOF持久化，向硬盘写数据的频率大大提高(everysec策略下为秒级)，IO压力更大，甚至可能造成AOF追加阻塞问题。

AOF文件的重写与RDB的bgsave类似，会有fork时的阻塞和子进程的IO压力问题。相对来说，由于AOF向硬盘中写数据的频率更高，因此对 Redis主进程性能的影响会更大。
十、Redis 性能管理
----- 查看Redis内存使用 -----
redis-cli -h 192.168.184.10 -p 6379
192.168.184.10:6379> info memory

----- 内存碎片率 -----

操系统分配的内存值used_memory_rss除以Redis使用的内存值used_memory计算得出
内存碎片是由操作系统低效的分配/回收物理内存导致的（不连续的物理内存分配）
#跟踪内存碎片率对理解Redis实例的资源性能是非常重要的：

●内存碎片率稍大于1是合理的，这个值表示内存碎片率比较低

●内存碎片率超过1.5，说明Redis消耗了实际需要物理内存的150%，其中50%是内存碎片率。需要在redis-cli工具上输入shutdown save 命令，并重启 Redis 服务器。

●内存碎片率低于1的，说明Redis内存分配超出了物理内存，操作系统正在进行内存交换。需要增加可用物理内存或减少 Redis 内存占用。
----- 内存使用率 -----

redis实例的内存使用率超过可用最大内存，操作系统将开始进行内存与swap空间交换。
#避免内存交换发生的方法：

●针对缓存数据大小选择安装 Redis 实例

●尽可能的使用Hash数据结构存储

●设置key的过期时间
----- 内回收key -----

保证合理分配redis有限的内存资源。
当达到设置的最大阀值时，需选择一种key的回收策略，默认情况下回收策略是禁止删除。

配置文件中修改 maxmemory-policy 属性值：
vim /etc/redis/6379.conf

598取消注释
maxmemory-policy noenviction

数据库

数据库一般分为关系型数据和NoSql数据库， 关系型数据库一般使SQL操作，SQL对大小写不敏感。



SQL的数据类型

SQL支持许多内置的数据类型，并且允许用户定义新的域（数据）类型。

char(n)：定长字符串，长度n由用户指定。省略（n）时，长度为1。全称为character。
varchar(n)：变长字符串，最大长度n由用户指定。全称是character varying。定长和变长的区别主要表现在前者需要固定长度的空间，二后者占用的空间在最大长度范围内是可以改变的。
bit(n)：定长二进位串，长度n由用户指定。省略n时，长度为1。
bit varying(n)：变长二进位串，最大长度n由用户指定。
int：整数，其值域依赖于具体的实现，全称是integer。
smallint：小整数，其值域依赖于具体的实现，但是小于int的值域。
numeric(p, d)：p位有效数字的定点数，其中小数点右边占d位。
dec(p, d)：p位有效数字的定点数，其中小数点右边占d位。全称是decimal。
float(n)：精度至少为n位数字的浮点数，其值域依赖于实现。
real：实数，其值域依赖于实现。
double precision：双精度实数，精度依赖于实现，但精度比real高。
date：日期，包括年、月、日，格式为YYYY-MM-DD。
time：时间，包括时、分、秒，格式为HH：MM：SS。time(n)可以表示比秒更小的单位，秒后取n位
timestamp：时间戳，是data和time的结合体，包括年、月、日、时、分、秒。timestamp(n)可以表示比秒更小的单位，秒后取n位。
interval：时间间隔。SQL允许对date、time和interval类型的值进行运算。例如，如果x和y都是date类型，则x-y为interval类型，其值为x和y之间的天数。在date或time类型的值上加减一个interval类型的值得到新的date或time类型的值。
数据库操作：

查看当前数据库服务器有哪些数据库： show databases;
使用当前数据库服务器下的某一个数据库：use 数据库名称;
创建数据库：create database 数据库名称；
删除数据库：drop database 数据库名称
数据表操作

创建数据表:
create table <表名> (<列定义>...<列定义>   [<表约束定义>...<表约束定义>]);

<表名>：标识符，是对定义的基本表命名

<列定义>：定义每个属性（列）的名称、类型、缺省值和列上的约束条件，格式是：
<列名> <类型> [default<缺省值>] <列约束定义>,...,<列约束定义>

列约束定义格式：
[constraint <约束名>] <列约束>
其中可选短语“constraint <约束名>”为列约束的命名。常用的列约束包括：
1）not null：不允许该列取空值，不加此限制时，该列可以取空值。
2）primary key：知名该列时主码（主键）,其值非空、唯一。
3）unique：该列上的值必须唯一。这相当于说明该列为候选码。
4）check(<条件>)：指明该列的值必须满足的条件，其中<条件>是一个涉及该列的布尔表达式。

表约束定义格式：
[constraint <约束名>] <表约束>
其中可选短语“constraint <约束名>”为表约束的命名。常用的表约束包括：
1）primary key(A1, A2,...Ak)：说明属性列A1...Ak构成该表的主码（主键）。当主码只包含一个属性时，也可以用列定义约束定义主码。
2）unique(A1, A2,...Ak)：说明这些属性列上的值必须唯一，这相当于说明A1，...，Ak构成该表的候选码。当候选码只包含一个属性时，也可以用列约束定义候选码。
3）check(A1,...，Ak)：说明该表上的一个完整性约束条件。通常，<条件>是一个涉及到该表一个或多个列的布尔表达式。

外码比较复杂，它具有如下形式：
foreign key(A1,...,Ak) references <外表名> (<外表主码>)
[<参照触发动作>]
它说明属性时A1,...,Ak是表的外码，<外表名>给出被参照关系的表名，<外表主码>给出被参照关系的主码，而<参照触发动作>说明违反参照完整性时需要采取的措施。

eg：创建教师表Teachers
creat table Teachers
(
Tno      char(7) not null primary key,
Tname    char(10) not null,
Sex      char(2) check(Sex='男' or Sex='女'),
Birthday date,
Title    char(6),
Dno      char(4),
foreign key (Dno) references Departments (Dno)
);

这里，我们定义Tno为Teachers的主码，Tname不能为空，而用check短语限定Sex的值只能是“男”或“女”。最后一行定义Dno为关系Teachers的外码，它参照Departments的主码Dno。


eg：创建选课表SC
create table SC
(
Sno     char(9),
Cno     char(5),
Grade   smallint check(Grade>=0 and Grade<=100),
primary key(Sno, Cno),
foreign key(Sno) references Students (Sno),
foreign key(Cno) references Courses (Cno)
);


修改数据表
(1)向数据表中添加新列
alter table <表名> add [column] <列定义>
例：向Courses中增加一个新列Pno，表示课程的先行课程号
alter table Courses add Pno char(5);

(2)对于已经存在的列，只允许修改或删除列的缺省值，语句形式为
alter table <表名> alter [column] <列名> {set default <缺省值> | drop default}
例：在Students的Sex列设置缺省值“女”可以减少大约一半学生性别的输入。可以使用如下语句：
alter table Students alter Sex set default '女';
而删除Sex上的缺省值可以用：
alter table Students alter Sex drop default;

(3)删除已经存在的列
alter table <表名> drop [column] <列名> {cascade | restrict}
其中cascade表示级联，删除将成功，并且依赖于该列的数据库对象（如涉及到该列的视图）也一并删除。restrict表示受限，仅当没有依赖于该列的数据库对象时删除才成功。
例：删除Courses中的Pno列可以用：
alter table Courses drop Pno;

(4)添加表约束
alter table <表名> add <表约束定义>
其中表约束定义与创建基本表相同。

(5)删除表约束
alter table <表名> drop constraint <约束名> {cascade | restrict}
其中被删除的约束名一定是命名的约束，给出约束名。cascade导致删除约束并且同时删除依赖于该约束的数据库对象。而restrict仅当不存在依赖于该约束的数据库对象才可以删除该约束。


删除基本表
当不需要某个基本表时，可以将其删除。语句格式为：
drop table <表名> {cascade | restrict}
其中cascade表示级联删除，依赖于表的数据对象（最常见的是视图）也将一同删除。restrict表示受限删除，如果基于该表定义有视图或者有其他表引用该表（如check，foreign key等约束），或者该表有触发器。存储过程或函数等，则不能删除。
删除基本表将导致存放在表中的数据和表定义都将被彻底删除。

例：
drop table Student restrict;


添加
insert语句有两种使用形式，一种是向基本表中插入单个元组；另一种是将查询的结果（多个元组）插入基本表。

1）插入单个元组
语句格式为：
insert into T[(A1, .... ，Ak)] values (c1,....,ck);
其中T通常是基本表，也可以是视图，Ai是T的属性，ci是常量。
(A1, .... ，Ak)缺省时，values子句必须按基本表属性的定义次序提供新元素每个属性上的值。否则，(A1, .... ，Ak)中属性的次序可以是任意次序，并且可以仅列举基本表的部分属性。此时，value子句中的常量与属性个数是相等的，并且常量对应相对位置上的属性，新元组取缺省值（如果定义了缺省值的话）或空值为null。

eg.

insert 表名 (栏位名称) values (栏位值)

insert stu_info (stu_no, stu_name, gender, birthday)
values('20171217123', '张三', 1, '2017‐12‐14');

insert stu_info (stu_no, stu_name, birthday)
values ('20171217123', '张三', '2017‐12‐14');

2）插入查询结果

语句格式为
insert into T[(A1, .... ，Ak)] <查询表达式>
其中查询表达式通常是一个select语句。该表达式对查询表达式求值，并将结果元组插入到基本表中。

设存放就餐卡登记信息关系Cardinf具有如下模式：
Cardinf(Card-no, Name, Banlance)
其中属性分别是持卡人编号，Name为持卡人姓名，Balance为卡中余额。假设现为教师办理一个就餐卡，直接使用教师号作为持卡人编号，并预存100元。
insert into Cardinf(Card-no, Name, Banlance)
select Tno, Tname, 100.00
from Teachers;

注意：常量100.00出现在select子句中。这使得查询结果的每个元组的第三列均取常量值100.00。

查询
查询在一个或多个关系（基本表或试图）上进行，其结果是一个关系。

select语句个一般形式为：
select [all | distinct] <选择序列>
from <表引用>,...,<表引用>
[where <选择条件>]
[group by <分组列>,...,<分组列> [having <分组选择条件>]]
[order by <排序列> [asc | desc] ,..., <排序列> [asc | desc]]

select语句包含5个子句，其中最基本的结构是select-from-where，并且select子句和from子句是必需得，其他子句都是可选的。

1. select子句
    select子句相当于关系代数的投影运算，用来表示查询结果的诸列。select后可以使用集合量词all或distinct，缺省时为all。all不删除结果重复行，而distinct将删除结果中的重复行。
    <选择序列>可以是“*”，表示查询结果包含from子句指定的基本表或导出表的所有属性。通常，<选择序列>列举查询结果的每个列。结果列的次序可以任意指定，结果列之间用逗号隔开。每个结果列具有如下格式：
    <值表达式> [[as] <列名>]
    其中，<值表达式>是任意可以求值的表达式；可选短语“[as] <列名>”（as可以省略）用<列名>对列重新命名，缺省时结果列名为<值表达式>。<列名>在select-from-where结构中有效。<值表达式>最常见的形式为：
    [<表名.>]<列名>
    其中，<列名>必须出现在from子句指定的表中。在不会引起混淆（即<列名>只出现在一个表中）时，<列名>前的可选前缀“<表名>.”可以缺省。<表名>是<列名>所在表的名字或别名。


2. from子句
    from子句相当于关系代数的笛卡尔积运算，用来列出查询需要扫描的基本表或导出表。from子句中可以有一个或多个<表引用>，中间用逗号隔开，常见形式是：
    <表名>[[as] <表别名>]
    其中，<表名>是合法的表名；可选短语“as <表别名>”（可省略as）用来对表起别名（在select-from-where结构中有效）。当同一个表在select-from-where结构中重复出现时，使用别名可以很好地区分它们的不同出现。当列名前需要带表名前缀时，使用较短的别名也可以简化语句书写。


3. where子句
    where子句相当于关系代数中的选择运算，<查询条件>是作用与from子句中的表和视图的选择谓词。where子句缺省时等价于where true（即查询条件为恒真条件）。
    基本的select语句的执行相当于：首先求from子句指定的基本表或导出表的笛卡尔积，然后根据where子句的查询条件从中个选择满足查询条件的元组，最后投影到select子句的结果列上，得到查询的回答。


4. 不带where子句的简单查询
    最简单的select语句只包含select和from子句。这种语句只能完成对单个表的投影运算。

    例：查询所有课程信息可以用
    select Cno, Cname, Period, Credit
    from Courses;
    或简单地使用
    select *
    from Courses;
    注意：用“*”表示所有的属性列时，得到的查询表的属性次序将和表定义的属性次序一致。然而，如果用第一种形式，属性的次序不必与表属性的定义次序一致，并且允许只显示我们感兴趣的某些属性。如：
    select Cno, Credit
    from Courses;

    select子句中的列可以是表达式，如下：
    假定当前年份为2017年，并且假设我们定义了一个函数year(d)，它返回date类型的参数d中的年份。下面的语句将显示每位学生的年龄：
    select 2017-year(Birthday) as Age
    from Students;
    as Age（as可以省略）用Age对表达式2017-year(Birthday)重新命名，导致结果为单个属性Age的表。
    SQL允许我们用distinct短语强制删除重复元组。下面的语句将显示所有学生的不同年龄：
    select distinct 2017-year(Birthday) Age
    from Students;


5. 带where子句的查询
    一般地，查询条件是一个布尔表达式。布尔表达式由基本布尔表达式用圆括号和逻辑运算符（not，and，or）构成的表达式。其中，基本布尔表达式可以是逻辑常量（true，false）、比较表达式、between表达式、in表达式、like表达式、NULL表达式、量化表达式、存在表达式、唯一表达式、或匹配表达式。

    1. 比较表达式
        常见形式如下：
        <值表达式1> op <值表达式2>
        其中op是比较运算符（<, <=, >, >=, =, <>或!=），<值表达式1> 和 <值表达式2>都是可求值的表达式。
        eg.
        select distinct Sno
        from SC
        where Grade>60;

    2. between表达式
        between表达式判定一个给定的值是否在给定的闭区间内，常见形式为：
        <值表达式> [not] between <下界> and <上界>
        eg.查询出生年份在1987~1990的学生姓名和专业
        select Sname, Speciality
        from Students
        where year(Birtthday) between 1987 and 1990;

    3. in表达式
        in表达式判定给定的一个元素是否在给定的集合中。常见两种形式有：
        <值表达式> [not] in (<值表达式列表>)
        <元组> | [not] in <子查询>
        eg.查询计算机科学与技术和软件工程专业的学生的学号和姓名
        select Sno, Sname
        from Students
        where Speciality in('计算机科学与技术', '软件工程');

模糊查询
like表达式允许我们表示模糊查询，一般格式是：
<匹配值> [not] like <模式> [escape'<换码字符>']

其中<匹配值>和<模式>都是字符串表达式，它们的值是可以比较的。通常，<匹配值>是属性，<模式>是给定的字符串常量。<模式>中允许使用通配符。有两种通配符：“_”（下划线）可以与任意单个字符匹配，而"%"可以与零个或多个任意字符匹配。escape'<换码字符>'通常是escape'\'。它定义‘\’为转义字符，将紧随其后的一个字符转义。如果<模式>中的_或%紧跟在\之后，则这个_或%就失去了通配符的意义，而取其字面意义。
当<匹配值>与<模式>匹配时，则like表达式的值为真，否则，值为假。

eg.

select Sno, Sname
from Student
where Sname like '李__';   /*有两个下划线，因为一个汉字占两个字符位置*/

select *
from Courses
where Cname like 'C\_%' escape '\';        /* 定义"\"为转义字符，“_" 被转义 */

NULL 查询
SQL允许元组在某些属性上取空值（NULL）。空值代表未知的值，不能与其他值进行比较。NULL表达式允许我们判断给定的值是否为空值。NULL表达式常见的形式如下：

<值表达式> | <子查询> IS [NOT] NULL
通常<值表达式>是属性。

eg.

select Sno, Cno
from SC
where Grade IS NULL;

连接查询
涉及到多个表的查询通常称为连接查询

eg.查询学号为200605098的学生的各科成绩，对每门课显示课程名和成绩。
select Cname, Grade
from SC, Courses
where SC.Cno=Courses.Cno and Sno='200605098';
其中SC.Cno=Courses.Cno称为连接条件，相同于求SC和Courses的自然连接。而Sno='200605098'则是查询条件。当属性只是from子句中一个表的属性时，前缀可以省略。

eg.查询每个学生的平均成绩，并输出平均成绩大于85的学生学号、姓名和平均成绩。
select Students.Sno, Sname, avg(Grade)
from SC, Students
where Students.Sno=SC.Sno
group by Student.Sno, Sname
having avg(Grade)>85;

eg.查询和小李出生年月相同的学生的姓名
select S2.Sname
from Students S1, Students S2
where S1.Birthday=S2.Birthday and
S1.Sname='小李' and
S2.Sname<>'小李';
同一个表名出现两次，需要重命名（省略as）。

嵌套查询
我们将一个查询嵌套在另一个查询中的查询称为嵌套查询，并称前者为子查询（内层查询），后者为父查询（外层查询）。子查询中不能使用order by子句。

嵌套查询可以分为两类：不相关子查询的子查询的条件不依赖与父查询；而相关子查询的子查询的查询条件依赖于父查询。

1. in引出的子查询
    in表达式的第二种形式可以更一般地判定集合成员资格，其形式如下：
    <元组> [not] in <子查询>

    eg.查询和小李在同一个专业学习的女同学的学号的姓名
    select Sno, Sname
    from Students
    where Sex='女' and Speciality in
    (select Speciality
    from Students
    where Sname='小李'
    );
    这是一个不相关的子查询。系统先执行子查询，得到小李所在的专业。如果小李只有一个，则子查询的结果是单个值。此时，可以将“Speciality in”用“Speciality=”替代。

2. 集合的比较引出的子查询
    SQL允许将一个元素与子查询的结果集进行比较。这种量化的比较表达式的常用形式为：
    <值表达式> h all | some | any <子查询>
    其中h是比较运算符（=, <>, !=, <, >, >=, <=）。some和any的含义相同。但现在更多地使用some。当<子查询>的结果为单个值时，all，some，any可以省略。

    eg.查询比软件工程专业都小的其他专业的学生的学号、姓名、专业和出生日期。
    select Sno, Sname, Speciality, Birthday
    from Students
    where Speciality <> '软件工程' and 
    Birthday > all (
    select Birthday
    from Student
    where Speciality='软件工程'
    );

    也可以使用聚集函数实现：
    select Sno, Sname, Speciality, Birthday
    from Students
    where Speciality <> '软件工程' and
    Birthday > (
    select max(Birthday)
    from Students
    where  Speciality='软件工程'
    );


分组
按属性分组，再使用聚集函数
一般形式如下：
group by <分组列> {, <分组列>} [having <分组选择条件>]
其中<分组列>是属性（可以带表名前缀），它所在的表出现在from子句中。可选的having子句是用来过滤掉不满足<分组选择条件>的分组，缺省时等价于having true。<分组选择条件>类似于where子句的查询条件，但其中允许出现聚集函数。
对于group by子句的select语句，select语句中的结果列必须是group by子句中的<分组列>或聚集函数。
带group by子句的select语句的执行效果相当于：首先对from子句中的表计算笛卡尔积，再根据where子句的查询条件从中选择满足查询条件的元组，得到查询的中间结果。然后，暗中group by子句指定的一个或多个列队中间元组进行分组，在这些列上的值相等的元组分为一组；按照having短语中的分组选择条件过滤掉不满足条件的分组。最后，投影到select子句的结果列上，得到查询的回答。

eg.查询每个学生的平均成绩，并输出平均成绩大于85的学生序号和平均成绩
select Sno, avg(Grade)
from SC
group by Sno having avg(Grade)>85;

删除
使用delete语句删除表中的某些记录，语句格式为：
delete from T [where <删除条件>]

其中T通常为基本表，但也可以是某些视图，<删除条件>与select语句中的查询条件类似。
delete语句的功能是从指定的表T中删除满足<删除条件>的所有元组。where子句缺省时，则删除表T中全部元组（剩下一个空表T）。

删除所有学生的记录：
delete from Students;

删除学号为200624010的学生记录可以用：
delete from Students where Sno='200624010';

尽管delete语句只能从一个表删除元组，但是删除条件可以涉及到多个表
例如删除计算机系所有学生的选课记录（SC是学生选课关系表）
我们可以先得到计算机系所有学生的学号
delete from SC
where Sno In
(
select Sno
from Students
where Speciality='计算机');


区分：truncate 、delete与drop
相同点：
1.truncate和不带where子句的delete、以及drop都会删除表内的数据。
2.drop、truncate都是DDL语句(数据定义语言),执行后会自动提交。

不同点：
1. truncate 和 delete 只删除数据不删除表的结构(定义)，而drop 语句将删除表的结构以及被依赖的约束(constrain)、触发器(trigger)、索引(index)。
2. delete 语句是数据库操作语言(dml)，这个操作会放到 rollback segement 中，事务提交之后才生效；如果有相应的 trigger，执行的时候将被触发。
truncate、drop 是数据库定义语言(ddl)，操作立即生效，原数据不放到 rollback segment 中，不能回滚，操作不触发 trigger。
3. 速度：一般来说: drop> truncate > delete
4. 安全性：小心使用 drop 和 truncate，尤其没有备份的时候。
5. delete是DML语句,不会自动提交。drop和truncate都是DDL语句,执行后会自动提交。


修改
使用update语句可以修改表中某些元组指定属性上的值。格式为：
update T
set A1=e1,...,Ak=ek
[where <修改条件>]

其中T通常为基本表，但也可以是某些视图；A1,...Ak是T的属性，而e1,...ek是表达式；<修改条件>与select语句中的查询条件类似
该语句的功能是：修改表T满足<修改条件>的元组。更具体的说，对于表T中没个满足<修改条件>的元组t，求表达式ei的值，并将它赋予元组t的属性Ai。where子句缺省时，则修改表T中全部元组。

update语句只能修改一个表的元组。但是，修改条件中可以包含涉及其他表的子查询。
例如：将微积分课程成绩低于60分的所有学生的微积分课程成绩提高5分。
先得到微积分课程的课程号，再修改微积分成绩
update SC
set Grade=Grade+5
where Grade < 60 and Cno in
(select Cno
from Courses
where Cname='微积分'
);


SQL函数

SQL的函数可以单独使用也可以配合group by(分组)子句使用。单独使用时，聚集函数作用于整个查询结果；而与group by子句配合使用时，聚集函数作用于查询结果的每个分组。聚集函数单独使用时，可以认为整个查询结果形成一个分组。 

SQL的聚集函数有如下形式：

count([all | distinct] *) 或 <聚集函数> ([all | distinct] <值表达式>)
其中[all | distinct]可选，缺省时为all，使用distinct将删除多重集中的重复元素


计数

返回元组中元素的个数
格式：select count(参数) from 表名;
参数可以是栏位（列）的序列号，按照属性定义的次序从零开始，也可以是栏位的名称。最好选择主键作为参数，查询速度快。

eg.
select count(*) from 表名;
select count(0) from 表名;
select count(栏位名) from 表名;

求和函数
将对每个元组中的分组，在某个属性的不同值上求和
    sum(栏位名 or 栏位序号)

查询最大值最小值平均值
查询CS302课程成绩最低分、平均分和最高分
select min(Grade), max(Grade), avg(Grade)
from SC
where Cno='CS302';

查询每个学生的平均成绩，并输出平均成绩大于85的学生序号和平均成绩
select Sno, avg(Grade)
from sc
group by Sno having avg(Grade)>85;

查询并使用逻辑运算
select * 
from user
user where score >= 80 and score <= 90;

数据排序
order by 栏位名 asc；   (升序（default）,默认情况可以不写asc)
order by 栏位名 desc;   (降序) 

查询每个学生CS202课程的成绩，并将查询结果按成绩降序排序
select *
from SC
where Cno='CS202'
order by Grade desc;

查询每位学生的每门课的成绩，并将查询结果按课程号升序、成绩降序排序
select *
from SC
order by Cno, Grader desc;

分页函数
select * from 表名  limit [offset,] rows | rows OFFSET offset

limit子句可以被用于强制 select 语句返回指定的记录数。limit 接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。初始记录行的偏移量是 0(而不是 1)

select * from table limit 5,10;    //检索记录行6-15

//检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为-1：
select * from table limit 95,-1; // 检索记录行 96-last.

//如果只给定一个参数，它表示返回最大的记录行数目： 
SELECT * from table limit 5;     //检索前 5 个记录行
SQL JOIN 

SQL join 用于根据两个或多个表中的列之间的关系，从这些表中查询数据。

Join 和 Key 

有时为了得到完整的结果，我们需要从两个或更多的表中获取结果。我们就需要执行 join。 

数据库中的表可通过键将彼此联系起来。主键（Primary Key）是一个列，在这个列中的每一行的值都是唯一的。在表中，每个主键的值都是唯一的。这样做的目的是在不重复每个表中的所有数据的情况下，把表间的数据交叉捆绑在一起。

LEFT JOIN 

资料来源：SQL LEFT JOIN 关键字 

RIGHT JOIN 

资料来源：SQL RIGHT JOIN 

FULL JOIN 

资料来源：SQL FULL JOIN 关键字