PostgreSQL - 数据库与表格操作

最新推荐文章于 2024-08-25 14:50:02 发布

S_numb

最新推荐文章于 2024-08-25 14:50:02 发布

阅读量1.6k

点赞数

分类专栏： SQL 文章标签： postgresql big data 数据库

本文链接：https://blog.csdn.net/S_numb/article/details/120645812

版权

SQL 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 创建数据库

PostgreSQL 创建数据库可以用以下三种方式：

使用 CREATE DATABASE SQL 语句来创建；
使用 createdb 命令来创建；
使用 pdAdmin 工具；

1.1 CREATE DATABASE 创建数据库

语法：

CREATE DATABASE dbname;

栗子：

postgres=# CREATE DATABASE testdb;

1.2 createdb 命令创建数据库

createdb 是一个 SQL 命令 CREATE DATABASE 的封装。
语法：

createdb [option ...] [dbname [description]]

参数说明：

dbname：要创建的数据库名；
description：关于新创建的数据库相关的说明；
options：参数可选项；

选项	描述
-D tablespace	指定数据库默认表空间。
-e	将 createdb 生成的命令发送到服务端。
-E encoding	指定数据库的编码。
-l locale	指定数据库的语言环境。
-T template	指定创建此数据库的模板。
–help	显示 createdb 命令的帮助信息。
-h host	指定服务器的主机名。
-p port	指定服务器监听的端口，或者 socket 文件。
-U username	连接数据库的用户名。
-w	忽略输入密码。
-W	连接时强制要求输入密码。

使用封装的命令 createdb创建命令时，不能已经登录到 pg 数据库命令行，而需要在数据库安装的 bin 目录下，直接使用命令创建；
栗子：

[10307440@zte.intra@LIN-874286D0CB5 bin]$ createdb -h localhost -p 5432 -U postgres sdtestbd
口令: 
[10307440@zte.intra@LIN-874286D0CB5 bin]$

以上命令表示：使用 postgres 用户登录到主机地址为 localhost，端口号为 5432 的 PostgreSQL 数据库中并创建 sdtestdb 数据库。

2. 选择数据库

使用\l 查看已经存在的数据库：

postgres=# \l
                                     数据库列表
   名称    |  拥有者  | 字元编码 |  校对规则   |    Ctype    |       存取权限        
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | 
 sdtestbd  | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | 
 template0 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 行记录)

使用 \c + 数据库名 进入数据库：

postgres=# \c sdtestbd 
您现在已经连接到数据库 "sdtestbd",用户 "postgres".

3. 删除数据库

PostgreSQL 删除数据库可以用以下三种方式：

使用 DROP DATABASE SQL 语句来删除；
使用 dropdb 命令来删除；
使用 pgAdmin 工具；

3.1 DROP DATABASE 删除数据库

DROP DATABASE 会删除数据库的系统目录项并且删除包含数据的文件目录。
DROP DATABASE 只能由超级管理员或数据库拥有者执行。
DROP DATABASE 命令需要在 PostgreSQL 命令窗口来执行，语法格式如下：

DROP DATABASE [ IF EXISTS ] name

参数说明：
- IF EXISTS：如果数据库不存在则发出提示信息，而不是错误信息。
- name：要删除的数据库的名称。
栗子：

postgres=# DROP DATABASE sdtestbd;
DROP DATABASE
postgres=# \l
                                     数据库列表
   名称    |  拥有者  | 字元编码 |  校对规则   |    Ctype    |       存取权限        
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | 
 template0 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(3 行记录)

3.2 dropdb 命令删除数据库

dropdb 是 DROP DATABASE 的包装器。
dropdb 用于删除 PostgreSQL 数据库。
dropdb 命令只能由超级管理员或数据库拥有者执行。
语法格式：

dropdb [connection-option...] [option...] dbname

参数说明：

dbname：要删除的数据库名。
options：参数可选项，可以是以下值：

