一、INSERT INTO 语句

PostgreSQL INSERT INTO 语句用于向表中插入新记录。

我们可以插入一行也可以同时插入多行。

1.1 语法

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);

下表列出执行插入后返回结果的说明：

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

1.1.1 实例

在 runoobdb 数据库中创建 COMPANY 表：

runoobdb=# CREATE TABLE COMPANY(ID INT PRIMARY KEY     NOT NULL,NAME           TEXT    NOT NULL,AGE            INT     NOT NULL,ADDRESS        CHAR(50),SALARY         REAL,JOIN_DATE      DATE
);

在 COMPANY 表中插入以下数据：

runoobdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (1, 'Paul', 32, 'California', 20000.00,'2001-07-13');
INSERT 0 1

以下插入语句忽略 SALARY 字段：

runoobdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,JOIN_DATE) VALUES (2, 'Allen', 25, 'Texas', '2007-12-13');
INSERT 0 1

以下插入语句 JOIN_DATE 字段使用 DEFAULT 子句来设置默认值，而不是指定值：

runoobdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (3, 'Teddy', 23, 'Norway', 20000.00, DEFAULT );
INSERT 0 1

以下实例插入多行：

runoobdb=# 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

使用 SELECT 语句查询表格数据：

runoobdb=# SELECT * FROM company;ID        NAME        AGE        ADDRESS     SALARY   JOIN_DATE
----      ----------  -----      ----------  -------      --------
1         Paul        32         California  20000.0      2001-07-13
2         Allen       25         Texas                    2007-12-13
3         Teddy       23         Norway      20000.0
4         Mark        25         Rich-Mond   65000.0      2007-12-13
5         David       27         Texas       85000.0      2007-12-13

二、SELECT 语句

PostgreSQL SELECT 语句用于从数据库中选取数据。

结果被存储在一个结果表中，称为结果集。

2.1 语法

SELECT 语句语法格式如下：

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

• column1, column2,…columnN 为表中字段名。
• table_name 为表名。

如果我们想读取表中的所有数据可以使用以下 SQL 语句：

SELECT * FROM table_name;

在上一章节 INSERT INTO 语句 中，我们已经向表 company 插入了一些数据，使用 * 号可以读取该表的所有数据：

runoobdb=# SELECT * FROM company;ID        NAME        AGE        ADDRESS     SALARY   JOIN_DATE
----      ----------  -----      ----------  -------      --------
1         Paul        32         California  20000.0      2001-07-13
2         Allen       25         Texas                    2007-12-13
3         Teddy       23         Norway      20000.0
4         Mark        25         Rich-Mond   65000.0      2007-12-13
5         David       27         Texas       85000.0      2007-12-13

我们也可以读取指定字段 ID 和 NAME：

runoobdb=# SELECT ID,NAME FROM company;id | name
----+-------1 | Paul2 | Allen3 | Teddy4 | Mark5 | David
(5 rows)

三、运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。

PostgreSQL 运算符是一个保留关键字或字符，一般用在 WHERE 语句中，作为过滤条件。

常见的运算符有：

• 算术运算符
• 比较运算符
• 逻辑运算符
• 按位运算符

---

3.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

3.1.1 实例

runoobdb=# select 2+3;?column?
----------5
(1 row)runoobdb=# select 2*3;?column?
----------6
(1 row)runoobdb=# select 10/5;?column?
----------2
(1 row)runoobdb=# select 12%5;?column?
----------2
(1 row)runoobdb=# select 2^3;?column?
----------8
(1 row)runoobdb=# select |/ 25.0;?column?
----------5
(1 row)runoobdb=# select ||/ 27.0;?column?
----------3
(1 row)runoobdb=# select 5 !;?column?
----------120
(1 row)runoobdb=# select !!5;?column?
----------120
(1 row)

---

3.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。

3.2.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb=# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

读取 SALARY 字段大于 50000 的数据：

runoobdb=# SELECT * FROM COMPANY WHERE SALARY > 50000;id | name  | age |address    | salary
----+-------+-----+-----------+--------4 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  85000
(2 rows)

读取 SALARY 字段等于 20000 的数据：

runoobdb=#  SELECT * FROM COMPANY WHERE SALARY = 20000;id | name  | age |  address    | salary----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200003 | Teddy |  23 | Norway      |  20000
(2 rows)

读取 SALARY 字段不等于 20000 的数据：

runoobdb=#  SELECT * FROM COMPANY WHERE SALARY != 20000;id | name  | age |  address    | salary
----+-------+-----+-------------+--------2 | Allen |  25 | Texas       |  150004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  450007 | James |  24 | Houston     |  10000
(5 rows)runoobdb=# SELECT * FROM COMPANY WHERE SALARY <> 20000;id | name  | age | address    | salary
----+-------+-----+------------+--------2 | Allen |  25 | Texas      |  150004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  850006 | Kim   |  22 | South-Hall |  450007 | James |  24 | Houston    |  10000
(5 rows)

读取 SALARY 字段大于等于 65000 的数据：

runoobdb=# SELECT * FROM COMPANY WHERE SALARY >= 65000;id | name  | age |  address  | salary
----+-------+-----+-----------+--------4 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  85000
(2 rows)

---

3.3 逻辑运算符

PostgreSQL 逻辑运算符有以下几种：

序号	运算符 & 描述
1	AND 逻辑与运算符。如果两个操作数都非零，则条件为真。 PostgresSQL 中的 WHERE 语句可以用 AND 包含多个过滤条件。
2	NOT 逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 PostgresSQL 有 NOT EXISTS, NOT BETWEEN, NOT IN 等运算符。
3	OR 逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 PostgresSQL 中的 WHERE 语句可以用 OR 包含多个过滤条件。

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

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

a	NOT a
TRUE	FALSE
FALSE	TRUE
NULL	NULL

3.3.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb=# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

读取 AGE 字段大于等于 25 且 SALARY 字段大于等于 6500 的数据：

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 6500;id | name  | age |                      address                  | salary
----+-------+-----+-----------------------------------------------+--------1 | Paul  |  32 | California                                    |  200002 | Allen |  25 | Texas                                         |  150004 | Mark  |  25 | Rich-Mond                                     |  650005 | David |  27 | Texas                                         |  85000
(4 rows)

读取 AGE 字段大于等于 25 或 SALARY 字段大于 6500 的数据：

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 6500;id | name  | age |  address    | salary
----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200002 | Allen |  25 | Texas       |  150003 | Teddy |  23 | Norway      |  200004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  450007 | James |  24 | Houston     |  100008 | Paul  |  24 | Houston     |  200009 | James |  44 | Norway      |   500010 | James |  45 | Texas       |   5000
(10 rows)

读取 SALARY 字段不为 NULL 的数据：

runoobdb=#  SELECT * FROM COMPANY WHERE SALARY IS NOT NULL;id | name  | age |  address    | salary
----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200002 | Allen |  25 | Texas       |  150003 | Teddy |  23 | Norway      |  200004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  450007 | James |  24 | Houston     |  100008 | Paul  |  24 | Houston     |  200009 | James |  44 | Norway      |   500010 | James |  45 | Texas       |   5000
(10 rows)

---

3.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

下表显示了 PostgreSQL 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符	描述	实例
&	按位与操作，按二进制位进行"与"运算。运算规则： 0&0=0; 0&1=0; 1&0=0; 1&1=1;	(A & B) 将得到 12，即为 0000 1100
|	按位或运算符，按二进制位进行"或"运算。运算规则： 0|0=0; 0|1=1; 1|0=1; 1|1=1;	(A | B) 将得到 61，即为 0011 1101
#	异或运算符，按二进制位进行"异或"运算。运算规则： 0#0=0; 0#1=1; 1#0=1; 1#1=0;	(A # B) 将得到 49，即为 0011 0001
~	取反运算符，按二进制位进行"取反"运算。运算规则： ~1=0; ~0=1;	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。	A >> 2 将得到 15，即为 0000 1111

3.4.1 实例

runoobdb=# select 60 | 13;?column?
----------61
(1 row)runoobdb=# select 60 & 13;?column?
----------12
(1 row)runoobdb=#  select  (~60);?column?
-----------61
(1 row)runoobdb=# select  (60 << 2);?column?
----------240
(1 row)runoobdb=# select  (60 >> 2);?column?
----------15
(1 row)runoobdb=#  select 60 # 13;?column?
----------49
(1 row)

四、表达式

表达式是由一个或多个的值、运算符、PostgresSQL 函数组成的。

PostgreSQL 表达式类似一个公式，我们可以将其应用在查询语句中，用来查找数据库中指定条件的结果集。