选项	描述
-e	显示 dropdb 生成的命令并发送到数据库服务器。
-i	在做删除的工作之前发出一个验证提示。
-V	打印 dropdb 版本并退出。
–if-exists	如果数据库不存在则发出提示信息，而不是错误信息。
–help	显示有关 dropdb 命令的帮助信息。
-h host	指定运行服务器的主机名。
-p port	指定服务器监听的端口，或者 socket 文件。
-U username	连接数据库的用户名。
-w	连接数据库的用户名。
-W	连接时强制要求输入密码。
–maintenance-db=dbname	删除数据库时指定连接的数据库，默认为 postgres，如果它不存在则使用 template1。

跟创建数据库时的命令一样，还是得进入 bin 目录下：

dropdb -h localhost -p 5432 -U postgres runoobdb

4. 创建表格

PostgreSQL 使用 CREATE TABLE 语句来创建数据库表格。
CREATE TABLE 语法格式如下：

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( 一个或多个列 )
);

CREATE TABLE 是一个关键词，用于告诉数据库系统将创建一个数据表。
表名字必需在同一模式中的其它表、序列、索引、视图或外部表名字中唯一。
CREATE TABLE 在当前数据库创建一个新的空白表，该表将由发出此命令的用户所拥有。
表格中的每个字段都会定义数据类型，如下：
栗子：

postgres=# CREATE DATABASE pgtestdb
postgres-# ;
CREATE DATABASE
postgres=# \l
                                     数据库列表
   名称    |  拥有者  | 字元编码 |  校对规则   |    Ctype    |       存取权限        
-----------+----------+----------+-------------+-------------+-----------------------
 pgtestdb  | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | 
 postgres  | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | 
 template0 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | zh_CN.UTF-8 | zh_CN.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 行记录)