4.1 语法

SELECT 语句的语法格式如下：

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

PostgreSQL 的表达式可以有不同类型，我们接下来会讲到。

4.2 布尔表达式

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

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

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下使用了布尔表达式（SALARY=10000）来查询数据：

runoobdb=# SELECT * FROM COMPANY WHERE SALARY = 10000;id | name  | age | address  | salary
----+-------+-----+----------+--------7 | James |  24 | Houston  |  10000
(1 row)

4.3 数字表达式

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

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

numerical_expression 是一个数学运算表达式，实例如下：

runoobdb=# SELECT (17 + 6) AS ADDITION ;addition
----------23
(1 row)

此外 PostgreSQL 还内置了一些数学函数，如：

• avg() ： 返回一个表达式的平均值
• sum() ： 返回指定字段的总和
• count() ： 返回查询的记录总数

以下实例查询 COMPANY 表的记录总数：

runoobdb=# SELECT COUNT(*) AS "RECORDS" FROM COMPANY;RECORDS
---------7
(1 row)

4.4 日期表达式

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

runoobdb=# SELECT CURRENT_TIMESTAMP;current_timestamp
-------------------------------2019-06-13 10:49:06.419243+08
(1 row)

五、WHERE 子句

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

WHERE 子句不仅可以用于 SELECT 语句中，同时也可以用于 UPDATE，DELETE 等等语句中。

5.1 语法

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

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

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

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下几个实例我们使用逻辑运算符来读取表中的数据。

5.2 AND

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;id | name  | age |  address   | salary
----+-------+-----+------------+--------4 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  85000
(2 rows)

5.3 OR

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;
id | name  | age | address     | salary
----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200002 | Allen |  25 | Texas       |  150004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  85000
(4 rows)

5.4 NOT NULL

在公司表中找出 AGE(年龄) 字段不为空的记录：

runoobdb=#  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;id | name  | age | address    | salary----+-------+-----+------------+--------1 | Paul  |  32 | California |  200002 | Allen |  25 | Texas      |  150003 | Teddy |  23 | Norway     |  200004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  850006 | Kim   |  22 | South-Hall |  450007 | James |  24 | Houston    |  10000
(7 rows)

5.5 LIKE

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

runoobdb=# SELECT * FROM COMPANY WHERE NAME LIKE 'Pa%';
id | name | age |address    | salary
----+------+-----+-----------+--------1 | Paul |  32 | California|  20000

5.6 IN

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );id | name  | age | address    | salary
----+-------+-----+------------+--------2 | Allen |  25 | Texas      |  150004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  85000
(3 rows)

5.7 NOT IN

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );id | name  | age | address    | salary
----+-------+-----+------------+--------1 | Paul  |  32 | California |  200003 | Teddy |  23 | Norway     |  200006 | Kim   |  22 | South-Hall |  450007 | James |  24 | Houston    |  10000
(4 rows)

5.8 BETWEEN

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;id | name  | age | address    | salary
----+-------+-----+------------+--------2 | Allen |  25 | Texas      |  150004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  85000
(3 rows)

5.9 子查询

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

runoobdb=# SELECT AGE FROM COMPANYWHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);age
-----32252325272224
(7 rows)

以下的 SELECT 语句同样使用了 SQL 的子查询，子查询语句中读取 SALARY(薪资) 字段大于 65000 的 AGE(年龄) 字段数据，然后用 > 运算符查询大于该 AGE(年龄) 字段数据：

runoobdb=# SELECT * FROM COMPANYWHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);id | name | age | address    | salary
----+------+-----+------------+--------1 | Paul |  32 | California |  20000

六、AND & OR 运算符

在 PostgreSQL 中，AND 和 OR 也叫连接运算符，在查询数据时用于缩小查询范围，我们可以用 AND 或者 OR 指定一个或多个查询条件。

6.1 AND

AND 运算符表示一个或者多个条件必须同时成立。

在 WHERE 子句中，AND 的使用语法如下：

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

6.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下实例读取 AGE 字段大于 25 且 SALARY 字段大于等于 65000 的所有记录：

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;id | name  | age | address    | salary
----+-------+-----+------------+--------4 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  85000
(2 rows)

6.2 OR

OR 运算符表示多个条件中只需满足其中任意一个即可。

在 WHERE 子句中，OR 的使用语法如下：

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

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下实例读取 AGE 字段大于等于 25 或 SALARY 字段大于等于 65000 的所有记录：

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;id | name  | age | address    | salary
----+-------+-----+------------+--------1 | Paul  |  32 | California |  200002 | Allen |  25 | Texas      |  150004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  85000
(4 rows)

七、UPDATE 语句

如果我们要更新在 PostgreSQL 数据库中的数据，我们可以用 UPDATE 来操作。

7.1 语法

以下是 UPDATE 语句修改数据的通用 SQL 语法：

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

• 我们可以同时更新一个或者多个字段。
• 我们可以在 WHERE 子句中指定任何条件。

7.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下实例将更新 COMPANY 表中 id 为 3 的 salary 字段值：

runoobdb=# UPDATE COMPANY SET SALARY = 15000 WHERE ID = 3;

得到结果如下：

id | name  | age | address    | salary
----+-------+-----+------------+--------1 | Paul  |  32 | California |  200002 | Allen |  25 | Texas      |  150004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  850006 | Kim   |  22 | South-Hall |  450007 | James |  24 | Houston    |  100003 | Teddy |  23 | Norway     |  15000

从结果上看，COMPANY 表中的 id 为 3 的 salary 字段值已被修改。

以下实例将同时更新 salary 字段和 address 字段的值：

runoobdb=# UPDATE COMPANY SET ADDRESS = 'Texas', SALARY=20000;

得到结果如下：

id | name  | age | address | salary
----+-------+-----+---------+--------1 | Paul  |  32 | Texas   |  200002 | Allen |  25 | Texas   |  200004 | Mark  |  25 | Texas   |  200005 | David |  27 | Texas   |  200006 | Kim   |  22 | Texas   |  200007 | James |  24 | Texas   |  200003 | Teddy |  23 | Texas   |  20000
(7 rows)

八、DELETE 语句

你可以使用 DELETE 语句来删除 PostgreSQL 表中的数据。

8.1 语法

以下是 DELETE 语句删除数据的通用语法：

DELETE FROM table_name WHERE [condition];

如果没有指定 WHERE 子句，PostgreSQL 表中的所有记录将被删除。

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

8.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

以下 SQL 语句将删除 ID 为 2 的数据：

runoobdb=# DELETE FROM COMPANY WHERE ID = 2;

得到结果如下：

 id | name  | age | address     | salary
----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200003 | Teddy |  23 | Norway      |  200004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  450007 | James |  24 | Houston     |  10000
(6 rows)

从上面结果可以看出，id 为 2 的数据已被删除。

以下语句将删除整张 COMPANY 表：

DELETE FROM COMPANY;

九、LIKE 子句

在 PostgreSQL 数据库中，我们如果要获取包含某些字符的数据，可以使用 LIKE 子句。

在 LIKE 子句中，通常与通配符结合使用，通配符表示任意字符，在 PostgreSQL 中，主要有以下两种通配符：

• 百分号 %
• 下划线 _

如果没有使用以上两种通配符，LIKE 子句和等号 = 得到的结果是一样的。

9.1 语法

以下是使用 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_';

你可以在 WHERE 子句中指定任何条件。

你可以使用 AND 或者 OR 指定一个或多个条件。

XXXX 可以是任何数字或者字符。

9.1.1 实例

下面是 LIKE 语句中演示了 % 和 _ 的一些差别:

实例	描述
WHERE SALARY::text LIKE ‘200%’	找出 SALARY 字段中以 200 开头的数据。
WHERE SALARY::text LIKE ‘%200%’	找出 SALARY 字段中含有 200 字符的数据。
WHERE SALARY::text LIKE ‘_00%’	找出 SALARY 字段中在第二和第三个位置上有 00 的数据。
WHERE SALARY::text LIKE ‘2 % %’	找出 SALARY 字段中以 2 开头的字符长度大于 3 的数据。
WHERE SALARY::text LIKE ‘%2’	找出 SALARY 字段中以 2 结尾的数据
WHERE SALARY::text LIKE ‘_2%3’	找出 SALARY 字段中 2 在第二个位置上并且以 3 结尾的数据
WHERE SALARY::text LIKE ‘2___3’	找出 SALARY 字段中以 2 开头，3 结尾并且是 5 位数的数据

在 PostgreSQL 中，LIKE 子句是只能用于对字符进行比较，因此在上面例子中，我们要将整型数据类型转化为字符串数据类型。

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