postgres=# \c pgtestdb 
您现在已经连接到数据库 "pgtestdb",用户 "postgres".
pgtestdb=# CREATE TABLE COMPANY(
pgtestdb(#   ID    INT     PRIMARY KEY    NOT NULL,
pgtestdb(#   NAME  TEXT    NOT NULL,
pgtestdb(#   ADDRESS    CHAR(50),
pgtestdb(#   SALARY    REAL
pgtestdb(# );
CREATE TABLE

然后使用 \d 查看表是否创建成功：

pgtestdb=# \d
                关联列表
 架构模式 |  名称   |  类型  |  拥有者  
----------+---------+--------+----------
 public   | company | 数据表 | postgres
(1 行记录)

使用 \d tablename 查看表格信息：

pgtestdb=# \d COMPANY
               数据表 "public.company"
  栏位   |     类型      | 校对规则 |  可空的  | 预设 
---------+---------------+----------+----------+------
 id      | integer       |          | not null | 
 name    | text          |          | not null | 
 address | character(50) |          |          | 
 salary  | real          |          |          | 
索引：
    "company_pkey" PRIMARY KEY, btree (id)

即兴，在创建一个表（教程说后续会用）：

pgtestdb=# CREATE TABLE DEPARTMENT(
pgtestdb(#   ID    INT    PRIMARY KEY    NOT NULL,
pgtestdb(#   EDPT  CHAR(50)    NOT NULL,
pgtestdb(#   EMP_ID    INT    NOT NULL
pgtestdb(# );
CREATE TABLE
pgtestdb=# \d
                 关联列表
 架构模式 |    名称    |  类型  |  拥有者  
----------+------------+--------+----------
 public   | company    | 数据表 | postgres
 public   | department | 数据表 | postgres
(2 行记录)

5. 删除表格

PostgreSQL 使用 DROP TABLE 语句来删除表格，包含表格数据、规则、触发器等，所以删除表格要慎重，删除后所有信息就消失了。
语法：

DROP TABLE table_name;

栗子：

pgtestdb=# \d
                 关联列表
 架构模式 |    名称    |  类型  |  拥有者  
----------+------------+--------+----------
 public   | company    | 数据表 | postgres
 public   | department | 数据表 | postgres
(2 行记录)

pgtestdb=# DROP TABLE department;
DROP TABLE
pgtestdb=# \d
                关联列表
 架构模式 |  名称   |  类型  |  拥有者  
----------+---------+--------+----------
 public   | company | 数据表 | postgres
(1 行记录)

6. 模式（SCHEMA）

模式（SCHEMA）可以看着是一个表的集合。
一个模式可以包含：
- 视图、索引、数据类型、函数和操作符等。
相同的对象名称可以被用于不同的模式中而不会出现冲突；
- 例如 schema1 和 myschema 都可以包含名为 mytable 的表；
使用模式的优势：
- 允许多个用户使用一个数据库并且不会互相干扰。
- 将数据库对象组织成逻辑组以便更容易管理。
- 第三方应用的对象可以放在独立的模式中，这样它们就不会与其他对象的名称发生冲突。
模式类似于操作系统层的目录，但是模式不能嵌套。

6.1 语法

可以使用 CREATE SCHEMA 语句来创建模式；
语法格式如下：

CREATE SCHEMA myschema.mytable (
...
);

6.2 实例

在数据库 pgtestdb 下创建模式 testSchema:

pgtestdb=# CREATE SCHEMA testSchema;
CREATE SCHEMA

在模式 testSchema 下创建一个表格：

pgtestdb=# CREATE TABLE testSchema.COMPANY(
pgtestdb(#   ID    INT        NOT NULL,
pgtestdb(#   NAME  VARCHAR(9) NOT NULL,
pgtestdb(#   AGE   INT        NOT NULL,
pgtestdb(#   ADDRESS  CHAR(20),
pgtestdb(#   SALARY   DECIMAL(18, 2),
pgtestdb(#   PRIMARY KEY(ID)
pgtestdb(# );
CREATE TABLE

查看表格：

pgtestdb=# SELECT * FROM testschema.COMPANY
pgtestdb-# ;
 id | name | age | address | salary 
----+------+-----+---------+--------
(0 行记录)

6.3 删除模式

删除一个为空的模式（其中的所有对象已经被删除）：

pgtestdb=# DROP SCHEMA testschema;
错误:  无法删除 模式 testschema 因为有其它对象倚赖它
描述:  表 testschema.company 倚赖于 模式 testschema
提示:  使用 DROP .. CASCADE 把倚赖对象一并删除.

当我们没有删除这张表时，是无法直接删除这个模式的，提示告诉我们可以直接使用命令删除；

pgtestdb=# DROP SCHEMA testschema CASCADE;
注意:  递归删除 表 testschema.company
DROP SCHEMA

7. INSERT INTO 语句

INSERT INTO 语句用于向表中插入新记录。
可以插入一行也可以同时插入多行。
语法：

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

参数说明：
- column1, column2,…columnN 为表中字段名。
- value1, value2, value3,…valueN 为字段对应的值。
在使用 INSERT INTO 语句时，字段列必须和数据值数量相同，且顺序也要对应。
如果我们向表中的所有字段插入值，则可以不需要指定字段，只需要指定插入的值即可：

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

插入后返回值结果说明：

输出信息	描述
INSERT oid 1	只插入一行并且目标表具有 OID的返回信息，那么 oid 是分配给被插入行的 OID。
INSERT 0 #	插入多行返回的信息， # 为插入的行数。

栗子：
在 pgtestdb 数据库中创建表 COMPANY ；

pgtestdb=#  CREATE TABLE COMPANY(
pgtestdb(#   ID        INT      NOT NULL,
pgtestdb(#   NAME      TEXT     NOT NULL,
pgtestdb(#   AGE       INT      NOT NULL,
pgtestdb(#   ADDRESS   CHAR(50) NOT NULL,
pgtestdb(#   SALARY    REAL,
pgtestdb(#   JOIN_DATE DATE,
pgtestdb(#   PRIMARY KEY(ID)
pgtestdb(# );
CREATE TABLE
pgtestdb=# \d company
                数据表 "public.company"
   栏位    |     类型      | 校对规则 |  可空的  | 预设 
-----------+---------------+----------+----------+------
 id        | integer       |          | not null | 
 name      | text          |          | not null | 
 age       | integer       |          | not null | 
 address   | character(50) |          | not null | 
 salary    | real          |          |          | 
 join_date | date          |          |          | 
索引：
    "company_pkey" PRIMARY KEY, btree (id)

在表 COMPANY 中插入以下数据：

pgtestdb=# INSERT INTO COMPANY (ID, NAME, AGE, ADDRESS, SALARY, JOIN_DATE)
pgtestdb-#        VALUES(1, 'Alice', 19, 'California', 19999.00, '2021-07-14');
INSERT 0 1

忽略 SALARY 字段，插入数据：

pgtestdb=# INSERT INTO COMPANY (ID, NAME, AGE, ADDRESS, JOIN_DATE)
pgtestdb-#        VALUES (2, 'Mona', 18, 'Texas', '2021-07-14');
INSERT 0 1

使用默认值 DEFAULT 来对 JOIN_DATE 字段插入：

pgtestdb=# INSERT INTO COMPANY (ID, NAME, AGE, ADDRESS, SALARY, JOIN_DATE)
pgtestdb-#        VALUES (3, 'Gorden', 45, 'WHOCARE', 100.00, DEFAULT);
INSERT 0 1

插入多行：

pgtestdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (4, 'Mark', 25, 'Rich-Mond', 65000.00, '2007-12-13' ), (5, 'David', 27, 'Texas', 85000.00, '2007-12-13');
INSERT 0 2

查询表中的数据：

pgtestdb=# SELECT * FROM COMPANY;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  2 | Mona   |  18 | Texas                                              |        | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(5 行记录)

8. SELECT

SELECT 语句用于从数据库中选取数据。
结果被存储在一个结果表中，称为结果集。
语法：

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

参数说明：
- column1, column2,…columnN 为表中字段名。
- table_name 为表名。
读取表中的所有数据：SELECT * FROM table_name;
指定字段来读取表中的数据：

pgtestdb=# SELECT ID, NAME, AGE FROM COMPANY;
 id |  name  | age 
----+--------+-----
  1 | Alice  |  19
  2 | Mona   |  18
  3 | Gorden |  45
  4 | Mark   |  25
  5 | David  |  27
(5 行记录)

9. 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。
PostgreSQL 运算符是一个保留关键字或字符，一般用在 WHERE 语句中，作为过滤条件。
常见的运算符有：
- 算术运算符；
- 比较运算符；
- 逻辑运算符；
- 按位运算符；

9.1 算术运算符

假设变量 a 为 2，变量 b 为 3，则：

运算符	描述	实例
`+`	加	a + b 结果为 5
`-`	减	a - b 结果为 -1
`*`	乘	a * b 结果为 6
`/`	除	b / a 结果为 1
`%`	模（取余）	b % a 结果为 1
`^`	指数	a ^ b 结果为 8
`\|/`	平方根	`\|/ 25.0 结果为 5`
`\|\|/`	立方根	`\|\|/ 27.0 结果为 3`
`!`	阶乘	5 ! 结果为 120
`!!`	阶乘（前缀操作符）	!! 5 结果为 120

9.2 比较运算符

假设变量 a 为 10，变量 b 为 20，则：

运算符	描述	实例
=	等于	(a = b) 为 false
!=	不等于	(a != b) 为 true
<>	不等于	(a <> b) 为 true
>	大于	(a > b) 为 false
<	小于	(a < b) 为 true
>=	大于等于	(a >= b) 为 false
<=	小于等于	(a <= b) 为 true

9.3 逻辑运算符

运算符	描述
`AND`	逻辑与运算符。如果两个操作数都非零，则条件为真。
`NOT`	逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。
`OR`	逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。

SQL 使用三值的逻辑系统，包括 true、false 和 null，null 表示"未知"。

a	b	NOT a	a AND b	a OR b
TRUE	TRUE	FALSE	TRUE	TRUE
TRUE	FALSE		FALSE	TRUE
TRUE	NULL		NULL	TRUE
FALSE	FALSE	TRUE	FALSE	FALSE
FALSE	NULL		FALSE	NULL
NULL	NULL	NULL	NULL	NULL

9.4 位运算符

位运算符作用于位，并逐位执行操作。
&、 | 和 ^ 的真值表如下所示：

p	q	p&q	`p \| q`
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
- A = 0011 1100
- B = 0000 1101
- A&B = 0000 1100
- A|B = 0011 1101
- A^B = 0011 0001
- ~A = 1100 0011

10. 表达式

表达式是由一个或多个的值、运算符、PostgresSQL 函数组成的。
PostgreSQL 表达式类似一个公式，用来查找数据库中指定条件的结果集。

10.1 语法

SELECT 语句的语法格式如下：

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

10.2 布尔表达式

布尔表达式是根据一个指定条件来读取数据：

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

栗子：

pgtestdb=# SELECT * FROM COMPANY;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  2 | Mona   |  18 | Texas                                              |        | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(5 行记录)

pgtestdb=# SELECT * FROM COMPANY WHERE SALARY < 20000;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
(2 行记录)

10.3 数字表达式

数字表达式常用于查询语句中的数学运算：

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

栗子：

pgtestdb=# SELECT (99 + 1) AS RESULT;
 result 
--------
    100
(1 行记录)

此外 PostgreSQL 还内置了一些数学函数，如：
- avg() ：返回一个表达式的平均值；
- sum() ：返回指定字段的总和；
- count() ：返回查询的记录总数；
以下实例查询 COMPANY 表的记录总数：

pgtestdb=# SELECT COUNT(*) AS "RECORDS" FROM COMPANY;
 RECORDS 
---------
       5
(1 行记录)

10.4 日期表达式

日期表达式返回当前系统的日期和时间，可用于各种数据操作，以下实例查询当前时间：

pgtestdb=# SELECT CURRENT_TIMESTAMP;
       current_timestamp       
-------------------------------
 2021-09-30 16:37:59.760127+08
(1 行记录)

11. WHERE 子句

在 PostgreSQL 中，当需要根据指定条件从单张表或者多张表中查询数据时，就可以在 SELECT 语句中添加 WHERE 子句，从而过滤掉不需要数据。
WHERE 子句不仅可以用于 SELECT 语句中，同时也可以用于 UPDATE，DELETE 等等语句中。

11.1 语法

以下是 SELECT 语句中使用 WHERE 子句从数据库中读取数据的通用语法：

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

可以在 WHERE 子句中使用比较运算符或逻辑运算符，例如 >, <, =, LIKE, NOT 等。

11.2 AND

找出 AGE(年龄) 字段大于等于 20，并且 SALARY(薪资) 字段大于等于 65000 的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE >= 20 AND SALARY >= 65000;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
(2 行记录)

11.3 OR

找出 AGE(年龄) 字段大于等于 20，或者 SALARY(薪资) 字段大于等于 65000 的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE >= 20 OR SALARY >= 65000;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(3 行记录)

11.4 NOT NULL

在公司表中找出 SALARY(薪资) 字段不为空的记录：

pgtestdb=# SELECT * FROM COMPANY WHERE SALARY IS NOT NULL;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(4 行记录)

11.5 LIKE

在 COMPANY 表中找出 NAME(名字) 字段中以 Al 开头的的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE NAME LIKE "Al%";
错误:  字段 "Al%" 不存在
第1行SELECT * FROM COMPANY WHERE NAME LIKE "Al%";
                                           ^
pgtestdb=# SELECT * FROM COMPANY WHERE NAME LIKE 'Al%';
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
(1 行记录)

从上边看出，不可以使用双引号；

11.6 IN

以下 SELECT 语句列出了 AGE(年龄) 字段为 18 或 25 的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE IN (18, 25);
 id | name | age |                      address                       | salary | join_date  
----+------+-----+----------------------------------------------------+--------+------------
  2 | Mona |  18 | Texas                                              |        | 2021-07-14
  4 | Mark |  25 | Rich-Mond                                          |  65000 | 2007-12-13
(2 行记录)

11.7 NOT IN

以下 SELECT 语句列出了 AGE(年龄) 字段不为 18 或 25 的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE NOT IN (18, 25);
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(3 行记录)

11.8 BETWEEN

以下 SELECT 语句列出了 AGE(年龄) 字段在 18 到 25 的数据：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE BETWEEN 18 AND 25;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  2 | Mona  |  18 | Texas                                              |        | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
(3 行记录)

11.9 子查询

以下的 SELECT 语句使用了 SQL 的子查询，子查询语句中读取 SALARY(薪资) 字段大于 65000 的数据，然后通过 EXISTS 运算符判断它是否返回行，如果有返回行则读取所有的 AGE(年龄) 字段。

pgtestdb=# SELECT AGE FROM COMPANY
pgtestdb-#        WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
 age 
-----
  19
  18
  45
  25
  27
(5 行记录)

12. UPDATE 语句

可以用 UPDATE 来更新在 PostgreSQL 数据库中的数据；
语法：

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

栗子：

pgtestdb=# SELECT * FROM COMPANY;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  2 | Mona   |  18 | Texas                                              |        | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
(5 行记录)

pgtestdb=# UPDATE COMPANY SET SALARY = 19991 WHERE ID = 2;
UPDATE 1
pgtestdb=# SELECT * FROM COMPANY;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
  2 | Mona   |  18 | Texas                                              |  19991 | 2021-07-14
(5 行记录)

13. DELETE 语句

使用 DELETE 语句来删除 PostgreSQL 表中的数据。
语法：

DELETE FROM table_name WHERE [condition];

如果没有指定 WHERE 子句，PostgreSQL 表中的所有记录将被删除。
一般我们需要在 WHERE 子句中指定条件来删除对应的记录，条件语句可以使用 AND 或 OR 运算符来指定一个或多个。

pgtestdb=# SELECT * FROM COMPANY;
 id |  name  | age |                      address                       | salary | join_date  
----+--------+-----+----------------------------------------------------+--------+------------
  1 | Alice  |  19 | California                                         |  19999 | 2021-07-14
  3 | Gorden |  45 | WHOCARE                                            |    100 | 
  4 | Mark   |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David  |  27 | Texas                                              |  85000 | 2007-12-13
  2 | Mona   |  18 | Texas                                              |  19991 | 2021-07-14
(5 行记录)

pgtestdb=# DELETE FROM COMPANY WHERE ID = 3;
DELETE 1
pgtestdb=# SELECT * FROM COMPANY;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
  2 | Mona  |  18 | Texas                                              |  19991 | 2021-07-14
(4 行记录)

14. LIKE 子句

在 PostgreSQL 数据库中，我们如果要获取包含某些字符的数据，可以使用 LIKE 子句。
在 LIKE 子句中，通常与通配符结合使用，通配符表示任意字符，在 PostgreSQL 中，主要有以下两种通配符：
- 百分号 %；
- 下划线 _；
如果没有使用以上两种通配符，LIKE 子句和等号 = 得到的结果是一样的。
以下是使用 LIKE 子句搭配百分号 % 和下划线 _ 从数据库中获取数据的通用语法：

SELECT FROM table_name WHERE column LIKE 'XXXX%';
或者
SELECT FROM table_name WHERE column LIKE '%XXXX%';
或者
SELECT FROM table_name WHERE column LIKE 'XXXX_';
或者
SELECT FROM table_name WHERE column LIKE '_XXXX';
或者
SELECT FROM table_name WHERE column LIKE '_XXXX_';

栗子：

pgtestdb=# SELECT * FROM COMPANY WHERE AGE::text LIKE '2%';
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
(2 行记录)

其中：
- ::作用：将一种类型的常量转化成指定类型的常量；

15. LIMIT 子句

PostgreSQL 中的 limit 子句用于限制 SELECT 语句中查询的数据的数量。
带有 LIMIT 子句的 SELECT 语句的基本语法如下：

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

下面是 LIMIT 子句与 OFFSET 子句一起使用时的语法：

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows] OFFSET [row num]

查看 COMPANY 表：

pgtestdb=# SELECT * FROM COMPANY;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
  2 | Mona  |  18 | Texas                                              |  19991 | 2021-07-14
(4 行记录)

读取 2 条数据：

pgtestdb=# SELECT * FROM COMPANY LIMIT 2;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
(2 行记录)

从第二位开始提取 2 个记录：

pgtestdb=# SELECT * FROM COMPANY LIMIT 2 OFFSET 1;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
(2 行记录)

16. ORDER BY 语句

ORDER BY 用于对一列或者多列数据进行升序（ASC）或者降序（DESC）排列。
语法：

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

查看 COMPANY 中的内容：

pgtestdb=# SELECT * FROM COMPANY
pgtestdb-# ;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
  2 | Mona  |  18 | Texas                                              |  19991 | 2021-07-14
(4 行记录)

通过 ORDER BY 对 AGE 字段进行升序排列：

pgtestdb=# SELECT * FROM COMPANY ORDER BY AGE ASC;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  2 | Mona  |  18 | Texas                                              |  19991 | 2021-07-14
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
(4 行记录)

通过 ORDER BY 对 NAME 字段进行降序排列：

pgtestdb=# SELECT * FROM COMPANY ORDER BY NAME DESC;
 id | name  | age |                      address                       | salary | join_date  
----+-------+-----+----------------------------------------------------+--------+------------
  2 | Mona  |  18 | Texas                                              |  19991 | 2021-07-14
  4 | Mark  |  25 | Rich-Mond                                          |  65000 | 2007-12-13
  5 | David |  27 | Texas                                              |  85000 | 2007-12-13
  1 | Alice |  19 | California                                         |  19999 | 2021-07-14
(4 行记录)

17. GROUP BY 语句

GROUP BY 语句和 SELECT 语句一起使用，用来对相同的数据进行分组。
GROUP BY 在一个 SELECT 语句中，放在 WHRER 子句的后面，ORDER BY 子句的前面。
语法：

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

创建新的 COMPANY 表：

pgtestdb=# SELECT * FROM COMPANY;
 id | name  | age |                      address                       | salary 
----+-------+-----+----------------------------------------------------+--------
  1 | Paul  |  32 | California                                         |  20000
  2 | Allen |  25 | Texas                                              |  15000
  3 | Teddy |  23 | Norway                                             |  20000
  4 | Mark  |  25 | Rich-Mond                                          |  15000
  5 | David |  27 | Texas                                              |  15000
  6 | Kim   |  22 | South-Hall                                         |  45000
(6 行记录)

根据 NAME 字段值进行分组，找出每个人的工资总额：

pgtestdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;
 name  |  sum  
-------+-------
 Teddy | 20000
 David | 15000
 Paul  | 20000
 Kim   | 45000
 Mark  | 15000
 Allen | 15000
(6 行记录)

其实，这个就是按照人来将工资综合求和（聚合函数 SUM）；
看不懂没关系，再来一个，通过聚合函数 COUNT 来统计一下不同工资的人数；

pgtestdb=# SELECT SALARY, COUNT(*) FROM COMPANY GROUP BY SALARY;
 salary | count 
--------+-------
  20000 |     2
  45000 |     1
  15000 |     3
(3 行记录)

将 ORDER BY 和 GROUO BY 一起使用：

pgtestdb=# SELECT SALARY, COUNT(*) FROM COMPANY GROUP BY SALARY ORDER BY SALARY DESC;
 salary | count 
--------+-------
  45000 |     1
  20000 |     2
  15000 |     3
(3 行记录)

18. WITH 语句

WITH 子句提供了一种编写辅助语句的方法，以便在更大的查询中使用。
WITH 子句有助于将复杂的大型查询分解为更简单的表单，便于阅读。
这些语句通常称为通用表表达式（Common Table Express， CTE），也可以当做一个为查询而存在的临时表。
WITH 子句是在多次执行子查询时特别有用，允许我们在查询中通过它的名称(可能是多次)引用它。
WITH 子句在使用前必须先定义。
语法：

WITH
   name_for_summary_data AS (
      SELECT Statement)
   SELECT columns
   FROM name_for_summary_data
   WHERE conditions <=> (
      SELECT column
      FROM name_for_summary_data)
   [ORDER BY columns]

name_for_summary_data：是 WITH 子句的名称；
name_for_summary_data 可以与现有的表名相同，并且具有优先级。
实例没看懂，感觉像是将某一部分功能提出来了一个函数，有兴趣的参考菜鸟教程：WITH 子句

19. HAVING 子句

HAVING 子句可以让我们筛选分组后的各组数据。
WHERE 子句在所选列上设置条件，而 HAVING 子句则在由 GROUP BY 子句创建的分组上设置条件。
HAVING 子句必须放置于 GROUP BY 子句后面，ORDER BY 子句前面，下面是 HAVING 子句在 SELECT 语句中基础语法：
语法：

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

根据工资字段进行分组，并且统计工资数少于 18000 的人数：

pgtestdb=# SELECT SALARY, COUNT(*) FROM COMPANY GROUP BY SALARY HAVING SALARY < 18000;
 salary | count 
--------+-------
  15000 |     3
(1 行记录)

20. DISTINCT 关键字

DISTINCT 关键字与 SELECT 语句一起使用，用于去除重复记录，只获取唯一的记录。
语法：

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

查看表 COMPANY，发现并没有重复数据，顺便在里边添加两条重复数据；

pgtestdb=# SELECT * FROM COMPANY;
 id | name  | age |                      address                       | salary 
----+-------+-----+----------------------------------------------------+--------
  1 | Paul  |  32 | California                                         |  20000
  2 | Allen |  25 | Texas                                              |  15000
  3 | Teddy |  23 | Norway                                             |  20000
  4 | Mark  |  25 | Rich-Mond                                          |  15000
  5 | David |  27 | Texas                                              |  15000
  6 | Kim   |  22 | South-Hall                                         |  45000
(6 行记录)

pgtestdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
pgtestdb-# VALUES (8, 'Paul', 32, 'California', 20000.00 );
INSERT 0 1
pgtestdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
pgtestdb-# VALUES (9, 'Allen', 25, 'Texas', 15000.00 );
INSERT 0 1
pgtestdb=# SELECT * FROM COMPANY;
 id | name  | age |                      address                       | salary 
----+-------+-----+----------------------------------------------------+--------
  1 | Paul  |  32 | California                                         |  20000
  2 | Allen |  25 | Texas                                              |  15000
  3 | Teddy |  23 | Norway                                             |  20000
  4 | Mark  |  25 | Rich-Mond                                          |  15000
  5 | David |  27 | Texas                                              |  15000
  6 | Kim   |  22 | South-Hall                                         |  45000
  8 | Paul  |  32 | California                                         |  20000
  9 | Allen |  25 | Texas                                              |  15000
(8 行记录)

找出 COMPANY 表中的所有 NAME：

pgtestdb=# SELECT NAME FROM COMPANY;
 name  
-------
 Paul
 Allen
 Teddy
 Mark
 David
 Kim
 Paul
 Allen
(8 行记录)

在 SELECT 语句中使用 DISTINCT 子句：

pgtestdb=# SELECT DISTINCT NAME FROM COMPANY;
 name  
-------
 Teddy
 David
 Paul
 Kim
 Mark
 Allen
(6 行记录)