下面实例将找出 AGE 以 2 开头的数据：

runoobdb=# SELECT * FROM COMPANY WHERE AGE::text LIKE '2%';

得到以下结果：

id | name  | age | address     | salary
----+-------+-----+-------------+--------2 | Allen |  25 | Texas       |  150003 | Teddy |  23 | Norway      |  200004 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  450007 | James |  24 | Houston     |  100008 | Paul  |  24 | Houston     |  20000
(7 rows)

下面实例将找出 address 字段中含有 - 字符的数据：

runoobdb=# SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

得到结果如下：

id | name | age |                      address              | salary
----+------+-----+-------------------------------------------+--------4 | Mark |  25 | Rich-Mond                                 |  650006 | Kim  |  22 | South-Hall                                |  45000
(2 rows)

十、LIMIT 子句

PostgreSQL 中的 limit 子句用于限制 SELECT 语句中查询的数据的数量。

10.1 语法

带有 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]

10.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

下面实例将找出限定的数量的数据，即读取 4 条数据：

runoobdb=# SELECT * FROM COMPANY LIMIT 4;

得到以下结果：

 id | name  | age | address     | salary
----+-------+-----+-------------+--------1 | Paul  |  32 | California  |  200002 | Allen |  25 | Texas       |  150003 | Teddy |  23 | Norway      |  200004 | Mark  |  25 | Rich-Mond   |  65000
(4 rows)

但是，在某些情况下，可能需要从一个特定的偏移开始提取记录。

下面是一个实例，从第三位开始提取 3 个记录：

runoobdb=# SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

得到以下结果：

 id | name  | age | address   | salary
----+-------+-----+-----------+--------3 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  85000
(3 rows)

十一、ORDER BY 语句

在 PostgreSQL 中，ORDER BY 用于对一列或者多列数据进行升序（ASC）或者降序（DESC）排列。

11.1 语法

ORDER BY 子句的基础语法如下：

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

您可以在 ORDER BY 中使用一列或者多列，但是必须保证要排序的列必须存在。

ASC 表示升序，DESC 表示降序。

11.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

下面实例将对结果根据 AGE 字段值进行升序排列：

runoobdb=# SELECT * FROM COMPANY ORDER BY AGE ASC;

得到以下结果：

 id | name  | age |                      address                       | salary
----+-------+-----+----------------------------------------------------+--------6 | Kim   |  22 | South-Hall                                         |  450003 | Teddy |  23 | Norway                                             |  200007 | James |  24 | Houston                                            |  100004 | Mark  |  25 | Rich-Mond                                          |  650002 | Allen |  25 | Texas                                              |  150005 | David |  27 | Texas                                              |  850001 | Paul  |  32 | California                                         |  20000
(7 rows)

下面实例将对结果根据 NAME 字段值和 SALARY 字段值进行升序排序：

runoobdb=# SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

得到以下结果：

 id | name  | age |                      address                       | salary
----+-------+-----+----------------------------------------------------+--------2 | Allen |  25 | Texas                                              |  150005 | David |  27 | Texas                                              |  850007 | James |  24 | Houston                                            |  100006 | Kim   |  22 | South-Hall                                         |  450004 | Mark  |  25 | Rich-Mond                                          |  650001 | Paul  |  32 | California                                         |  200003 | Teddy |  23 | Norway                                             |  20000
(7 rows)

下面实例将对结果根据NAME字段值进行降序排列：

runoobdb=# SELECT * FROM COMPANY ORDER BY NAME DESC;

得到以下结果：

 id | name  | age |                      address                       | salary
----+-------+-----+----------------------------------------------------+--------3 | Teddy |  23 | Norway                                             |  200001 | Paul  |  32 | California                                         |  200004 | Mark  |  25 | Rich-Mond                                          |  650006 | Kim   |  22 | South-Hall                                         |  450007 | James |  24 | Houston                                            |  100005 | David |  27 | Texas                                              |  850002 | Allen |  25 | Texas                                              |  15000
(7 rows)

十二、GROUP BY 语句

在 PostgreSQL 中，GROUP BY 语句和 SELECT 语句一起使用，用来对相同的数据进行分组。

GROUP BY 在一个 SELECT 语句中，放在 WHRER 子句的后面，ORDER BY 子句的前面。

12.1 语法

下面给出了 GROUP BY 子句的基本语法:

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

GROUP BY 子句必须放在 WHERE 子句中的条件之后，必须放在 ORDER BY 子句之前。

在 GROUP BY 子句中，你可以对一列或者多列进行分组，但是被分组的列必须存在于列清单中。

12.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

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

runoobdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

得到以下结果：

  name  |  sum-------+-------Teddy | 20000Paul  | 20000Mark  | 65000David | 85000Allen | 15000Kim   | 45000James | 10000
(7 rows)

现在我们添加使用下面语句在 CAMPANY 表中添加三条记录：

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00);
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00);
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);

现在 COMPANY 表中存在重复的名称，数据如下：

 id | name  | age | address      | salary----+-------+-----+--------------+--------1 | Paul  |  32 | California   |  200002 | Allen |  25 | Texas        |  150003 | Teddy |  23 | Norway       |  200004 | Mark  |  25 | Rich-Mond    |  650005 | David |  27 | Texas        |  850006 | Kim   |  22 | South-Hall   |  450007 | James |  24 | Houston      |  100008 | Paul  |  24 | Houston      |  200009 | James |  44 | Norway       |   500010 | James |  45 | Texas        |   5000
(10 rows)

现在再根据 NAME 字段值进行分组，找出每个客户的工资总额：

runoobdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

这时的得到的结果如下：

name  |  sum
-------+-------Allen | 15000David | 85000James | 20000Kim   | 45000Mark  | 65000Paul  | 40000Teddy | 20000
(7 rows)

下面实例将 ORDER BY 子句与 GROUP BY 子句一起使用：

runoobdb=#  SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

得到以下结果：

name  |  sum
-------+-------Teddy | 20000Paul  | 40000Mark  | 65000Kim   | 45000James | 20000David | 85000Allen | 15000
(7 rows)

十三、WITH 子句

在 PostgreSQL 中，WITH 子句提供了一种编写辅助语句的方法，以便在更大的查询中使用。

WITH 子句有助于将复杂的大型查询分解为更简单的表单，便于阅读。这些语句通常称为通用表表达式（Common Table Express， CTE），也可以当做一个为查询而存在的临时表。

WITH 子句是在多次执行子查询时特别有用，允许我们在查询中通过它的名称(可能是多次)引用它。

WITH 子句在使用前必须先定义。

13.1 语法

WITH 查询的基础语法如下：

WITHname_for_summary_data AS (SELECT Statement)SELECT columnsFROM name_for_summary_dataWHERE conditions <=> (SELECT columnFROM name_for_summary_data)[ORDER BY columns]

name_for_summary_data 是 WITH 子句的名称，name_for_summary_data 可以与现有的表名相同，并且具有优先级。

可以在 WITH 中使用数据 INSERT, UPDATE 或 DELETE 语句，允许您在同一个查询中执行多个不同的操作。

13.2 WITH 递归

在 WITH 子句中可以使用自身输出的数据。

公用表表达式 (CTE) 具有一个重要的优点，那就是能够引用其自身，从而创建递归 CTE。递归 CTE 是一个重复执行初始 CTE 以返回数据子集直到获取完整结果集的公用表表达式。

13.2.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

下面将使用 WITH 子句在上表中查询数据：

With CTE AS
(SelectID
, NAME
, AGE
, ADDRESS
, SALARY
FROM COMPANY )
Select * From CTE;

得到结果如下：

id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

接下来让我们使用 RECURSIVE 关键字和 WITH 子句编写一个查询，查找 SALARY(工资) 字段小于 20000 的数据并计算它们的和：

WITH RECURSIVE t(n) AS (VALUES (0)UNION ALLSELECT SALARY FROM COMPANY WHERE SALARY < 20000
)
SELECT sum(n) FROM t;

得到结果如下：

 sum
-------25000
(1 row)

下面我们建立一张和 COMPANY 表相似的 COMPANY1 表，使用 DELETE 语句和 WITH 子句删除 COMPANY 表中 SALARY(工资) 字段大于等于 30000 的数据，并将删除的数据插入 COMPANY1 表，实现将 COMPANY 表数据转移到 COMPANY1 表中：

CREATE TABLE COMPANY1(ID INT PRIMARY KEY     NOT NULL,NAME           TEXT    NOT NULL,AGE            INT     NOT NULL,ADDRESS        CHAR(50),SALARY         REAL
);WITH moved_rows AS (DELETE FROM COMPANYWHERESALARY >= 30000RETURNING *
)
INSERT INTO COMPANY1 (SELECT * FROM moved_rows);

得到结果如下：

INSERT 0 3

此时，CAMPANY 表和 CAMPANY1 表的数据如下：

runoobdb=# SELECT * FROM COMPANY;id | name  | age |  address   | salary
----+-------+-----+------------+--------1 | Paul  |  32 | California |  200002 | Allen |  25 | Texas      |  150003 | Teddy |  23 | Norway     |  200007 | James |  24 | Houston    |  10000
(4 rows)runoobdb=# SELECT * FROM COMPANY1;id | name  | age | address | salary
----+-------+-----+-------------+--------4 | Mark  |  25 | Rich-Mond   |  650005 | David |  27 | Texas       |  850006 | Kim   |  22 | South-Hall  |  45000
(3 rows)

十四、HAVING 子句

HAVING 子句可以让我们筛选分组后的各组数据。

WHERE 子句在所选列上设置条件，而 HAVING 子句则在由 GROUP BY 子句创建的分组上设置条件。

14.1 语法

下面是 HAVING 子句在 SELECT 查询中的位置：

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER 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

14.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

下面实例将找出根据 NAME 字段值进行分组，并且 name(名称) 字段的计数少于 2 数据：

SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) < 2;

得到以下结果：

  name-------TeddyPaulMarkDavidAllenKimJames
(7 rows)

我们往表里添加几条数据：

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00);
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00);
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);

此时，COMPANY 表的记录如下：

 id | name  | age | address      | salary----+-------+-----+--------------+--------1 | Paul  |  32 | California   |  200002 | Allen |  25 | Texas        |  150003 | Teddy |  23 | Norway       |  200004 | Mark  |  25 | Rich-Mond    |  650005 | David |  27 | Texas        |  850006 | Kim   |  22 | South-Hall   |  450007 | James |  24 | Houston      |  100008 | Paul  |  24 | Houston      |  200009 | James |  44 | Norway       |   500010 | James |  45 | Texas        |   5000
(10 rows)

下面实例将找出根据 name 字段值进行分组，并且名称的计数大于 1 数据：

runoobdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) > 1;

得到结果如下：

 name
-------PaulJames
(2 rows)

十五、DISTINCT 关键字

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

我们平时在操作数据时，有可能出现一种情况，在一个表中有多个重复的记录，当提取这样的记录时，DISTINCT 关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。

15.1 语法

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

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

15.1.1 实例

创建 COMPANY 表（下载 COMPANY SQL 文件 ），数据内容如下：

runoobdb# select * from COMPANY;id | name  | age | address   | salary
----+-------+-----+-----------+--------1 | Paul  |  32 | California|  200002 | Allen |  25 | Texas     |  150003 | Teddy |  23 | Norway    |  200004 | Mark  |  25 | Rich-Mond |  650005 | David |  27 | Texas     |  850006 | Kim   |  22 | South-Hall|  450007 | James |  24 | Houston   |  10000
(7 rows)

让我们插入两条数据：

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (8, 'Paul', 32, 'California', 20000.00 );INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (9, 'Allen', 25, 'Texas', 15000.00 );

现在数据如下：

 id | name  | age | address    | salary
----+-------+-----+------------+--------1 | Paul  |  32 | California |  200002 | Allen |  25 | Texas      |  150003 | Teddy |  23 | Norway     |  200004 | Mark  |  25 | Rich-Mond  |  650005 | David |  27 | Texas      |  850006 | Kim   |  22 | South-Hall |  450007 | James |  24 | Houston    |  100008 | Paul  |  32 | California |  200009 | Allen |  25 | Texas      |  15000
(9 rows)

接下来我们找出 COMPANY 表中的所有 NAME：

runoobdb=# SELECT name FROM COMPANY;

得到结果如下：

 name
-------PaulAllenTeddyMarkDavidKimJamesPaulAllen
(9 rows)

现在我们在 SELECT 语句中使用 DISTINCT 子句：

runoobdb=# SELECT DISTINCT name FROM COMPANY;

得到结果如下：

name
-------TeddyPaulMarkDavidAllenKimJames
(7 rows)

从结果可以看到，重复数据已经被删除。

7.PostgreSQL操作语句相关推荐

1. postgreSQL 操作 教程

   postgreSQL 操作 教程 1. 建立数据库连接 2. 访问数据库 列出当前数据库所有表 列出数据库名 切换数据库 查询数据库.表名 内部命令 SQL命令通用如(标准化SQL语句): 数据库 s ...

2. Oracle 数据库常用操作语句大全

   原文:Oracle 数据库常用操作语句大全 一.Oracle数据库操作 1.创建数据库      create database databasename 2.删除数据库      drop data ...

3. PostgreSQL操作问题(转载)

   PostgreSQL操作问题 4.1)如何只选择一个查询结果的头几行?或是随机的一行? 如果你只是要提取几行数据,并且你在执行查询中知道确切的行数,你可以使用LIMIT功能. 如果有一个索引与 ORD ...

4. Database之SQLSever：T-SQL数据语言操作(数据定义语句DDL、数据操作语句DML、数据控制语句DCL、其他基本语句、流程控制语句、批处理语句)概念及其相关案例之详细攻略

   Database之SQLSever:T-SQL数据语言操作(数据定义语句DDL.数据操作语句DML.数据控制语句DCL.其他基本语句.流程控制语句.批处理语句)概念及其相关案例之详细攻略 目录 T-S ...

5. ubuntu下mysql语句_Ubuntu安装mysql及常用SQL操作语句

   Ubuntu安装mysql及常用SQL操作语句:安装mysql,在终端运行如下三条命令. sudo apt-get install mysql-server sudo apt-get install ...

6. 跳出框架iframe的操作语句

   常用的iframe操作语句 ①   本页面跳转语句: "window.location.href" 或者 "location.href" ②   上一层页面跳转 ...

7. 数据库操作 linq php,.NET_asp.net使用LINQ to SQL连接数据库及SQL操作语句用法分析，本文实例讲述了asp.net使用LINQ t - phpStudy...

   asp.net使用LINQ to SQL连接数据库及SQL操作语句用法分析 本文实例讲述了asp.net使用LINQ to SQL连接数据库及SQL操作语句用法.分享给大家供大家参考,具体如下: LI ...

8. MySQL数据库（3）_MySQL数据库表记录操作语句

   附: MYSQL5.7版本sql_mode=only_full_group_by问题1.查询当前sql_mode: select @@sql_mode2.查询出来的值为:set @@sql_mode ...

9. Oracle 操作语句

   Oracle 数据库操作语句 创建表 SQL>create table classes(        classId number(2),        cname varchar2(40), ...

最新文章

1. 04Strategy(策略)模式
2. The Innovation | Volume 2 Issue3 正式出版
3. django部署iiswin10_基于Windows平台的Django在本地部署和腾讯云服务器上部署的方法教程（一）...
4. C语言经典程序之：求十个整数中的最大最小数并输出（指针）
5. vim编辑环境设定[Linux]
6. Feature Map of Pytorch示例
7. 采用 opencv surf 算子进行特征匹配
8. Python os模块常用介绍
9. Python 5种方法实现单例模式
10. C++归并排序(附完整源码)
11. MATLAB读取文件夹及其所有子文件夹内的图像
12. 「镁客早报」传SpaceX计划展开7.5亿美元贷款融资；LG开始为苹果生产OLED面板
13. 创业者没有周末，但有周期
14. 2021-2025年中国超本地服务行业市场供需与战略研究报告
15. 复制构造函数与析构函数
16. 做项目时自己的心得体会
17. 【Stanford CNN课程笔记】5. 神经网络解读1 几种常见的激活函数
18. 分布式自增序列id的实现(二) ---分布式序号生成器---基于Redis的自增功能
19. vueX的mutation/action个人学习总结
20. 【理解】运用数据透视表制作三栏账

热门文章

1. 基于MATLAB的远程声控小车的系统设计与仿真
2. 新麦机械冲刺深交所：年营收9.7亿 谢氏家族持股23%
3. 3G入门教程--通讯基础
4. LWIP学习笔记（3）LWIP数据包管理结构pbuf
5. 全志Tina Linux 系统裁剪 boot0裁剪 uboot裁剪 内核裁剪 文件系统裁剪 C库裁剪 文件系统压缩
6. 最优化--等式约束最优性条件
7. cmd package install-create -r -t -S returns error
8. mimikatz免杀过360和火绒
9. # Android实习周记-9.29
10. LINE FRIENDS 跨界李宁推出联名系列