PostgreSQL语法

曾经终败给现在 2023-07-24 09:10 3阅读 0赞

# PostgreSQL 语法 #

> 更多内容可以参考手册中的 SQL 语法：http://www.runoob.com/manual/PostgreSQL/sql-syntax.html。
> 
> https://www.cnblogs.com/XiaoGuanYu/p/9892321.html

### 文章目录 ###

*  PostgreSQL 语法
 *   *  进入命令行工具
     *  SQL 语句
     *  PostgreSQL 命令
     *   *  \\l:查看数据库
         *  \\c:进入数据库
         *  \\d:查看当前数据库中表
         *  \\di:查看索引
         *  ABORT:退出当前事务
         *  ALTER AGGREGATE
         *  ALTER COLLATION
         *  ALTER CONVERSION
         *  ALTER DATABASE
         *  ALTER DEFAULT PRIVILEGES
         *  ALTER DOMAIN
         *  ALTER FUNCTION
         *  ALTER GROUP
         *  ALTER INDEX
         *  ALTER LANGUAGE
         *  ALTER OPERATOR
         *  ALTER OPERATOR CLASS
         *  ALTER SCHEMA
         *  ALTER SEQUENCE
         *  ALTER TABLE
         *  ALTER TABLESPACE
         *  ALTER TRIGGER
         *  ALTER TYPE
         *  ALTER USER
         *  ANALYZE:收集与数据库有关的统计
         *  BEGIN:开始一个事务块
         *  CHECKPOINT:强制一个事务日志检查点
         *  CLOSE:关闭游标
         *  CLUSTER:根据一个索引对某个表盘簇化排序
         *  COMMENT:定义或者改变一个对象的注释
         *  COMMIT
         *  COPY:在表和文件之间拷贝数据
         *  CREATE AGGREGATE
         *  CREATE CAST
         *  CREATE CONSTRAINT TRIGGER
         *  CREATE CONVERSION
         *  CREATE DATABASE
         *  CREATE DOMAIN
         *  CREATE FUNCTION
         *  CREATE GROUP
         *  CREATE INDEX
         *  CREATE LANGUAGE
         *  CREATE OPERATOR
         *  CREATE OPERATOR CLASS
         *  CREATE ROLE
         *  CREATE RULE
         *  CREATE SCHEMA
         *  CREATE SERVER
         *  CREATE SEQUENCE
         *  CREATE TABLE
         *  CREATE TABLE AS
         *  CREATE TABLESPACE
         *  CREATE TRIGGER
         *  CREATE TYPE
         *  CREATE USER
         *  CREATE VIEW
         *  DEALLOCATE
         *  DECLARE
         *  DELETE
         *  DROP AGGREGATE
         *  DROP CAST
         *  DROP CONVERSION
         *  DROP DATABASE
         *  DROP DOMAIN
         *  DROP FUNCTION
         *  DROP GROUP
         *  DROP INDEX
         *  DROP LANGUAGE
         *  DROP OPERATOR
         *  DROP OPERATOR CLASS
         *  DROP ROLE
         *  DROP RULE
         *  DROP SCHEMA
         *  DROP SEQUENCE
         *  DROP TABLE
         *  DROP TABLESPACE
         *  DROP TRIGGER
         *  DROP TYPE
         *  DROP USER
         *  DROP VIEW
         *  END
         *  EXECUTE
         *  EXPLAIN
         *  FETCH
         *  GRANT
         *  INSERT
         *  LISTEN
         *  LOAD
         *  LOCK
         *  MOVE
         *  NOTIFY
         *  PREPARE
         *  REINDEX
         *  RELEASE SAVEPOINT
         *  RESET
         *  REVOKE
         *  ROLLBACK
         *  ROLLBACK TO SAVEPOINT
         *  SAVEPOINT
         *  SELECT
         *  SELECT INTO
         *  SET
         *  SET CONSTRAINTS
         *  SET SESSION AUTHORIZATION
         *  SET TRANSACTION
         *  SHOW
         *  START TRANSACTION
         *  TRUNCATE
         *  UNLISTEN
         *  UPDATE
         *  VACUUM
         *  VALUES
 *  PostgreSQL 简单命令
 *  PostgreSQL 数据类型
 *   *  数值类型
     *  货币类型
     *  字符类型
     *  日期/时间类型
     *  布尔类型
     *  枚举类型
     *  几何类型
     *  网络地址类型
     *  位串类型
     *  文本搜索类型
     *  UUID 类型
     *  XML 类型
     *   *  创建XML值
     *  JSON 类型
     *  数组类型
     *   *  声明数组
         *  插入值
         *  访问数组
         *  修改数组
         *  数组中检索
     *  复合类型
     *   *  声明复合类型
         *  复合类型值输入
         *  访问复合类型
     *  范围类型
     *  对象标识符类型
     *  伪类型
 *  PostgreSQL 创建数据库
 *   *  1.CREATE DATABASE 创建数据库
     *  2.createdb 命令创建数据库
     *  3.pgAdmin 工具创建数据库
 *  PostgreSQL 选择数据库
 *   *   *  数据库的命令窗口
         *  系统命令行窗口
         *  pgAdmin 工具
 *  PostgreSQL 删除数据库
 *   *   *  DROP DATABASE 删除数据库
         *  dropdb 命令删除数据库
         *  pgAdmin 工具删除据库
 *  PostgreSQL 创建表格
 *   *   *  语法
         *  实例
 *  PostgreSQL 删除表格
 *   *   *  语法
         *  实例
 *  PostgreSQL INSERT INTO 语句
 *   *   *  语法
         *  实例
 *  PostgreSQL SELECT 语句
 *   *   *  语法
 *  PostgreSQL 运算符
 *   *  算术运算符
     *   *  实例
     *  比较运算符
     *   *  实例
     *  逻辑运算符
     *   *  实例
     *  位运算符
     *   *  实例
 *  PostgreSQL 表达式
 *   *   *  语法
         *  布尔表达式
         *  数字表达式
         *  日期表达式
 *  PostgreSQL WHERE 子句
 *   *   *  语法
         *  AND
         *  OR
         *  NOT NULL
         *  LIKE
         *  IN
         *  NOT IN
         *  BETWEEN
         *  子查询
 *  PostgreSQL AND & OR 运算符
 *   *   *  AND
         *  实例
         *  OR
 *  PostgreSQL UPDATE 语句
 *   *   *  语法
         *  实例
 *  PostgreSQL DELETE 语句
 *   *   *  语法
         *  实例
 *  PostgreSQL LIKE 子句
 *   *   *  语法
         *  实例
 *  PostgreSQL LIMIT 子句
 *   *   *  语法
         *  实例
 *  PostgreSQL ORDER BY 语句
 *   *   *  语法
         *  实例
 *  PostgreSQL GROUP BY 语句
 *   *   *  语法
         *  实例
 *  PostgreSQL WITH 子句
 *   *   *  语法
         *  WITH 递归
         *  实例
 *  PostgreSQL HAVING 子句
 *   *   *  语法
         *  实例
 *  PostgreSQL DISTINCT 关键字
 *   *   *  语法
         *  实例
 *  PostgreSQL 约束
 *   *   *  NOT NULL 约束
         *  UNIQUE 约束
         *  PRIMARY KEY
         *  FOREIGN KEY 约束
         *  CHECK 约束
         *  EXCLUSION 约束
         *  删除约束
 *  PostgreSQL 连接(JOIN)
 *   *  实例
     *  交叉连接
     *  内连接
     *  左外连接
     *  右外连接
     *  外连接
 *  PostgreSQL UNION 操作符
 *   *  语法
     *  实例
     *  UNION ALL 子句
     *   *  语法
         *  实例
 *  PostgreSQL NULL 值
 *   *   *  语法
         *  实例
 *  PostgreSQL 别名
 *   *   *  语法
         *  实例
 *  PostgreSQL ALTER TABLE 命令
 *   *   *  语法
         *  实例
 *  PostgreSQL TRUNCATE TABLE
 *   *   *  语法
         *  实例
 *  PostgreSQL 子查询
 *   *  SELECT 语句中的子查询使用
     *   *  实例
     *  INSERT 语句中的子查询使用
     *   *  实例
     *  UPDATE 语句中的子查询使用
     *   *  实例
     *  DELETE 语句中的子查询使用
     *   *  实例
 *  PostgreSQL AUTO INCREMENT（自动增长）
 *   *   *  语法
         *  实例
 *  PostgreSQL PRIVILEGES（权限）
 *   *   *  GRANT 语法
         *  实例
         *  实例
 *  PostgreSQL 时间/日期函数和操作符
 *   *   *  日期/时间操做符
         *  日期/时间函数
 *  PostgreSQL 常用函数
 *   *  数学函数
     *   *  三角函数列表
     *  字符串函数和操作符
     *  类型转换相关函数

## 进入命令行工具 ##

默认情况下 PostgreSQL 安装完成后，自带了一个命令行工具 **SQL Shell(psql)**。

**Linux** 系统可以直接切换到 postgres 用户来开启命令行工具：

# sudo -i -u postgres
    
    
    
    su - postgres 
    切换用户，执行后提示符会变为 '-bash-4.2$'
    
    psql -U postgres
    登录数据库，执行后提示符变为 'postgres=#'
    
    ALTER USER postgres WITH PASSWORD 'postgres';   
    设置postgres用户密码为postgres
    
    \q 
    退出数据库

**Windows** 系统一般在它的安装目录下：

Program Files → PostgreSQL 11.3 → SQL Shell(psql)

进入命令行工具，我们可以使用 **\\help** 来查看各个命令的语法 ：

postgres-# \help <command_name>

例如，我们查看下 select 语句的语法：

postgres=# \help SELECT
    Command:     SELECT
    Description: retrieve rows from a table or view
    Syntax:
    [ WITH [ RECURSIVE ] with_query [, ...] ]
    SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
        [ * | expression [ [ AS ] output_name ] [, ...] ]
        [ FROM from_item [, ...] ]
        [ WHERE condition ]
        [ GROUP BY grouping_element [, ...] ]
        [ HAVING condition [, ...] ]
        [ WINDOW window_name AS ( window_definition ) [, ...] ]
        [ {  UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
        [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS {  FIRST | LAST } ] [, ...] ]
        [ LIMIT {  count | ALL } ]
        [ OFFSET start [ ROW | ROWS ] ]
        [ FETCH {  FIRST | NEXT } [ count ] {  ROW | ROWS } ONLY ]
        [ FOR {  UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ] [ NOWAIT | SKIP LOCKED ] [...] ]
    
    from_item 可以是以下选项之一：
    
        [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]

## SQL 语句 ##

一个 SQL 语句通常包含了关键字、标识符（字段）、常量、特殊符号等，下面是一个简单的 SQL 语句：

SELECT id, name FROM runoob

<table> 
 <thead> 
  <tr> 
   <th align="left"></th> 
   <th align="center">SELECT</th> 
   <th align="center">id, name</th> 
   <th align="center">FROM</th> 
   <th align="center">runoob</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">符号类型</td> 
   <td align="center">关键字</td> 
   <td align="center">标识符（字段）</td> 
   <td align="center">关键字</td> 
   <td align="center">标识符</td> 
  </tr> 
  <tr> 
   <td align="left">描述</td> 
   <td align="center">命令</td> 
   <td align="center">id 和 name 字段</td> 
   <td align="center">语句，用于设置条件规则等</td> 
   <td align="center">表名</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## PostgreSQL 命令 ##

> https://blog.csdn.net/kiwi\_kid/article/details/50998428\#

### \\l:查看数据库 ###

> \\加上字母l,相当于mysql的，mysql> show databases;

### \\c:进入数据库 ###

postgres=# \c runoobdb
    You are now connected to database "runoobdb" as user "postgres".
    runoobdb=#

### \\d:查看当前数据库中表 ###

### \\di:查看索引 ###

playboy=> \di                      //相当于mysql的，mysql> show index from test;
                    List of relations
     Schema |     Name      | Type  |  Owner  | Table
    --------+---------------+-------+---------+-------
     public | playboy_id_pk | index | playboy | test
    (1 row)
     
    playboy=> select pg_size_pretty(pg_relation_size('playboy_id_pk'));    //查看索引大小
     pg_size_pretty
    ----------------
     8192 bytes
    (1 row)

### ABORT:退出当前事务 ###

ABORT 用于退出当前事务。

ABORT [ WORK | TRANSACTION ]

### ALTER AGGREGATE ###

修改一个聚集函数的定义 。

ALTER AGGREGATE _name_ ( _argtype_ [ , ... ] ) RENAME TO _new_name_
    ALTER AGGREGATE _name_ ( _argtype_ [ , ... ] ) OWNER TO _new_owner_
    ALTER AGGREGATE _name_ ( _argtype_ [ , ... ] ) SET SCHEMA _new_schema_

### ALTER COLLATION ###

修改一个排序规则定义 。

ALTER COLLATION _name_ RENAME TO _new_name_
    ALTER COLLATION _name_ OWNER TO _new_owner_
    ALTER COLLATION _name_ SET SCHEMA _new_schema_

### ALTER CONVERSION ###

修改一个编码转换的定义。

ALTER CONVERSION name RENAME TO new_name
    ALTER CONVERSION name OWNER TO new_owner

### ALTER DATABASE ###

修改一个数据库。

ALTER DATABASE name SET parameter { TO | = } { value | DEFAULT }
    ALTER DATABASE name RESET parameter
    ALTER DATABASE name RENAME TO new_name
    ALTER DATABASE name OWNER TO new_owner

### ALTER DEFAULT PRIVILEGES ###

定义默认的访问权限。

ALTER DEFAULT PRIVILEGES
        [ FOR { ROLE | USER } target_role [, ...] ]
        [ IN SCHEMA schema_name [, ...] ]
        abbreviated_grant_or_revoke
    
    where abbreviated_grant_or_revoke is one of:
    
    GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER }
        [, ...] | ALL [ PRIVILEGES ] }
        ON TABLES
        TO { [ GROUP ] role_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    ...

### ALTER DOMAIN ###

修改一个域的定义。

ALTER DOMAIN name { SET DEFAULT expression | DROP DEFAULT }
    ALTER DOMAIN name { SET | DROP } NOT NULL
    ALTER DOMAIN name ADD domain_constraint
    ALTER DOMAIN name DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
    ALTER DOMAIN name OWNER TO new_owner

### ALTER FUNCTION ###

修改一个函数的定义。

ALTER FUNCTION name ( [ type [, ...] ] ) RENAME TO new_name
    ALTER FUNCTION name ( [ type [, ...] ] ) OWNER TO new_owner

### ALTER GROUP ###

修改一个用户组。

ALTER GROUP groupname ADD USER username [, ... ]
    ALTER GROUP groupname DROP USER username [, ... ]
    ALTER GROUP groupname RENAME TO new_name

### ALTER INDEX ###

修改一个索引的定义。

ALTER INDEX name OWNER TO new_owner
    ALTER INDEX name SET TABLESPACE indexspace_name
    ALTER INDEX name RENAME TO new_name

### ALTER LANGUAGE ###

修改一个过程语言的定义。

ALTER LANGUAGE name RENAME TO new_name

### ALTER OPERATOR ###

改变一个操作符的定义。

ALTER OPERATOR name ( { lefttype | NONE }, { righttype | NONE } )
    OWNER TO new_owner

### ALTER OPERATOR CLASS ###

修改一个操作符表的定义。

ALTER OPERATOR CLASS name USING index_method RENAME TO new_name
    ALTER OPERATOR CLASS name USING index_method OWNER TO new_owner

### ALTER SCHEMA ###

修改一个模式的定义。

ALTER SCHEMA name RENAME TO new_name
    ALTER SCHEMA name OWNER TO new_owner

### ALTER SEQUENCE ###

修改一个序列生成器的定义。

ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
    [ MINVALUE minvalue | NO MINVALUE ]
    [ MAXVALUE maxvalue | NO MAXVALUE ]
    [ RESTART [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

### ALTER TABLE ###

修改表的定义。

ALTER TABLE [ ONLY ] name [ * ]
    action [, ... ]
    ALTER TABLE [ ONLY ] name [ * ]
    RENAME [ COLUMN ] column TO new_column
    ALTER TABLE name
    RENAME TO new_name

其中 **action** 可以是以选项之一：

ADD [ COLUMN ] column_type [ column_constraint [ ... ] ]
    DROP [ COLUMN ] column [ RESTRICT | CASCADE ]
    ALTER [ COLUMN ] column TYPE type [ USING expression ]
    ALTER [ COLUMN ] column SET DEFAULT expression
    ALTER [ COLUMN ] column DROP DEFAULT
    ALTER [ COLUMN ] column { SET | DROP } NOT NULL
    ALTER [ COLUMN ] column SET STATISTICS integer
    ALTER [ COLUMN ] column SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
    ADD table_constraint
    DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
    CLUSTER ON index_name
    SET WITHOUT CLUSTER
    SET WITHOUT OIDS
    OWNER TO new_owner
    SET TABLESPACE tablespace_name

### ALTER TABLESPACE ###

修改一个表空间的定义。

ALTER TABLESPACE name RENAME TO new_name
    ALTER TABLESPACE name OWNER TO new_owner

### ALTER TRIGGER ###

修改改变一个触发器的定义 。

ALTER TRIGGER name ON table RENAME TO new_name

### ALTER TYPE ###

修改一个类型的定义 。

ALTER TYPE name OWNER TO new_owner

### ALTER USER ###

修改数据库用户帐号 。

ALTER USER name [ [ WITH ] option [ ... ] ]
    ALTER USER name RENAME TO new_name
    ALTER USER name SET parameter { TO | = } { value | DEFAULT }
    ALTER USER name RESET parameter

Where *option* can be −

### ANALYZE:收集与数据库有关的统计 ###

收集与数据库有关的统计。

ANALYZE [ VERBOSE ] [ table [ (column [, ...] ) ] ]

### BEGIN:开始一个事务块 ###

开始一个事务块。

BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]

*transaction\_mode* 可以是以下选项之一：

ISOLATION LEVEL { 
       SERIALIZABLE | REPEATABLE READ | READ COMMITTED
       | READ UNCOMMITTED
    }
    READ WRITE | READ ONLY

### CHECKPOINT:强制一个事务日志检查点 ###

强制一个事务日志检查点 。

CHECKPOINT

### CLOSE:关闭游标 ###

关闭游标。

CLOSE name

### CLUSTER:根据一个索引对某个表盘簇化排序 ###

根据一个索引对某个表盘簇化排序。

CLUSTER index_name ON table_name
    CLUSTER table_name
    CLUSTER

### COMMENT:定义或者改变一个对象的注释 ###

定义或者改变一个对象的注释。

COMMENT ON {
       TABLE object_name |
       COLUMN table_name.column_name |
       AGGREGATE agg_name (agg_type) |
       CAST (source_type AS target_type) |
       CONSTRAINT constraint_name ON table_name |
       CONVERSION object_name |
       DATABASE object_name |
       DOMAIN object_name |
       FUNCTION func_name (arg1_type, arg2_type, ...) |
       INDEX object_name |
       LARGE OBJECT large_object_oid |
       OPERATOR op (left_operand_type, right_operand_type) |
       OPERATOR CLASS object_name USING index_method |
       [ PROCEDURAL ] LANGUAGE object_name |
       RULE rule_name ON table_name |
       SCHEMA object_name |
       SEQUENCE object_name |
       TRIGGER trigger_name ON table_name |
       TYPE object_name |
       VIEW object_name
    } 
    IS 'text'

### COMMIT ###

提交当前事务。

COMMIT [ WORK | TRANSACTION ]

### COPY:在表和文件之间拷贝数据 ###

在表和文件之间拷贝数据。

COPY table_name [ ( column [, ...] ) ]
    FROM { 'filename' | STDIN }
    [ WITH ]
    [ BINARY ]
    [ OIDS ]
    [ DELIMITER [ AS ] 'delimiter' ]
    [ NULL [ AS ] 'null string' ]
    [ CSV [ QUOTE [ AS ] 'quote' ]
    [ ESCAPE [ AS ] 'escape' ]
    [ FORCE NOT NULL column [, ...] ]
    COPY table_name [ ( column [, ...] ) ]
    TO { 'filename' | STDOUT }
    [ [ WITH ]
    [ BINARY ]
    [ OIDS ]
    [ DELIMITER [ AS ] 'delimiter' ]
    [ NULL [ AS ] 'null string' ]
    [ CSV [ QUOTE [ AS ] 'quote' ]
    [ ESCAPE [ AS ] 'escape' ]
    [ FORCE QUOTE column [, ...] ]

### CREATE AGGREGATE ###

定义一个新的聚集函数。

CREATE AGGREGATE name (
       BASETYPE = input_data_type,
       SFUNC = sfunc,
       STYPE = state_data_type
       [, FINALFUNC = ffunc ]
       [, INITCOND = initial_condition ]
    )

### CREATE CAST ###

定义一个用户定义的转换。

CREATE CAST (source_type AS target_type)
    WITH FUNCTION func_name (arg_types)
    [ AS ASSIGNMENT | AS IMPLICIT ]
    CREATE CAST (source_type AS target_type)
    WITHOUT FUNCTION
    [ AS ASSIGNMENT | AS IMPLICIT ]

### CREATE CONSTRAINT TRIGGER ###

定义一个新的约束触发器 。

CREATE CONSTRAINT TRIGGER name
    AFTER events ON
    table_name constraint attributes
    FOR EACH ROW EXECUTE PROCEDURE func_name ( args )

### CREATE CONVERSION ###

定义一个新的的编码转换。

CREATE [DEFAULT] CONVERSION name
    FOR source_encoding TO dest_encoding FROM func_name

### CREATE DATABASE ###

创建新数据库。

CREATE DATABASE name
    [ [ WITH ] [ OWNER [=] db_owner ]
       [ TEMPLATE [=] template ]
       [ ENCODING [=] encoding ]
       [ TABLESPACE [=] tablespace ] 
    ]

### CREATE DOMAIN ###

定义一个新域。

CREATE DOMAIN name [AS] data_type
    [ DEFAULT expression ]
    [ constraint [ ... ] ]

*constraint* 可以是以下选项之一：

[ CONSTRAINT constraint_name ]
    { NOT NULL | NULL | CHECK (expression) }

### CREATE FUNCTION ###

定义一个新函数。

CREATE [ OR REPLACE ] FUNCTION name ( [ [ arg_name ] arg_type [, ...] ] )
    RETURNS ret_type
    { LANGUAGE lang_name
       | IMMUTABLE | STABLE | VOLATILE
       | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
       | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
       | AS 'definition'
       | AS 'obj_file', 'link_symbol'
    } ...
    [ WITH ( attribute [, ...] ) ]

### CREATE GROUP ###

定义一个新的用户组。

CREATE GROUP name [ [ WITH ] option [ ... ] ]
    Where option can be:
    SYSID gid
    | USER username [, ...]

### CREATE INDEX ###

定义一个新索引。

CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
    ( { column | ( expression ) } [ opclass ] [, ...] )
    [ TABLESPACE tablespace ]
    [ WHERE predicate ]

### CREATE LANGUAGE ###

定义一种新的过程语言。

CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
    HANDLER call_handler [ VALIDATOR val_function ]

### CREATE OPERATOR ###

定义一个新的操作符。

CREATE OPERATOR name (
       PROCEDURE = func_name
       [, LEFTARG = left_type ] [, RIGHTARG = right_type ]
       [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
       [, RESTRICT = res_proc ] [, JOIN = join_proc ]
       [, HASHES ] [, MERGES ]
       [, SORT1 = left_sort_op ] [, SORT2 = right_sort_op ]
       [, LTCMP = less_than_op ] [, GTCMP = greater_than_op ]
    )

### CREATE OPERATOR CLASS ###

定义一个新的操作符表。

CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type
    USING index_method AS
    { OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ RECHECK ]
       | FUNCTION support_number func_name ( argument_type [, ...] )
       | STORAGE storage_type
    } [, ... ]

### CREATE ROLE ###

定义一个新的数据库角色。

### CREATE RULE ###

定义一个新重写规则。

CREATE [ OR REPLACE ] RULE name AS ON event
    TO table [ WHERE condition ]
    DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }

### CREATE SCHEMA ###

定义一个新模式。

CREATE SCHEMA schema_name
    [ AUTHORIZATION username ] [ schema_element [ ... ] ]
    CREATE SCHEMA AUTHORIZATION username
    [ schema_element [ ... ] ]

### CREATE SERVER ###

定义一个新的外部服务器。。

CREATE SERVER _server_name_ [ TYPE '_server_type_' ] [ VERSION '_server_version_' ]
        FOREIGN DATA WRAPPER _fdw_name_
        [ OPTIONS ( _option_ '_value_' [, ... ] ) ]

### CREATE SEQUENCE ###

定义一个新序列发生器。

CREATE [ TEMPORARY | TEMP ] SEQUENCE name
    [ INCREMENT [ BY ] increment ]
    [ MINVALUE minvalue | NO MINVALUE ]
    [ MAXVALUE maxvalue | NO MAXVALUE ]
    [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

### CREATE TABLE ###

定义一个新表。

CREATE [ [ GLOBAL | LOCAL ] { 
       TEMPORARY | TEMP } ] TABLE table_name ( { 
          column_name data_type [ DEFAULT default_expr ] [ column_constraint [ ... ] ]
          | table_constraint
          | LIKE parent_table [ { INCLUDING | EXCLUDING } DEFAULTS ] 
       } [, ... ]
    )
    [ INHERITS ( parent_table [, ... ] ) ]
    [ WITH OIDS | WITHOUT OIDS ]
    [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
    [ TABLESPACE tablespace ]

*column\_constraint* 可以是以下选项之一：

[ CONSTRAINT constraint_name ] { 
       NOT NULL |
       NULL |
       UNIQUE [ USING INDEX TABLESPACE tablespace ] |
       PRIMARY KEY [ USING INDEX TABLESPACE tablespace ] |
       CHECK (expression) |
       REFERENCES ref_table [ ( ref_column ) ]
       [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
       [ ON DELETE action ] [ ON UPDATE action ] 
    }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

*table\_constraint* 可以是以下选项之一：

[ CONSTRAINT constraint_name ]
    { UNIQUE ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
    PRIMARY KEY ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
    CHECK ( expression ) |
    FOREIGN KEY ( column_name [, ... ] )
    REFERENCES ref_table [ ( ref_column [, ... ] ) ]
    [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
    [ ON DELETE action ] [ ON UPDATE action ] }
    [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

### CREATE TABLE AS ###

从一条查询的结果中定义一个新表。

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name
    [ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
    AS query

### CREATE TABLESPACE ###

定义一个新的表空间。

CREATE TABLESPACE tablespace_name [ OWNER username ] LOCATION 'directory'

### CREATE TRIGGER ###

定义一个新的触发器。

CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
    ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
    EXECUTE PROCEDURE func_name ( arguments )

### CREATE TYPE ###

定义一个新的数据类型。

CREATE TYPE name AS
    ( attribute_name data_type [, ... ] )
    CREATE TYPE name (
    INPUT = input_function,
    OUTPUT = output_function
    [, RECEIVE = receive_function ]
    [, SEND = send_function ]
    [, ANALYZE = analyze_function ]
    [, INTERNALLENGTH = { internal_length | VARIABLE } ]
    [, PASSEDBYVALUE ]
    [, ALIGNMENT = alignment ]
    [, STORAGE = storage ]
    [, DEFAULT = default ]
    [, ELEMENT = element ]
    [, DELIMITER = delimiter ]
    )

### CREATE USER ###

创建一个新的数据库用户帐户。

CREATE USER name [ [ WITH ] option [ ... ] ]

*option* 可以是以下选项之一：

### CREATE VIEW ###

定义一个视图。

CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS query

### DEALLOCATE ###

删除一个准备好的查询。

DEALLOCATE [ PREPARE ] plan_name

### DECLARE ###

定义一个游标。

DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
    CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
    [ FOR { READ ONLY | UPDATE [ OF column [, ...] ] } ]

### DELETE ###

删除一个表中的行。

DELETE FROM [ ONLY ] table [ WHERE condition ]

### DROP AGGREGATE ###

删除一个用户定义的聚集函数。

DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]

### DROP CAST ###

删除一个用户定义的类型转换。

DROP CAST (source_type AS target_type) [ CASCADE | RESTRICT ]

### DROP CONVERSION ###

删除一个用户定义的编码转换。

DROP CONVERSION name [ CASCADE | RESTRICT ]

### DROP DATABASE ###

删除一个数据库。

DROP DATABASE name

### DROP DOMAIN ###

删除一个用户定义的域。

DROP DOMAIN name [, ...] [ CASCADE | RESTRICT ]

### DROP FUNCTION ###

删除一个函数。

DROP FUNCTION name ( [ type [, ...] ] ) [ CASCADE | RESTRICT ]

### DROP GROUP ###

删除一个用户组。

DROP GROUP name

### DROP INDEX ###

删除一个索引。

DROP INDEX name [, ...] [ CASCADE | RESTRICT ]

### DROP LANGUAGE ###

删除一个过程语言。

DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]

### DROP OPERATOR ###

删除一个操作符。

DROP OPERATOR name ( { left_type | NONE }, { right_type | NONE } )
    [ CASCADE | RESTRICT ]

### DROP OPERATOR CLASS ###

删除一个操作符表。

DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]

### DROP ROLE ###

删除一个数据库角色。

DROP ROLE [ IF EXISTS ] _name_ [, ...]

### DROP RULE ###

删除一个重写规则。

DROP RULE name ON relation [ CASCADE | RESTRICT ]

### DROP SCHEMA ###

删除一个模式。

DROP SCHEMA name [, ...] [ CASCADE | RESTRICT ]

### DROP SEQUENCE ###

删除一个序列。

DROP SEQUENCE name [, ...] [ CASCADE | RESTRICT ]

### DROP TABLE ###

删除一个表。

DROP TABLE name [, ...] [ CASCADE | RESTRICT ]

### DROP TABLESPACE ###

删除一个表空间。

DROP TABLESPACE tablespace_name

### DROP TRIGGER ###

删除一个触发器定义。

DROP TRIGGER name ON table [ CASCADE | RESTRICT ]

### DROP TYPE ###

删除一个用户定义数据类型。

DROP TYPE name [, ...] [ CASCADE | RESTRICT ]

### DROP USER ###

删除一个数据库用户帐号。

DROP USER name

### DROP VIEW ###

删除一个视图。

DROP VIEW name [, ...] [ CASCADE | RESTRICT ]

### END ###

提交当前的事务。

END [ WORK | TRANSACTION ]

### EXECUTE ###

执行一个准备好的查询。

EXECUTE plan_name [ (parameter [, ...] ) ]

### EXPLAIN ###

显示一个语句的执行规划。

EXPLAIN [ ANALYZE ] [ VERBOSE ] statement

### FETCH ###

用游标从查询中抓取行。

FETCH [ direction { FROM | IN } ] cursor_name

*direction* 可以是以下选项之一：

NEXT
    PRIOR
    FIRST
    LAST
    ABSOLUTE count
    RELATIVE count
    count
    ALL
    FORWARD
    FORWARD count
    FORWARD ALL
    BACKWARD
    BACKWARD count
    BACKWARD ALL

### GRANT ###

定义访问权限。

GRANT { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
    [,...] | ALL [ PRIVILEGES ] }
    ON [ TABLE ] table_name [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
    ON DATABASE db_name [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { CREATE | ALL [ PRIVILEGES ] }
    ON TABLESPACE tablespace_name [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { EXECUTE | ALL [ PRIVILEGES ] }
    ON FUNCTION func_name ([type, ...]) [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { USAGE | ALL [ PRIVILEGES ] }
    ON LANGUAGE lang_name [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]
    
    GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
    ON SCHEMA schema_name [, ...]
    TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

### INSERT ###

在表中创建新行，即插入数据。

INSERT INTO table [ ( column [, ...] ) ]
    { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | query }

### LISTEN ###

监听一个通知。

LISTEN name

### LOAD ###

加载或重载一个共享库文件。

LOAD 'filename'

### LOCK ###

锁定一个表。

LOCK [ TABLE ] name [, ...] [ IN lock_mode MODE ] [ NOWAIT ]

*lock\_mode* 可以是以下选项之一：

### MOVE ###

定位一个游标。

MOVE [ direction { FROM | IN } ] cursor_name

### NOTIFY ###

生成一个通知。

NOTIFY name

### PREPARE ###

创建一个准备好的查询。

PREPARE plan_name [ (data_type [, ...] ) ] AS statement

### REINDEX ###

重建索引。

REINDEX { DATABASE | TABLE | INDEX } name [ FORCE ]

### RELEASE SAVEPOINT ###

删除一个前面定义的保存点。

RELEASE [ SAVEPOINT ] savepoint_name

### RESET ###

把一个运行时参数值恢复为默认值。

RESET name
    RESET ALL

### REVOKE ###

删除访问权限。

REVOKE [ GRANT OPTION FOR ]
    { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
    [,...] | ALL [ PRIVILEGES ] }
    ON [ TABLE ] table_name [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
    { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
    ON DATABASE db_name [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
    { CREATE | ALL [ PRIVILEGES ] }
    ON TABLESPACE tablespace_name [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
    { EXECUTE | ALL [ PRIVILEGES ] }
    ON FUNCTION func_name ([type, ...]) [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
    { USAGE | ALL [ PRIVILEGES ] }
    ON LANGUAGE lang_name [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]
    
    REVOKE [ GRANT OPTION FOR ]
    { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
    ON SCHEMA schema_name [, ...]
    FROM { username | GROUP group_name | PUBLIC } [, ...]
    [ CASCADE | RESTRICT ]

### ROLLBACK ###

退出当前事务。

ROLLBACK [ WORK | TRANSACTION ]

### ROLLBACK TO SAVEPOINT ###

回滚到一个保存点。

ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name

### SAVEPOINT ###

在当前事务里定义一个新的保存点。

SAVEPOINT savepoint_name

### SELECT ###

从表或视图中取出若干行。

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
    * | expression [ AS output_name ] [, ...]
    [ FROM from_item [, ...] ]
    [ WHERE condition ]
    [ GROUP BY expression [, ...] ]
    [ HAVING condition [, ...] ]
    [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    [ FOR UPDATE [ OF table_name [, ...] ] ]

*from\_item* 可以是以下选项：

### SELECT INTO ###

从一个查询的结果中定义一个新表。

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
    * | expression [ AS output_name ] [, ...]
    INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table
    [ FROM from_item [, ...] ]
    [ WHERE condition ]
    [ GROUP BY expression [, ...] ]
    [ HAVING condition [, ...] ]
    [ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
    [ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
    [ LIMIT { count | ALL } ]
    [ OFFSET start ]
    [ FOR UPDATE [ OF table_name [, ...] ] ]

### SET ###

修改运行时参数。

SET [ SESSION | LOCAL ] name { TO | = } { value | 'value' | DEFAULT }
    SET [ SESSION | LOCAL ] TIME ZONE { time_zone | LOCAL | DEFAULT }

### SET CONSTRAINTS ###

设置当前事务的约束检查模式。

SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }

### SET SESSION AUTHORIZATION ###

为当前会话设置会话用户标识符和当前用户标识符。

SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
    SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
    RESET SESSION AUTHORIZATION

### SET TRANSACTION ###

开始一个事务块。

SET TRANSACTION transaction_mode [, ...]
    SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]

Where *transaction\_mode* is one of −

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
    | READ UNCOMMITTED }
    READ WRITE | READ ONLY

### SHOW ###

显示运行时参数的值。

SHOW name
    SHOW ALL

### START TRANSACTION ###

开始一个事务块。

START TRANSACTION [ transaction_mode [, ...] ]

*transaction\_mode* 可以是下面的选项之一：

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
    | READ UNCOMMITTED }
    READ WRITE | READ ONLY

### TRUNCATE ###

清空一个或一组表。

TRUNCATE [ TABLE ] name

### UNLISTEN ###

停止监听通知信息。

UNLISTEN { name | * }

### UPDATE ###

更新一个表中的行。

UPDATE [ ONLY ] table SET column = { expression | DEFAULT } [, ...]
    [ FROM from_list ]
    [ WHERE condition ]

### VACUUM ###

垃圾收集以及可选地分析一个数据库。

VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
    VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]

### VALUES ###

计算一个或一组行。

VALUES ( _expression_ [, ...] ) [, ...]
        [ ORDER BY _sort_expression_ [ ASC | DESC | USING _operator_ ] [, ...] ]
        [ LIMIT { _count_ | ALL } ]
        [ OFFSET _start_ [ ROW | ROWS ] ]
        [ FETCH { FIRST | NEXT } [ _count_ ] { ROW | ROWS } ONLY ]

# PostgreSQL 简单命令 #

如果记不住一些命令可以直接输入`\h [命令]`或者`\?`即可查看相应命令或用法，返回结果如下：

postgres-# \?
    General
      \copyright             show PostgreSQL usage and distribution terms
      \crosstabview [COLUMNS] execute query and display results in crosstab
      \errverbose            show most recent error message at maximum verbosity
      \g [FILE] or ;         execute query (and send results to file or |pipe)
      \gdesc                 describe result of query, without executing it
      \gexec                 execute query, then execute each value in its result
      \gset [PREFIX]         execute query and store results in psql variables
      \gx [FILE]             as \g, but forces expanded output mode
      \q                     quit psql
      \watch [SEC]           execute query every SEC seconds
    
    Help
      \? [commands]          show help on backslash commands
      \? options             show help on psql command-line options
      \? variables           show help on special variables
      \h [NAME]              help on syntax of SQL commands, * for all commands
    
    Query Buffer
      \e [FILE] [LINE]       edit the query buffer (or file) with external editor
      \ef [FUNCNAME [LINE]]  edit function definition with external editor
      \ev [VIEWNAME [LINE]]  edit view definition with external editor
      \p                     show the contents of the query buffer
      \r                     reset (clear) the query buffer
      \s [FILE]              display history or save it to file
      \w FILE                write query buffer to file
    
    Input/Output
      \copy ...              perform SQL COPY with data stream to the client host
      \echo [STRING]         write string to standard output
      \i FILE                execute commands from file
      \ir FILE               as \i, but relative to location of current script
      \o [FILE]              send all query results to file or |pipe
      \qecho [STRING]        write string to query output stream (see \o)
    
    Conditional
      \if EXPR               begin conditional block
      \elif EXPR             alternative within current conditional block
      \else                  final alternative within current conditional block
      \endif                 end conditional block
    
    Informational
      (options: S = show system objects, + = additional detail)
      \d[S+]                 list tables, views, and sequences
      \d[S+]  NAME           describe table, view, sequence, or index
      \da[S]  [PATTERN]      list aggregates
      \dA[+]  [PATTERN]      list access methods
      \db[+]  [PATTERN]      list tablespaces
      \dc[S+] [PATTERN]      list conversions
      \dC[+]  [PATTERN]      list casts
      \dd[S]  [PATTERN]      show object descriptions not displayed elsewhere
      \dD[S+] [PATTERN]      list domains
      \ddp    [PATTERN]      list default privileges
      \dE[S+] [PATTERN]      list foreign tables
      \det[+] [PATTERN]      list foreign tables
      \des[+] [PATTERN]      list foreign servers
      \deu[+] [PATTERN]      list user mappings
      \dew[+] [PATTERN]      list foreign-data wrappers
      \df[anptw][S+] [PATRN] list [only agg/normal/procedures/trigger/window] functions
      \dF[+]  [PATTERN]      list text search configurations
      \dFd[+] [PATTERN]      list text search dictionaries
      \dFp[+] [PATTERN]      list text search parsers
      \dFt[+] [PATTERN]      list text search templates
      \dg[S+] [PATTERN]      list roles
      \di[S+] [PATTERN]      list indexes
      \dl                    list large objects, same as \lo_list
      \dL[S+] [PATTERN]      list procedural languages
      \dm[S+] [PATTERN]      list materialized views
      \dn[S+] [PATTERN]      list schemas
      \do[S]  [PATTERN]      list operators
      \dO[S+] [PATTERN]      list collations
      \dp     [PATTERN]      list table, view, and sequence access privileges
      \drds [PATRN1 [PATRN2]] list per-database role settings
      \dRp[+] [PATTERN]      list replication publications
      \dRs[+] [PATTERN]      list replication subscriptions
      \ds[S+] [PATTERN]      list sequences
      \dt[S+] [PATTERN]      list tables
      \dT[S+] [PATTERN]      list data types
      \du[S+] [PATTERN]      list roles
      \dv[S+] [PATTERN]      list views
      \dx[+]  [PATTERN]      list extensions
      \dy     [PATTERN]      list event triggers
      \l[+]   [PATTERN]      list databases
      \sf[+]  FUNCNAME       show a function's definition
      \sv[+]  VIEWNAME       show a view's definition
      \z      [PATTERN]      same as \dp
    
    Formatting
      \a                     toggle between unaligned and aligned output mode
      \C [STRING]            set table title, or unset if none
      \f [STRING]            show or set field separator for unaligned query output
      \H                     toggle HTML output mode (currently off)
      \pset [NAME [VALUE]]   set table output option
                             (NAME := {border|columns|expanded|fieldsep|fieldsep_zero|
                             footer|format|linestyle|null|numericlocale|pager|
                             pager_min_lines|recordsep|recordsep_zero|tableattr|title|
                             tuples_only|unicode_border_linestyle|
                             unicode_column_linestyle|unicode_header_linestyle})
      \t [on|off]            show only rows (currently off)
      \T [STRING]            set HTML <table> tag attributes, or unset if none
      \x [on|off|auto]       toggle expanded output (currently off)
    
    Connection
      \c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}
                             connect to new database (currently "postgres")
      \conninfo              display information about current connection
      \encoding [ENCODING]   show or set client encoding
      \password [USERNAME]   securely change the password for a user
    
    Operating System
      \cd [DIR]              change the current working directory
      \setenv NAME [VALUE]   set or unset environment variable
      \timing [on|off]       toggle timing of commands (currently off)
      \! [COMMAND]           execute command in shell or start interactive shell
    
    Variables
      \prompt [TEXT] NAME    prompt user to set internal variable
      \set [NAME [VALUE]]    set internal variable, or list all if no parameters
      \unset NAME            unset (delete) internal variable
    
    Large Objects
      \lo_export LOBOID FILE
      \lo_import FILE [COMMENT]
      \lo_list
      \lo_unlink LOBOID      large object operations

查看所有命令(`\h`)

postgres-# \h
    Available help:
      ABORT                            ALTER TEXT SEARCH TEMPLATE       CREATE PUBLICATION               DROP FUNCTION                    IMPORT FOREIGN SCHEMA
      ALTER AGGREGATE                  ALTER TRIGGER                    CREATE ROLE                      DROP GROUP                       INSERT
      ALTER COLLATION                  ALTER TYPE                       CREATE RULE                      DROP INDEX                       LISTEN
      ALTER CONVERSION                 ALTER USER                       CREATE SCHEMA                    DROP LANGUAGE                    LOAD
      ALTER DATABASE                   ALTER USER MAPPING               CREATE SEQUENCE                  DROP MATERIALIZED VIEW           LOCK
      ALTER DEFAULT PRIVILEGES         ALTER VIEW                       CREATE SERVER                    DROP OPERATOR                    MOVE
      ALTER DOMAIN                     ANALYZE                          CREATE STATISTICS                DROP OPERATOR CLASS              NOTIFY
      ALTER EVENT TRIGGER              BEGIN                            CREATE SUBSCRIPTION              DROP OPERATOR FAMILY             PREPARE
      ALTER EXTENSION                  CALL                             CREATE TABLE                     DROP OWNED                       PREPARE TRANSACTION
      ALTER FOREIGN DATA WRAPPER       CHECKPOINT                       CREATE TABLE AS                  DROP POLICY                      REASSIGN OWNED
      ALTER FOREIGN TABLE              CLOSE                            CREATE TABLESPACE                DROP PROCEDURE                   REFRESH MATERIALIZED VIEW
      ALTER FUNCTION                   CLUSTER                          CREATE TEXT SEARCH CONFIGURATION DROP PUBLICATION                 REINDEX
      ALTER GROUP                      COMMENT                          CREATE TEXT SEARCH DICTIONARY    DROP ROLE                        RELEASE SAVEPOINT
      ALTER INDEX                      COMMIT                           CREATE TEXT SEARCH PARSER        DROP ROUTINE                     RESET
      ALTER LANGUAGE                   COMMIT PREPARED                  CREATE TEXT SEARCH TEMPLATE      DROP RULE                        REVOKE
      ALTER LARGE OBJECT               COPY                             CREATE TRANSFORM                 DROP SCHEMA                      ROLLBACK
      ALTER MATERIALIZED VIEW          CREATE ACCESS METHOD             CREATE TRIGGER                   DROP SEQUENCE                    ROLLBACK PREPARED
      ALTER OPERATOR                   CREATE AGGREGATE                 CREATE TYPE                      DROP SERVER                      ROLLBACK TO SAVEPOINT
      ALTER OPERATOR CLASS             CREATE CAST                      CREATE USER                      DROP STATISTICS                  SAVEPOINT
      ALTER OPERATOR FAMILY            CREATE COLLATION                 CREATE USER MAPPING              DROP SUBSCRIPTION                SECURITY LABEL
      ALTER POLICY                     CREATE CONVERSION                CREATE VIEW                      DROP TABLE                       SELECT
      ALTER PROCEDURE                  CREATE DATABASE                  DEALLOCATE                       DROP TABLESPACE                  SELECT INTO
      ALTER PUBLICATION                CREATE DOMAIN                    DECLARE                          DROP TEXT SEARCH CONFIGURATION   SET
      ALTER ROLE                       CREATE EVENT TRIGGER             DELETE                           DROP TEXT SEARCH DICTIONARY      SET CONSTRAINTS
      ALTER ROUTINE                    CREATE EXTENSION                 DISCARD                          DROP TEXT SEARCH PARSER          SET ROLE
      ALTER RULE                       CREATE FOREIGN DATA WRAPPER      DO                               DROP TEXT SEARCH TEMPLATE        SET SESSION AUTHORIZATION
      ALTER SCHEMA                     CREATE FOREIGN TABLE             DROP ACCESS METHOD               DROP TRANSFORM                   SET TRANSACTION
      ALTER SEQUENCE                   CREATE FUNCTION                  DROP AGGREGATE                   DROP TRIGGER                     SHOW
      ALTER SERVER                     CREATE GROUP                     DROP CAST                        DROP TYPE                        START TRANSACTION
      ALTER STATISTICS                 CREATE INDEX                     DROP COLLATION                   DROP USER                        TABLE
      ALTER SUBSCRIPTION               CREATE LANGUAGE                  DROP CONVERSION                  DROP USER MAPPING                TRUNCATE
      ALTER SYSTEM                     CREATE MATERIALIZED VIEW         DROP DATABASE                    DROP VIEW                        UNLISTEN
      ALTER TABLE                      CREATE OPERATOR                  DROP DOMAIN                      END                              UPDATE
      ALTER TABLESPACE                 CREATE OPERATOR CLASS            DROP EVENT TRIGGER               EXECUTE                          VACUUM
      ALTER TEXT SEARCH CONFIGURATION  CREATE OPERATOR FAMILY           DROP EXTENSION                   EXPLAIN                          VALUES
      ALTER TEXT SEARCH DICTIONARY     CREATE POLICY                    DROP FOREIGN DATA WRAPPER        FETCH                            WITH
      ALTER TEXT SEARCH PARSER         CREATE PROCEDURE                 DROP FOREIGN TABLE               GRANT

查看具体某个命令的使用方法(`\h [command]`)

postgres-# \h CREATE PUBLICATION
    Command:     CREATE PUBLICATION
    Description: define a new publication
    Syntax:
    CREATE PUBLICATION name
        [ FOR TABLE [ ONLY ] table_name [ * ] [, ...]
          | FOR ALL TABLES ]
        [ WITH ( publication_parameter [= value] [, ... ] ) ]
        
        
    postgres-# \h ALTER TABLE
    Command:     ALTER TABLE
    Description: change the definition of a table
    Syntax:
    ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
        action [, ... ]
    ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
        RENAME [ COLUMN ] column_name TO new_column_name
    ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
        RENAME CONSTRAINT constraint_name TO new_constraint_name
    ALTER TABLE [ IF EXISTS ] name
        RENAME TO new_name
    ALTER TABLE [ IF EXISTS ] name
        SET SCHEMA new_schema
    ALTER TABLE ALL IN TABLESPACE name [ OWNED BY role_name [, ... ] ]
        SET TABLESPACE new_tablespace [ NOWAIT ]
    ALTER TABLE [ IF EXISTS ] name
        ATTACH PARTITION partition_name { FOR VALUES partition_bound_spec | DEFAULT }
    ALTER TABLE [ IF EXISTS ] name
        DETACH PARTITION partition_name
        ..........

# PostgreSQL 数据类型 #

本章节，我们将讨论 PostgreSQL 的数据类型，数据类型是我们再创建表的时候为每个字段设置的。

设置数据类型的好处：

PostgreSQL提供了丰富的数据类型。用户可以使用 CREATE TYPE 命令在数据库中创建新的数据类型。PostgreSQL 的数据类型有很多种，下面我们具体来说明。

--------------------

## 数值类型 ##

数值类型由 2 字节、4 字节或 8 字节的整数以及 4 字节或 8 字节的浮点数和可选精度的十进制数组成。

下表列出了可用的数值类型。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">存储长度</th> 
   <th align="left">描述</th> 
   <th align="left">范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">smallint</td> 
   <td align="left">2 字节</td> 
   <td align="left">小范围整数</td> 
   <td align="left">-32768 到 +32767</td> 
  </tr> 
  <tr> 
   <td align="left">integer</td> 
   <td align="left">4 字节</td> 
   <td align="left">常用的整数</td> 
   <td align="left">-2147483648 到 +2147483647</td> 
  </tr> 
  <tr> 
   <td align="left">bigint</td> 
   <td align="left">8 字节</td> 
   <td align="left">大范围整数</td> 
   <td align="left">-9223372036854775808 到 +9223372036854775807</td> 
  </tr> 
  <tr> 
   <td align="left">decimal</td> 
   <td align="left">可变长</td> 
   <td align="left">用户指定的精度，精确</td> 
   <td align="left">小数点前 131072 位；小数点后 16383 位</td> 
  </tr> 
  <tr> 
   <td align="left">numeric</td> 
   <td align="left">可变长</td> 
   <td align="left">用户指定的精度，精确</td> 
   <td align="left">小数点前 131072 位；小数点后 16383 位</td> 
  </tr> 
  <tr> 
   <td align="left">real</td> 
   <td align="left">4 字节</td> 
   <td align="left">可变精度，不精确</td> 
   <td align="left">6 位十进制数字精度</td> 
  </tr> 
  <tr> 
   <td align="left">double precision</td> 
   <td align="left">8 字节</td> 
   <td align="left">可变精度，不精确</td> 
   <td align="left">15 位十进制数字精度</td> 
  </tr> 
  <tr> 
   <td align="left">smallserial</td> 
   <td align="left">2 字节</td> 
   <td align="left">自增的小范围整数</td> 
   <td align="left">1 到 32767</td> 
  </tr> 
  <tr> 
   <td align="left">serial</td> 
   <td align="left">4 字节</td> 
   <td align="left">自增整数</td> 
   <td align="left">1 到 2147483647</td> 
  </tr> 
  <tr> 
   <td align="left">bigserial</td> 
   <td align="left">8 字节</td> 
   <td align="left">自增的大范围整数</td> 
   <td align="left">1 到 9223372036854775807</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 货币类型 ##

money 类型存储带有固定小数精度的货币金额。

numeric、int 和 bigint 类型的值可以转换为 money，不建议使用浮点数来处理货币类型，因为存在舍入错误的可能性。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">存储容量</th> 
   <th align="left">描述</th> 
   <th align="left">范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">money</td> 
   <td align="left">8 字节</td> 
   <td align="left">货币金额</td> 
   <td align="left">-92233720368547758.08 到 +92233720368547758.07</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 字符类型 ##

下表列出了 PostgreSQL 所支持的字符类型：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">名字 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>character varying(n), varchar(n)</strong> 变长，有长度限制</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center"><strong>character(n), char(n)</strong> f定长,不足补空白</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="center"><strong>text</strong> 变长，无长度限制</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 日期/时间类型 ##

下表列出了 PostgreSQL 支持的日期和时间类型。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">存储空间</th> 
   <th align="left">描述</th> 
   <th align="left">最低值</th> 
   <th align="left">最高值</th> 
   <th align="left">分辨率</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">timestamp [ (<em>p</em>) ] [ without time zone ]</td> 
   <td align="left">8 字节</td> 
   <td align="left">日期和时间(无时区)</td> 
   <td align="left">4713 BC</td> 
   <td align="left">294276 AD</td> 
   <td align="left">1 毫秒 / 14 位</td> 
  </tr> 
  <tr> 
   <td align="left">timestamp [ (<em>p</em>) ] with time zone</td> 
   <td align="left">8 字节</td> 
   <td align="left">日期和时间，有时区</td> 
   <td align="left">4713 BC</td> 
   <td align="left">294276 AD</td> 
   <td align="left">1 毫秒 / 14 位</td> 
  </tr> 
  <tr> 
   <td align="left">date</td> 
   <td align="left">4 字节</td> 
   <td align="left">只用于日期</td> 
   <td align="left">4713 BC</td> 
   <td align="left">5874897 AD</td> 
   <td align="left">1 天</td> 
  </tr> 
  <tr> 
   <td align="left">time [ (<em>p</em>) ] [ without time zone ]</td> 
   <td align="left">8 字节</td> 
   <td align="left">只用于一日内时间</td> 
   <td align="left">00:00:00</td> 
   <td align="left">24:00:00</td> 
   <td align="left">1 毫秒 / 14 位</td> 
  </tr> 
  <tr> 
   <td align="left">time [ (<em>p</em>) ] with time zone</td> 
   <td align="left">12 字节</td> 
   <td align="left">只用于一日内时间，带时区</td> 
   <td align="left">00:00:00+1459</td> 
   <td align="left">24:00:00-1459</td> 
   <td align="left">1 毫秒 / 14 位</td> 
  </tr> 
  <tr> 
   <td align="left">interval [ <em>fields</em> ] [ (<em>p</em>) ]</td> 
   <td align="left">12 字节</td> 
   <td align="left">时间间隔</td> 
   <td align="left">-178000000 年</td> 
   <td align="left">178000000 年</td> 
   <td align="left">1 毫秒 / 14 位</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 布尔类型 ##

PostgreSQL 支持标准的 boolean 数据类型。

boolean 有"true"(真)或"false"(假)两个状态， 第三种"unknown"(未知)状态，用 NULL 表示。

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">存储格式</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">boolean</td> 
   <td align="left">1 字节</td> 
   <td align="left">true/false</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 枚举类型 ##

枚举类型是一个包含静态和值的有序集合的数据类型。

PostgtesSQL中的枚举类型类似于 C 语言中的 enum 类型。

与其他类型不同的是枚举类型需要使用 CREATE TYPE 命令创建。

CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');

创建一周中的几天，如下所示:

CREATE TYPE week AS ENUM ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

就像其他类型一样，一旦创建，枚举类型可以用于表和函数定义。

CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
    CREATE TABLE person (
        name text,
        current_mood mood
    );
    INSERT INTO person VALUES ('Moe', 'happy');
    SELECT * FROM person WHERE current_mood = 'happy';
     name | current_mood 
    ------+--------------
     Moe  | happy
    (1 row)

--------------------

## 几何类型 ##

几何数据类型表示二维的平面物体。

下表列出了 PostgreSQL 支持的几何类型。

最基本的类型：点。它是其它类型的基础。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">存储空间</th> 
   <th align="left">说明</th> 
   <th align="left">表现形式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">point</td> 
   <td align="left">16 字节</td> 
   <td align="left">平面中的点</td> 
   <td align="left">(x,y)</td> 
  </tr> 
  <tr> 
   <td align="left">line</td> 
   <td align="left">32 字节</td> 
   <td align="left">(无穷)直线(未完全实现)</td> 
   <td align="left">((x1,y1),(x2,y2))</td> 
  </tr> 
  <tr> 
   <td align="left">lseg</td> 
   <td align="left">32 字节</td> 
   <td align="left">(有限)线段</td> 
   <td align="left">((x1,y1),(x2,y2))</td> 
  </tr> 
  <tr> 
   <td align="left">box</td> 
   <td align="left">32 字节</td> 
   <td align="left">矩形</td> 
   <td align="left">((x1,y1),(x2,y2))</td> 
  </tr> 
  <tr> 
   <td align="left">path</td> 
   <td align="left">16+16n 字节</td> 
   <td align="left">闭合路径(与多边形类似)</td> 
   <td align="left">((x1,y1),…)</td> 
  </tr> 
  <tr> 
   <td align="left">path</td> 
   <td align="left">16+16n 字节</td> 
   <td align="left">开放路径</td> 
   <td align="left">[(x1,y1),…]</td> 
  </tr> 
  <tr> 
   <td align="left">polygon</td> 
   <td align="left">40+16n 字节</td> 
   <td align="left">多边形(与闭合路径相似)</td> 
   <td align="left">((x1,y1),…)</td> 
  </tr> 
  <tr> 
   <td align="left">circle</td> 
   <td align="left">24 字节</td> 
   <td align="left">圆</td> 
   <td align="left">&lt;(x,y),r&gt; (圆心和半径)</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 网络地址类型 ##

PostgreSQL 提供用于存储 IPv4 、IPv6 、MAC 地址的数据类型。

用这些数据类型存储网络地址比用纯文本类型好， 因为这些类型提供输入错误检查和特殊的操作和功能。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">存储空间</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">cidr</td> 
   <td align="left">7 或 19 字节</td> 
   <td align="left">IPv4 或 IPv6 网络</td> 
  </tr> 
  <tr> 
   <td align="left">inet</td> 
   <td align="left">7 或 19 字节</td> 
   <td align="left">IPv4 或 IPv6 主机和网络</td> 
  </tr> 
  <tr> 
   <td align="left">macaddr</td> 
   <td align="left">6 字节</td> 
   <td align="left">MAC 地址</td> 
  </tr> 
 </tbody> 
</table>

在对 inet 或 cidr 数据类型进行排序的时候， IPv4 地址总是排在 IPv6 地址前面，包括那些封装或者是映射在 IPv6 地址里的 IPv4 地址， 比如 ::10.2.3.4 或 ::ffff:10.4.3.2。

--------------------

## 位串类型 ##

位串就是一串 1 和 0 的字符串。它们可以用于存储和直观化位掩码。 我们有两种 SQL 位类型：bit(n) 和bit varying(n)， 这里的n是一个正整数。

bit 类型的数据必须准确匹配长度 n， 试图存储短些或者长一些的数据都是错误的。bit varying 类型数据是最长 n 的变长类型；更长的串会被拒绝。 写一个没有长度的bit 等效于 bit(1)， 没有长度的 bit varying 意思是没有长度限制。

--------------------

## 文本搜索类型 ##

全文检索即通过自然语言文档的集合来找到那些匹配一个查询的检索。

PostgreSQL 提供了两种数据类型用于支持全文检索：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">名字 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>tsvector</strong> tsvector 的值是一个无重复值的 lexemes 排序列表， 即一些同一个词的不同变种的标准化。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center"><strong>tsquery</strong> tsquery 存储用于检索的词汇，并且使用布尔操作符 &amp;(AND)，|(OR)和!(NOT) 来组合它们，括号用来强调操作符的分组。</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## UUID 类型 ##

uuid 数据类型用来存储 RFC 4122，ISO/IEF 9834-8:2005 以及相关标准定义的通用唯一标识符（UUID）。 （一些系统认为这个数据类型为全球唯一标识符，或GUID。） 这个标识符是一个由算法产生的 128 位标识符，使它不可能在已知使用相同算法的模块中和其他方式产生的标识符相同。 因此，对分布式系统而言，这种标识符比序列能更好的提供唯一性保证，因为序列只能在单一数据库中保证唯一。

UUID 被写成一个小写十六进制数字的序列，由分字符分成几组， 特别是一组8位数字+3组4位数字+一组12位数字，总共 32 个数字代表 128 位， 一个这种标准的 UUID 例子如下：

a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11

--------------------

## XML 类型 ##

xml 数据类型可以用于存储XML数据。 将 XML 数据存到 text 类型中的优势在于它能够为结构良好性来检查输入值， 并且还支持函数对其进行类型安全性检查。 要使用这个数据类型，编译时必须使用 **configure --with-libxml**。

xml 可以存储由XML标准定义的格式良好的"文档"， 以及由 XML 标准中的 **XMLDecl? content** 定义的"内容"片段， 大致上，这意味着内容片段可以有多个顶级元素或字符节点。 xmlvalue IS DOCUMENT 表达式可以用来判断一个特定的 xml 值是一个完整的文件还是内容片段。

### 创建XML值 ###

使用函数 xmlparse: 来从字符数据产生 xml 类型的值：

XMLPARSE (DOCUMENT '<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter></book>')
    XMLPARSE (CONTENT 'abc<foo>bar</foo><bar>foo</bar>')

--------------------

## JSON 类型 ##

json 数据类型可以用来存储 JSON（JavaScript Object Notation）数据， 这样的数据也可以存储为 text，但是 json 数据类型更有利于检查每个存储的数值是可用的 JSON 值。

此外还有相关的函数来处理 json 数据：

<table> 
 <thead> 
  <tr> 
   <th align="center">实例</th> 
   <th align="center">实例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">array_to_json(’{ {1,5},{99,100}}’::int[])</td> 
   <td align="center">[[1,5],[99,100]]</td> 
  </tr> 
  <tr> 
   <td align="center">row_to_json(row(1,‘foo’))</td> 
   <td align="center">{“f1”:1,“f2”:“foo”}</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 数组类型 ##

PostgreSQL 允许将字段定义成变长的多维数组。

数组类型可以是任何基本类型或用户定义类型，枚举类型或复合类型。

### 声明数组 ###

创建表的时候，我们可以声明数组，方式如下：

CREATE TABLE sal_emp (
        name            text,
        pay_by_quarter  integer[],
        schedule        text[][]
    );

pay\_by\_quarter 为一位整型数组、schedule 为二维文本类型数组。

我们也可以使用 “ARRAY” 关键字，如下所示：

CREATE TABLE sal_emp (
       name text,
       pay_by_quarter integer ARRAY[4],
       schedule text[][]
    );

### 插入值 ###

插入值使用花括号 \{\}，元素在 \{\} 使用逗号隔开：

INSERT INTO sal_emp
        VALUES ('Bill',
        '{10000, 10000, 10000, 10000}',
        '{ {"meeting", "lunch"}, {"training", "presentation"}}');
    
    INSERT INTO sal_emp
        VALUES ('Carol',
        '{20000, 25000, 25000, 25000}',
        '{ {"breakfast", "consulting"}, {"meeting", "lunch"}}');

### 访问数组 ###

现在我们可以在这个表上运行一些查询。

首先，我们演示如何访问数组的一个元素。 这个查询检索在第二季度薪水变化的雇员名：

SELECT name FROM sal_emp WHERE pay_by_quarter[1] <> pay_by_quarter[2];
    
     name
    -------
     Carol
    (1 row)

数组的下标数字是写在方括弧内的。

### 修改数组 ###

我们可以对数组的值进行修改：

UPDATE sal_emp SET pay_by_quarter = '{25000,25000,27000,27000}'
        WHERE name = 'Carol';

或者使用 ARRAY 构造器语法：

UPDATE sal_emp SET pay_by_quarter = ARRAY[25000,25000,27000,27000]
        WHERE name = 'Carol';

### 数组中检索 ###

要搜索一个数组中的数值，你必须检查该数组的每一个值。

比如：

SELECT * FROM sal_emp WHERE pay_by_quarter[1] = 10000 OR
                                pay_by_quarter[2] = 10000 OR
                                pay_by_quarter[3] = 10000 OR
                                pay_by_quarter[4] = 10000;

另外，你可以用下面的语句找出数组中所有元素值都等于 10000 的行：

SELECT * FROM sal_emp WHERE 10000 = ALL (pay_by_quarter);

或者，可以使用 generate\_subscripts 函数。例如：

SELECT * FROM
       (SELECT pay_by_quarter,
               generate_subscripts(pay_by_quarter, 1) AS s
          FROM sal_emp) AS foo
     WHERE pay_by_quarter[s] = 10000;

--------------------

## 复合类型 ##

复合类型表示一行或者一条记录的结构； 它实际上只是一个字段名和它们的数据类型的列表。PostgreSQL 允许像简单数据类型那样使用复合类型。比如，一个表的某个字段可以声明为一个复合类型。

### 声明复合类型 ###

下面是两个定义复合类型的简单例子：

CREATE TYPE complex AS (
        r       double precision,
        i       double precision
    );
    
    CREATE TYPE inventory_item AS (
        name            text,
        supplier_id     integer,
        price           numeric
    );

语法类似于 CREATE TABLE，只是这里只可以声明字段名字和类型。

定义了类型，我们就可以用它创建表：

CREATE TABLE on_hand (
        item      inventory_item,
        count     integer
    );
    
    INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);

### 复合类型值输入 ###

要以文本常量书写复合类型值，在圆括弧里包围字段值并且用逗号分隔他们。 你可以在任何字段值周围放上双引号，如果值本身包含逗号或者圆括弧， 你必须用双引号括起。

复合类型常量的一般格式如下：

'( val1 , val2 , ... )'

一个例子是:

'("fuzzy dice",42,1.99)'

### 访问复合类型 ###

要访问复合类型字段的一个域，我们写出一个点以及域的名字， 非常类似从一个表名字里选出一个字段。实际上，因为实在太像从表名字中选取字段， 所以我们经常需要用圆括弧来避免分析器混淆。比如，你可能需要从on\_hand 例子表中选取一些子域，像下面这样：

SELECT item.name FROM on_hand WHERE item.price > 9.99;

这样将不能工作，因为根据 SQL 语法，item是从一个表名字选取的， 而不是一个字段名字。你必须像下面这样写：

SELECT (item).name FROM on_hand WHERE (item).price > 9.99;

或者如果你也需要使用表名字(比如，在一个多表查询里)，那么这么写：

SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;

现在圆括弧对象正确地解析为一个指向item字段的引用，然后就可以从中选取子域。

--------------------

## 范围类型 ##

范围数据类型代表着某一元素类型在一定范围内的值。

例如，timestamp 范围可能被用于代表一间会议室被预定的时间范围。

PostgreSQL 内置的范围类型有：

*  int4range — integer的范围
 *  int8range —bigint的范围
 *  numrange —numeric的范围
 *  tsrange —timestamp without time zone的范围
 *  tstzrange —timestamp with time zone的范围
 *  daterange —date的范围

此外，你可以定义你自己的范围类型。

CREATE TABLE reservation (room int, during tsrange);
    INSERT INTO reservation VALUES
        (1108, '[2010-01-01 14:30, 2010-01-01 15:30)');
    
    -- 包含
    SELECT int4range(10, 20) @> 3;
    
    -- 重叠
    SELECT numrange(11.1, 22.2) && numrange(20.0, 30.0);
    
    -- 提取上边界
    SELECT upper(int8range(15, 25));
    
    -- 计算交叉
    SELECT int4range(10, 20) * int4range(15, 25);
    
    -- 范围是否为空
    SELECT isempty(numrange(1, 5));

范围值的输入必须遵循下面的格式：

(下边界,上边界)
    (下边界,上边界]
    [下边界,上边界)
    [下边界,上边界]
    空

圆括号或者方括号显示下边界和上边界是不包含的还是包含的。注意最后的格式是 空，代表着一个空的范围（一个不含有值的范围）。

-- 包括3，不包括7，并且包括二者之间的所有点
    SELECT '[3,7)'::int4range;
    
    -- 不包括3和7，但是包括二者之间所有点
    SELECT '(3,7)'::int4range;
    
    -- 只包括单一值4
    SELECT '[4,4]'::int4range;
    
    -- 不包括点（被标准化为‘空’）
    SELECT '[4,4)'::int4range;

--------------------

## 对象标识符类型 ##

PostgreSQL 在内部使用对象标识符(OID)作为各种系统表的主键。

同时，系统不会给用户创建的表增加一个 OID 系统字段(除非在建表时声明了WITH OIDS 或者配置参数default\_with\_oids设置为开启)。oid 类型代表一个对象标识符。除此以外 oid 还有几个别名：regproc, regprocedure, regoper, regoperator, regclass, regtype, regconfig, 和regdictionary。

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">引用</th> 
   <th align="left">描述</th> 
   <th align="left">数值例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">oid</td> 
   <td align="left">任意</td> 
   <td align="left">数字化的对象标识符</td> 
   <td align="left">564182</td> 
  </tr> 
  <tr> 
   <td align="left">regproc</td> 
   <td align="left">pg_proc</td> 
   <td align="left">函数名字</td> 
   <td align="left">sum</td> 
  </tr> 
  <tr> 
   <td align="left">regprocedure</td> 
   <td align="left">pg_proc</td> 
   <td align="left">带参数类型的函数</td> 
   <td align="left">sum(int4)</td> 
  </tr> 
  <tr> 
   <td align="left">regoper</td> 
   <td align="left">pg_operator</td> 
   <td align="left">操作符名</td> 
   <td align="left">+</td> 
  </tr> 
  <tr> 
   <td align="left">regoperator</td> 
   <td align="left">pg_operator</td> 
   <td align="left">带参数类型的操作符</td> 
   <td align="left">*(integer,integer) 或 -(NONE,integer)</td> 
  </tr> 
  <tr> 
   <td align="left">regclass</td> 
   <td align="left">pg_class</td> 
   <td align="left">关系名</td> 
   <td align="left">pg_type</td> 
  </tr> 
  <tr> 
   <td align="left">regtype</td> 
   <td align="left">pg_type</td> 
   <td align="left">数据类型名</td> 
   <td align="left">integer</td> 
  </tr> 
  <tr> 
   <td align="left">regconfig</td> 
   <td align="left">pg_ts_config</td> 
   <td align="left">文本搜索配置</td> 
   <td align="left">english</td> 
  </tr> 
  <tr> 
   <td align="left">regdictionary</td> 
   <td align="left">pg_ts_dict</td> 
   <td align="left">文本搜索字典</td> 
   <td align="left">simple</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 伪类型 ##

PostgreSQL类型系统包含一系列特殊用途的条目， 它们按照类别来说叫做伪类型。伪类型不能作为字段的数据类型， 但是它可以用于声明一个函数的参数或者结果类型。 伪类型在一个函数不只是简单地接受并返回某种SQL 数据类型的情况下很有用。

下表列出了所有的伪类型：

<table> 
 <thead> 
  <tr> 
   <th align="left">名字</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">any</td> 
   <td align="left">表示一个函数接受任何输入数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">anyelement</td> 
   <td align="left">表示一个函数接受任何数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">anyarray</td> 
   <td align="left">表示一个函数接受任意数组数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">anynonarray</td> 
   <td align="left">表示一个函数接受任意非数组数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">anyenum</td> 
   <td align="left">表示一个函数接受任意枚举数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">anyrange</td> 
   <td align="left">表示一个函数接受任意范围数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">cstring</td> 
   <td align="left">表示一个函数接受或者返回一个空结尾的 C 字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">internal</td> 
   <td align="left">表示一个函数接受或者返回一种服务器内部的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left">language_handler</td> 
   <td align="left">一个过程语言调用处理器声明为返回language_handler。</td> 
  </tr> 
  <tr> 
   <td align="left">fdw_handler</td> 
   <td align="left">一个外部数据封装器声明为返回fdw_handler。</td> 
  </tr> 
  <tr> 
   <td align="left">record</td> 
   <td align="left">标识一个函数返回一个未声明的行类型。</td> 
  </tr> 
  <tr> 
   <td align="left">trigger</td> 
   <td align="left">一个触发器函数声明为返回trigger。</td> 
  </tr> 
  <tr> 
   <td align="left">void</td> 
   <td align="left">表示一个函数不返回数值。</td> 
  </tr> 
  <tr> 
   <td align="left">opaque</td> 
   <td align="left">一个已经过时的类型，以前用于所有上面这些用途。</td> 
  </tr> 
 </tbody> 
</table>

> 更多内容参考：[PostgreSQL 数据类型][PostgreSQL]

# PostgreSQL 创建数据库 #

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

1.  使用 **CREATE DATABASE** SQL 语句来创建。
2.  使用 **createdb** 命令来创建。
3.  使用 **pgAdmin** 工具。

## 1.CREATE DATABASE 创建数据库 ##

CREATE DATABASE 命令需要在 PostgreSQL 命令窗口来执行，语法格式如下：

CREATE DATABASE runoobdb;

例如，我们创建一个 mydb的数据库：

postgres=# CREATE DATABASE runoobdb;

## 2.createdb 命令创建数据库 ##

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

createdb 命令语法格式如下：

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

**参数说明：**

**dbname**：要创建的数据库名。

**description**：关于新创建的数据库相关的说明。

**options**：参数可选项，可以是以下值：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">选项 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>-D tablespace</strong>指定数据库默认表空间。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center"><strong>-e</strong>将 createdb 生成的命令发送到服务端。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="center"><strong>-E encoding</strong>指定数据库的编码。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="center"><strong>-l locale</strong>指定数据库的语言环境。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="center"><strong>-T template</strong>指定创建此数据库的模板。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="center"><strong>–help</strong>显示 createdb 命令的帮助信息。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="center"><strong>-h host</strong>指定服务器的主机名。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="center"><strong>-p port</strong>指定服务器监听的端口，或者 socket 文件。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="center"><strong>-U username</strong>连接数据库的用户名。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="center"><strong>-w</strong>忽略输入密码。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="center"><strong>-W</strong>连接时强制要求输入密码。</td> 
  </tr> 
 </tbody> 
</table>

接下来我们打开一个命令窗口，进入到 PostgreSQL 的安装目录，并进入到 bin 目录，createdb 命令位于 **PostgreSQL安装目录/bin** 下，执行创建数据库的命令：

$ cd /Library/PostgreSQL/11/bin/
    $ createdb -h localhost -p 5432 -U postgres runoobdb
    password ******

以上命令我们使用了超级用户 postgres 登录到主机地址为 localhost，端口号为 5432 的 PostgreSQL 数据库中并创建 runoobdb数据库。

## 3.pgAdmin 工具创建数据库 ##

pgAdmin 工具提供了完整操作数据库的功能：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qMBBP0dX-1586511657126)(img/1586321429790.png)\]

# PostgreSQL 选择数据库 #

### 数据库的命令窗口 ###

PostgreSQL 命令窗口中，我们可以命令提示符后面输入 SQL 语句：

postgres=#

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

postgres=# \l
                                 List of databases
       Name    |  Owner   | Encoding | Collate | Ctype |   Access privileges   
    -----------+----------+----------+---------+-------+-----------------------
     postgres  | postgres | UTF8     | C       | C     | 
     runoobdb  | postgres | UTF8     | C       | C     | 
     template0 | postgres | UTF8     | C       | C     | =c/postgres          +
               |          |          |         |       | postgres=CTc/postgres
     template1 | postgres | UTF8     | C       | C     | =c/postgres          +
               |          |          |         |       | postgres=CTc/postgres
    (4 rows)

接下来我们可以使用 `\c + 数据库名` 来进入数据库：

postgres=# \c runoobdb
    You are now connected to database "runoobdb" as user "postgres".
    runoobdb=#

### 系统命令行窗口 ###

在系统的命令行查看，我么可以在连接数据库后面添加数据库名来选择数据库：

$ psql -h localhost -p 5432 -U postgress testdb
    Password for user postgress: ****
    psql (11.3)
    Type "help" for help.
    You are now connected to database "runoobdb" as user "postgres".
    runoobdb=#

### pgAdmin 工具 ###

pgAdmin 工具更简单了，直接点击数据库选择就好了，还可以查看一些数据库额外的信息：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1F9HpJLb-1586511657128)(img/1586321833014.png)\]

# PostgreSQL 删除数据库 #

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

1.  使用`DROP DATABASE` SQL 语句来删除。
2.  使用 `dropdb` 命令来删除。
3.  使用 `pgAdmin` 工具。

\*\*注意：\*\*删除数据库要谨慎操作，一旦删除，所有信息都会消失。

### DROP DATABASE 删除数据库 ###

DROP DATABASE 会删除数据库的系统目录项并且删除包含数据的文件目录。

DROP DATABASE 只能由超级管理员或数据库拥有者执行。

DROP DATABASE 命令需要在 PostgreSQL 命令窗口来执行，语法格式如下：

DROP DATABASE [ IF EXISTS ] name

**参数说明：**

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

例如，我们删除一个 runoobdb 的数据库：

postgres=# DROP DATABASE runoobdb;

### dropdb 命令删除数据库 ###

dropdb 是 DROP DATABASE 的包装器。

dropdb 用于删除 PostgreSQL 数据库。

dropdb 命令只能由超级管理员或数据库拥有者执行。

dropdb 命令语法格式如下：

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

**参数说明：**

**dbname**：要删除的数据库名。

**options**：参数可选项，可以是以下值：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">选项 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>-e</strong>显示 dropdb 生成的命令并发送到数据库服务器。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center"><strong>-i</strong>在做删除的工作之前发出一个验证提示。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="center"><strong>-V</strong>打印 dropdb 版本并退出。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="center"><strong>–if-exists</strong>如果数据库不存在则发出提示信息，而不是错误信息。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="center"><strong>–help</strong>显示有关 dropdb 命令的帮助信息。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="center"><strong>-h host</strong>指定运行服务器的主机名。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="center"><strong>-p port</strong>指定服务器监听的端口，或者 socket 文件。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="center"><strong>-U username</strong>连接数据库的用户名。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="center"><strong>-w</strong>连接数据库的用户名。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="center"><strong>-W</strong>连接时强制要求输入密码。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="center"><strong>–maintenance-db=dbname</strong>删除数据库时指定连接的数据库，默认为 postgres，如果它不存在则使用 template1。</td> 
  </tr> 
 </tbody> 
</table>

接下来我们打开一个命令窗口，进入到 PostgreSQL 的安装目录，并进入到 bin 目录，dropdb 名位于 **PostgreSQL安装目录/bin** 下，执行删除数据库的命令：

$ cd /Library/PostgreSQL/11/bin/
    $ dropdb -h localhost -p 5432 -U postgres runoobdb
    password ******

以上命令我们使用了超级用户 postgres 登录到主机地址为 localhost，端口号为 5432 的 PostgreSQL 数据库中并删除 runoobdb 数据库。

### pgAdmin 工具删除据库 ###

pgAdmin 工具提供了完整操作数据库的功能：

![1586321979975][]

# PostgreSQL 创建表格 #

PostgreSQL 使用 CREATE TABLE 语句来创建数据库表格。

### 语法 ###

**CREATE TABLE** 语法格式如下：

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

**CREATE TABLE** 是一个关键词，用于告诉数据库系统将创建一个数据表。

表名字必需在同一模式中的其它表、 序列、索引、视图或外部表名字中唯一。

**CREATE TABLE** 在当前数据库创建一个新的空白表，该表将由发出此命令的用户所拥有。

表格中的每个字段都会定义数据类型，如下：

### 实例 ###

以下创建了一个表，表名为 **COMPANY** 表格，主键为 **ID**，**NOT NULL** 表示字段不允许包含 **NULL** 值：

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

接下来我们再创建一个表格，在后面章节会用到：

CREATE TABLE DEPARTMENT(
       ID INT PRIMARY KEY      NOT NULL,
       DEPT           CHAR(50) NOT NULL,
       EMP_ID         INT      NOT NULL
    );

我们可以使用 **\\d** 命令来查看表格是否创建成功：

**\\d tablename** 查看表格信息：

# PostgreSQL 删除表格 #

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

### 语法 ###

**DROP TABLE** 语法格式如下：

DROP TABLE table_name;

### 实例 ###

上一章节中我们创建了 COMPANY 和 DEPARTMENT 两个表格，我们可以先使用 **\\d** 命令来查看表格是否创建成功：

从以上结果可以看出，我们表格已经创建成功，接下来我们删除这两个表格：

runoobdb=# drop table department, company;
    DROP TABLE

再使用 **\\d** 命令来查看就找不到表格了：

testdb=# \d
    Did not find any relations.

# PostgreSQL INSERT INTO 语句 #

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

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

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">输出信息 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>INSERT oid 1</strong>只插入一行并且目标表具有 OID的返回信息， 那么 oid 是分配给被插入行的 OID。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center">**INSERT 0 #**插入多行返回的信息， # 为插入的行数。</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

在 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

# PostgreSQL SELECT 语句 #

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

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

### 语法 ###

SELECT 语句语法格式如下：

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

*  column1, column2,…columnN 为表中字段名。
 *  table\_name 为表名。

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

SELECT * FROM table_name;

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

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

# PostgreSQL 运算符 #

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

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

常见的运算符有：

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

--------------------

## 算术运算符 ##

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

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">+</td> 
   <td align="center">加</td> 
   <td align="center">a + b 结果为 5</td> 
  </tr> 
  <tr> 
   <td align="center">-</td> 
   <td align="center">减</td> 
   <td align="center">a - b 结果为 -1</td> 
  </tr> 
  <tr> 
   <td align="center">*</td> 
   <td align="center">乘</td> 
   <td align="center">a * b 结果为 6</td> 
  </tr> 
  <tr> 
   <td align="center">/</td> 
   <td align="center">除</td> 
   <td align="center">b / a 结果为 1</td> 
  </tr> 
  <tr> 
   <td align="center">%</td> 
   <td align="center">模（取余）</td> 
   <td align="center">b % a 结果为 1</td> 
  </tr> 
  <tr> 
   <td align="center">^</td> 
   <td align="center">指数</td> 
   <td align="center">a ^ b 结果为 8</td> 
  </tr> 
  <tr> 
   <td align="center">|/</td> 
   <td align="center">平方根</td> 
   <td align="center">|/ 25.0 结果为 5</td> 
  </tr> 
  <tr> 
   <td align="center">||/</td> 
   <td align="center">立方根</td> 
   <td align="center">||/ 27.0 结果为 3</td> 
  </tr> 
  <tr> 
   <td align="center">!</td> 
   <td align="center">阶乘</td> 
   <td align="center">5 ! 结果为 120</td> 
  </tr> 
  <tr> 
   <td align="center">!!</td> 
   <td align="center">阶乘（前缀操作符）</td> 
   <td align="center">!! 5 结果为 120</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

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)

--------------------

## 比较运算符 ##

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

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">描述</th> 
   <th align="center">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">=</td> 
   <td align="center">等于</td> 
   <td align="center">(a = b) 为 false。</td> 
  </tr> 
  <tr> 
   <td align="center">!=</td> 
   <td align="center">不等于</td> 
   <td align="center">(a != b) 为 true。</td> 
  </tr> 
  <tr> 
   <td align="center">&lt;&gt;</td> 
   <td align="center">不等于</td> 
   <td align="center">(a &lt;&gt; b) 为 true。</td> 
  </tr> 
  <tr> 
   <td align="center">&gt;</td> 
   <td align="center">大于</td> 
   <td align="center">(a &gt; b) 为 false。</td> 
  </tr> 
  <tr> 
   <td align="center">&lt;</td> 
   <td align="center">小于</td> 
   <td align="center">(a &lt; b) 为 true。</td> 
  </tr> 
  <tr> 
   <td align="center">&gt;=</td> 
   <td align="center">大于等于</td> 
   <td align="center">(a &gt;= b) 为 false。</td> 
  </tr> 
  <tr> 
   <td align="center">&lt;=</td> 
   <td align="center">小于等于</td> 
   <td align="center">(a &lt;= b) 为 true。</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

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

runoobdb=# 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 |  65000
      5 | David |  27 | Texas     |  85000
      6 | Kim   |  22 | South-Hall|  45000
      7 | James |  24 | Houston   |  10000
    (7 rows)

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

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

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

runoobdb=# SELECT * FROM COMPANY WHERE SALARY != 20000;
     id | name  | age |  address    | salary
    ----+-------+-----+-------------+--------
      2 | Allen |  25 | Texas       |  15000
      4 | Mark  |  25 | Rich-Mond   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
    (5 rows)
    
    runoobdb=# SELECT * FROM COMPANY WHERE SALARY <> 20000;
     id | name  | age | address    | salary
    ----+-------+-----+------------+--------
      2 | Allen |  25 | Texas      |  15000
      4 | Mark  |  25 | Rich-Mond  |  65000
      5 | David |  27 | Texas      |  85000
      6 | Kim   |  22 | South-Hall |  45000
      7 | James |  24 | Houston    |  10000
    (5 rows)

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

--------------------

## 逻辑运算符 ##

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

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="center">运算符 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="center"><strong>AND</strong>逻辑与运算符。如果两个操作数都非零，则条件为真。PostgresSQL 中的 WHERE 语句可以用 AND 包含多个过滤条件。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="center"><strong>NOT</strong>逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。PostgresSQL 有 NOT EXISTS, NOT BETWEEN, NOT IN 等运算符。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="center"><strong>OR</strong>逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。PostgresSQL 中的 WHERE 语句可以用 OR 包含多个过滤条件。</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <thead> 
  <tr> 
   <th align="left"><em>a</em></th> 
   <th align="left"><em>b</em></th> 
   <th align="left"><em>a</em> AND <em>b</em></th> 
   <th align="left"><em>a</em> OR <em>b</em></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">TRUE</td> 
   <td align="left">TRUE</td> 
   <td align="left">TRUE</td> 
   <td align="left">TRUE</td> 
  </tr> 
  <tr> 
   <td align="left">TRUE</td> 
   <td align="left">FALSE</td> 
   <td align="left">FALSE</td> 
   <td align="left">TRUE</td> 
  </tr> 
  <tr> 
   <td align="left">TRUE</td> 
   <td align="left">NULL</td> 
   <td align="left">NULL</td> 
   <td align="left">TRUE</td> 
  </tr> 
  <tr> 
   <td align="left">FALSE</td> 
   <td align="left">FALSE</td> 
   <td align="left">FALSE</td> 
   <td align="left">FALSE</td> 
  </tr> 
  <tr> 
   <td align="left">FALSE</td> 
   <td align="left">NULL</td> 
   <td align="left">FALSE</td> 
   <td align="left">NULL</td> 
  </tr> 
  <tr> 
   <td align="left">NULL</td> 
   <td align="left">NULL</td> 
   <td align="left">NULL</td> 
   <td align="left">NULL</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left"><em>a</em></th> 
   <th align="left">NOT <em>a</em></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">TRUE</td> 
   <td align="left">FALSE</td> 
  </tr> 
  <tr> 
   <td align="left">FALSE</td> 
   <td align="left">TRUE</td> 
  </tr> 
  <tr> 
   <td align="left">NULL</td> 
   <td align="left">NULL</td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

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

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

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 6500;
     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   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
      8 | Paul  |  24 | Houston     |  20000
      9 | James |  44 | Norway      |   5000
     10 | 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  |  20000
      2 | Allen |  25 | Texas       |  15000
      3 | Teddy |  23 | Norway      |  20000
      4 | Mark  |  25 | Rich-Mond   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
      8 | Paul  |  24 | Houston     |  20000
      9 | James |  44 | Norway      |   5000
     10 | James |  45 | Texas       |   5000
    (10 rows)

--------------------

## 位运算符 ##

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

假设如果 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，则：

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

### 实例 ###

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)

# PostgreSQL 表达式 #

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

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

### 语法 ###

SELECT 语句的语法格式如下：

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

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

### 布尔表达式 ###

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

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

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

runoobdb# 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 |  65000
      5 | David |  27 | Texas     |  85000
      6 | Kim   |  22 | South-Hall|  45000
      7 | James |  24 | Houston   |  10000
    (7 rows)

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

### 数字表达式 ###

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

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)

### 日期表达式 ###

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

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

# PostgreSQL WHERE 子句 #

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

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

### 语法 ###

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

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

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

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

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

### AND ###

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

### OR ###

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

### NOT NULL ###

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

runoobdb=# SELECT * FROM COMPANY WHERE AGE IS NOT NULL;
      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  |  65000
       5 | David |  27 | Texas      |  85000
       6 | Kim   |  22 | South-Hall |  45000
       7 | James |  24 | Houston    |  10000
    (7 rows)

### LIKE ###

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

### IN ###

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

### 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 |  20000
      3 | Teddy |  23 | Norway     |  20000
      6 | Kim   |  22 | South-Hall |  45000
      7 | James |  24 | Houston    |  10000
    (4 rows)

### BETWEEN ###

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

### 子查询 ###

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

runoobdb=# SELECT AGE FROM COMPANY
            WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
     age
    -----
      32
      25
      23
      25
      27
      22
      24
    (7 rows)

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

# PostgreSQL AND & OR 运算符 #

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

### AND ###

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

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

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

### 实例 ###

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

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

### OR ###

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

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

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

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

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

# PostgreSQL UPDATE 语句 #

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

### 语法 ###

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

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

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

### 实例 ###

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

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

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

得到结果如下：

id | name  | age | address    | salary
    ----+-------+-----+------------+--------
      1 | Paul  |  32 | California |  20000
      2 | Allen |  25 | Texas      |  15000
      4 | Mark  |  25 | Rich-Mond  |  65000
      5 | David |  27 | Texas      |  85000
      6 | Kim   |  22 | South-Hall |  45000
      7 | James |  24 | Houston    |  10000
      3 | 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   |  20000
      2 | Allen |  25 | Texas   |  20000
      4 | Mark  |  25 | Texas   |  20000
      5 | David |  27 | Texas   |  20000
      6 | Kim   |  22 | Texas   |  20000
      7 | James |  24 | Texas   |  20000
      3 | Teddy |  23 | Texas   |  20000
    (7 rows)

# PostgreSQL DELETE 语句 #

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

### 语法 ###

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

DELETE FROM table_name WHERE [condition];

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

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

### 实例 ###

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

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

runoobdb=# DELETE FROM COMPANY WHERE ID = 2;

得到结果如下：

id | name  | age | address     | salary
    ----+-------+-----+-------------+--------
      1 | Paul  |  32 | California  |  20000
      3 | Teddy |  23 | Norway      |  20000
      4 | Mark  |  25 | Rich-Mond   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
    (6 rows)

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

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

DELETE FROM COMPANY;

# PostgreSQL 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_';

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

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

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

### 实例 ###

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

<table> 
 <thead> 
  <tr> 
   <th align="left">实例</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘200%’</td> 
   <td align="left">找出 SALARY 字段中以 200 开头的数据。</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘%200%’</td> 
   <td align="left">找出 SALARY 字段中含有 200 字符的数据。</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘_00%’</td> 
   <td align="left">找出 SALARY 字段中在第二和第三个位置上有 00 的数据。</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘2 <em>%</em> %’</td> 
   <td align="left">找出 SALARY 字段中以 2 开头的字符长度大于 3 的数据。</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘%2’</td> 
   <td align="left">找出 SALARY 字段中以 2 结尾的数据</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘_2%3’</td> 
   <td align="left">找出 SALARY 字段中 2 在第二个位置上并且以 3 结尾的数据</td> 
  </tr> 
  <tr> 
   <td align="left">WHERE SALARY::text LIKE ‘2___3’</td> 
   <td align="left">找出 SALARY 字段中以 2 开头，3 结尾并且是 5 位数的数据</td> 
  </tr> 
 </tbody> 
</table>

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

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

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

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

得到以下结果：

id | name  | age | address     | salary
    ----+-------+-----+-------------+--------
      2 | Allen |  25 | Texas       |  15000
      3 | Teddy |  23 | Norway      |  20000
      4 | Mark  |  25 | Rich-Mond   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
      8 | Paul  |  24 | Houston     |  20000
    (7 rows)

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

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

得到结果如下：

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

# PostgreSQL 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 表（[下载 COMPANY SQL 文件][COMPANY SQL] ），数据内容如下：

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

runoobdb=# SELECT * FROM COMPANY LIMIT 4;

得到以下结果：

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   |  65000
    (4 rows)

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

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

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

得到以下结果：

id | name  | age | address   | salary
    ----+-------+-----+-----------+--------
      3 | Teddy |  23 | Norway    |  20000
      4 | Mark  |  25 | Rich-Mond |  65000
      5 | David |  27 | Texas     |  85000
    (3 rows)

# PostgreSQL ORDER BY 语句 #

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

### 语法 ###

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

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

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

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

### 实例 ###

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

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

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

得到以下结果：

id | name  | age |                      address                       | salary 
    ----+-------+-----+----------------------------------------------------+--------
      6 | Kim   |  22 | South-Hall                                         |  45000
      3 | Teddy |  23 | Norway                                             |  20000
      7 | James |  24 | Houston                                            |  10000
      4 | Mark  |  25 | Rich-Mond                                          |  65000
      2 | Allen |  25 | Texas                                              |  15000
      5 | David |  27 | Texas                                              |  85000
      1 | 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                                              |  15000
      5 | David |  27 | Texas                                              |  85000
      7 | James |  24 | Houston                                            |  10000
      6 | Kim   |  22 | South-Hall                                         |  45000
      4 | Mark  |  25 | Rich-Mond                                          |  65000
      1 | Paul  |  32 | California                                         |  20000
      3 | Teddy |  23 | Norway                                             |  20000
    (7 rows)

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

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

得到以下结果：

id | name  | age |                      address                       | salary 
    ----+-------+-----+----------------------------------------------------+--------
      3 | Teddy |  23 | Norway                                             |  20000
      1 | Paul  |  32 | California                                         |  20000
      4 | Mark  |  25 | Rich-Mond                                          |  65000
      6 | Kim   |  22 | South-Hall                                         |  45000
      7 | James |  24 | Houston                                            |  10000
      5 | David |  27 | Texas                                              |  85000
      2 | Allen |  25 | Texas                                              |  15000
    (7 rows)

# PostgreSQL GROUP BY 语句 #

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

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

### 语法 ###

下面给出了 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 子句中，你可以对一列或者多列进行分组，但是被分组的列必须存在于列清单中。

### 实例 ###

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

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

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

得到以下结果：

现在我们添加使用下面语句在 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   |  20000
       2 | Allen |  25 | Texas        |  15000
       3 | Teddy |  23 | Norway       |  20000
       4 | Mark  |  25 | Rich-Mond    |  65000
       5 | David |  27 | Texas        |  85000
       6 | Kim   |  22 | South-Hall   |  45000
       7 | James |  24 | Houston      |  10000
       8 | Paul  |  24 | Houston      |  20000
       9 | James |  44 | Norway       |   5000
      10 | James |  45 | Texas        |   5000
    (10 rows)

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

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

这时的得到的结果如下：

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

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

得到以下结果：

# PostgreSQL WITH 子句 #

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

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

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

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 中使用数据 INSERT, UPDATE 或 DELETE 语句，允许您在同一个查询中执行多个不同的操作。

### WITH 递归 ###

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

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

### 实例 ###

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

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

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

得到结果如下：

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 |  65000
      5 | David |  27 | Texas     |  85000
      6 | Kim   |  22 | South-Hall|  45000
      7 | James |  24 | Houston   |  10000
    (7 rows)

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

WITH RECURSIVE t(n) AS (
       VALUES (0)
       UNION ALL
       SELECT 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 COMPANY
       WHERE
          SALARY >= 30000
       RETURNING *
    )
    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 |  20000
      2 | Allen |  25 | Texas      |  15000
      3 | Teddy |  23 | Norway     |  20000
      7 | James |  24 | Houston    |  10000
    (4 rows)
    
    
    runoobdb=# SELECT * FROM COMPANY1;
     id | name  | age | address | salary
    ----+-------+-----+-------------+--------
      4 | Mark  |  25 | Rich-Mond   |  65000
      5 | David |  27 | Texas       |  85000
      6 | Kim   |  22 | South-Hall  |  45000
    (3 rows)

# PostgreSQL HAVING 子句 #

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

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

### 语法 ###

下面是 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

### 实例 ###

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

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

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

得到以下结果：

name
     -------
      Teddy
      Paul
      Mark
      David
      Allen
      Kim
      James
    (7 rows)

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

此时，COMPANY 表的记录如下：

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

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

得到结果如下：

name
    -------
     Paul
     James
    (2 rows)

# PostgreSQL DISTINCT 关键字 #

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

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

### 语法 ###

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

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

### 实例 ###

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

让我们插入两条数据：

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 |  20000
      2 | Allen |  25 | Texas      |  15000
      3 | Teddy |  23 | Norway     |  20000
      4 | Mark  |  25 | Rich-Mond  |  65000
      5 | David |  27 | Texas      |  85000
      6 | Kim   |  22 | South-Hall |  45000
      7 | James |  24 | Houston    |  10000
      8 | Paul  |  32 | California |  20000
      9 | Allen |  25 | Texas      |  15000
    (9 rows)

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

runoobdb=# SELECT name FROM COMPANY;

得到结果如下：

name
    -------
     Paul
     Allen
     Teddy
     Mark
     David
     Kim
     James
     Paul
     Allen
    (9 rows)

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

runoobdb=# SELECT DISTINCT name FROM COMPANY;

得到结果如下：

name
    -------
     Teddy
     Paul
     Mark
     David
     Allen
     Kim
     James
    (7 rows)

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

# PostgreSQL 约束 #

PostgreSQL 约束用于规定表中的数据规则。

如果存在违反约束的数据行为，行为会被约束终止。

约束可以在创建表时规定（通过 CREATE TABLE 语句），或者在表创建之后规定（通过 ALTER TABLE 语句）。

约束确保了数据库中数据的准确性和可靠性。

约束可以是列级或表级。列级约束仅适用于列，表级约束被应用到整个表。

以下是在 PostgreSQL 中常用的约束。

*  **NOT NULL**：指示某列不能存储 NULL 值。
 *  **UNIQUE**：确保某列的值都是唯一的。
 *  PRIMARY Key：NOT NULL 和 UNIQUE 的结合。确保某列（或两个列多个列的结合）有唯一标识，有助于更容易更快速地找到表中的一个特定的记录。。
 *  FOREIGN Key： 保证一个表中的数据匹配另一个表中的值的参照完整性。
 *  CHECK： 保证列中的值符合指定的条件。
 *  EXCLUSION ：排他约束，保证如果将任何两行的指定列或表达式使用指定操作符进行比较，至少其中一个操作符比较将会返回 false 或空值。

### NOT NULL 约束 ###

默认情况下，列可以保存为 NULL 值。如果您不想某列有 NULL 值，那么需要在该列上定义此约束，指定在该列上不允许 NULL 值。

NULL 与没有数据是不一样的，它代表着未知的数据。

**实例**

下面实例创建了一张新表叫 COMPANY1，添加了 5 个字段，其中三个 ID，NAME，AGE 设置不接受空置：

CREATE TABLE COMPANY1(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT    NOT NULL,
       AGE            INT     NOT NULL,
       ADDRESS        CHAR(50),
       SALARY         REAL
    );

### UNIQUE 约束 ###

UNIQUE 约束可以设置列是唯一的，避免同一列出现重复值。

**实例**

下面实例创建了一张新表叫 COMPANY3，添加了 5 个字段，其中 AGE 设置为 UNIQUE，因此你不能添加两条有相同年龄的记录：

CREATE TABLE COMPANY3(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT    NOT NULL,
       AGE            INT     NOT NULL UNIQUE,
       ADDRESS        CHAR(50),
       SALARY         REAL    DEFAULT 50000.00
    );

### PRIMARY KEY ###

在设计数据库时，PRIMARY KEY 非常重要。

PRIMARY KEY 称为主键，是数据表中每一条记录的唯一标识。

设置 UNIQUE 的列可能有多个，但是一张表只有一列可以设置 PRIMARY KEY。

我们可以使用主键来引用表中的行，也可以通过把主键设置为其他表的外键，来创建表之间的关系。

主键是非空约束和唯一约束的组合。

一个表只能有一个主键，它可以由一个或多个字段组成，当多个字段作为主键，它们被称为复合键。

如果一个表在任何字段上定义了一个主键，那么在这些字段上不能有两个记录具有相同的值。

**实例**

下面我们创建 COMAPNY4 表，其中 ID 作为主键：

CREATE TABLE COMPANY4(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT    NOT NULL,
       AGE            INT     NOT NULL,
       ADDRESS        CHAR(50),
       SALARY         REAL
    );

### FOREIGN KEY 约束 ###

FOREIGN KEY 即外键约束，指定列(或一组列)中的值必须匹配另一个表的某一行中出现的值。

通常一个表中的 FOREIGN KEY 指向另一个表中的 UNIQUE KEY(唯一约束的键)，即维护了两个相关表之间的引用完整性。

**实例**

下面实例创建了一张 COMPANY6 表，并添加了5个字段：

CREATE TABLE COMPANY6(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT    NOT NULL,
       AGE            INT     NOT NULL,
       ADDRESS        CHAR(50),
       SALARY         REAL
    );

下面实例创建一张 DEPARTMENT1 表，并添加 3 个字段，EMP\_ID 就是外键，参照 COMPANY6 的 ID：

CREATE TABLE DEPARTMENT1(
       ID INT PRIMARY KEY      NOT NULL,
       DEPT           CHAR(50) NOT NULL,
       EMP_ID         INT      references COMPANY6(ID)
    );

### CHECK 约束 ###

CHECK 约束保证列中的所有值满足某一条件，即对输入一条记录要进行检查。如果条件值为 false，则记录违反了约束，且不能输入到表。

**实例**

例如，下面实例建一个新的表 COMPANY5，增加了五列。在这里，我们为 SALARY 列添加 CHECK，所以工资不能为零：

CREATE TABLE COMPANY5(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT    NOT NULL,
       AGE            INT     NOT NULL,
       ADDRESS        CHAR(50),
       SALARY         REAL    CHECK(SALARY > 0)
    );

### EXCLUSION 约束 ###

EXCLUSION 约束确保如果使用指定的运算符在指定列或表达式上比较任意两行，至少其中一个运算符比较将返回 false 或 null。

**实例**

下面实例创建了一张 COMPANY7 表，添加 5 个字段，并且使用了 EXCLUDE 约束。

CREATE TABLE COMPANY7(
       ID INT PRIMARY KEY     NOT NULL,
       NAME           TEXT,
       AGE            INT  ,
       ADDRESS        CHAR(50),
       SALARY         REAL,
       EXCLUDE USING gist
       (NAME WITH =,  -- 如果满足 NAME 相同，AGE 不相同则不允许插入，否则允许插入
       AGE WITH <>)   -- 其比较的结果是如果整个表边式返回 true，则不允许插入，否则允许
    );

这里，USING gist 是用于构建和执行的索引一种类型。

> 您需要为每个数据库执行一次 CREATE EXTENSION btree\_gist 命令，这将安装 btree\_gist 扩展，它定义了对纯标量数据类型的 EXCLUDE 约束。

由于我们已经强制执行了年龄必须相同，让我们通过向表插入记录来查看这一点：

INSERT INTO COMPANY7 VALUES(1, 'Paul', 32, 'California', 20000.00 );
    INSERT INTO COMPANY7 VALUES(2, 'Paul', 32, 'Texas', 20000.00 );  
    -- 此条数据的 NAME 与第一条相同，且 AGE 与第一条也相同，故满足插入条件
    INSERT INTO COMPANY7 VALUES(3, 'Allen', 42, 'California', 20000.00 );
    -- 此数据与上面数据的 NAME 相同，但 AGE 不相同，故不允许插入

前面两条顺利添加的 COMPANY7 表中，但是第三条则会报错：

ERROR:  duplicate key value violates unique constraint "company7_pkey"
    DETAIL:  Key (id)=(3) already exists.

### 删除约束 ###

删除约束必须知道约束名称，已经知道名称来删除约束很简单，如果不知道名称，则需要找到系统生成的名称，使用 **\\d 表名** 可以找到这些信息。

通用语法如下：

ALTER TABLE table_name DROP CONSTRAINT some_name;

# PostgreSQL 连接(JOIN) #

PostgreSQL JOIN 子句用于把来自两个或多个表的行结合起来，基于这些表之间的共同字段。

在 PostgreSQL 中，JOIN 有五种连接类型：

*  CROSS JOIN ：交叉连接
 *  INNER JOIN：内连接
 *  LEFT OUTER JOIN：左外连接
 *  RIGHT OUTER JOIN：右外连接
 *  FULL OUTER JOIN：全外连接

接下来让我们创建两张表 **COMPANY** 和 **DEPARTMENT**。

## 实例 ##

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

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

此时，COMPANY 表的记录如下：

创建一张 DEPARTMENT 表，添加三个字段：

CREATE TABLE DEPARTMENT(
       ID INT PRIMARY KEY      NOT NULL,
       DEPT           CHAR(50) NOT NULL,
       EMP_ID         INT      NOT NULL
    );

向 DEPARTMENT 表插入三条记录：

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (1, 'IT Billing', 1 );
    
    INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (2, 'Engineering', 2 );
    
    INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (3, 'Finance', 7 );

此时，DEPARTMENT 表的记录如下：

id | dept        | emp_id
    ----+-------------+--------
      1 | IT Billing  |  1
      2 | Engineering |  2
      3 | Finance     |  7

--------------------

## 交叉连接 ##

交叉连接（CROSS JOIN）把第一个表的每一行与第二个表的每一行进行匹配。如果两个输入表分别有 x 和 y 行，则结果表有 x\*y 行。

由于交叉连接（CROSS JOIN）有可能产生非常大的表，使用时必须谨慎，只在适当的时候使用它们。

下面是 CROSS JOIN 的基础语法：

SELECT ... FROM table1 CROSS JOIN table2 ...

基于上面的表，我们可以写一个交叉连接（CROSS JOIN），如下所示：

runoobdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

得到结果如下：

--------------------

## 内连接 ##

内连接（INNER JOIN）根据连接谓词结合两个表（table1 和 table2）的列值来创建一个新的结果表。查询会把 table1 中的每一行与 table2 中的每一行进行比较，找到所有满足连接谓词的行的匹配对。

当满足连接谓词时，A 和 B 行的每个匹配对的列值会合并成一个结果行。

内连接（INNER JOIN）是最常见的连接类型，是默认的连接类型。

INNER 关键字是可选的。

下面是内连接（INNER JOIN）的语法：

SELECT table1.column1, table2.column2...
    FROM table1
    INNER JOIN table2
    ON table1.common_filed = table2.common_field;

基于上面的表，我们可以写一个内连接，如下所示：

--------------------

## 左外连接 ##

外部连接是内部连接的扩展。SQL 标准定义了三种类型的外部连接: LEFT、RIGHT 和 FULL, PostgreSQL 支持所有这些。

对于左外连接，首先执行一个内连接。然后，对于表 T1 中不满足表 T2 中连接条件的每一行，其中 T2 的列中有 null 值也会添加一个连接行。因此，连接的表在 T1 中每一行至少有一行。

下面是左外连接（ LEFT OUTER JOIN ）的基础语法：

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

基于上面两张表，我们可以写个左外连接，如下：

--------------------

## 右外连接 ##

首先，执行内部连接。然后，对于表T2中不满足表T1中连接条件的每一行，其中T1列中的值为空也会添加一个连接行。这与左联接相反;对于T2中的每一行，结果表总是有一行。

下面是右外连接（ RIGHT OUT JOIN）的基本语法：

SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...

基于上面两张表，我们建立一个右外连接：

--------------------

## 外连接 ##

首先，执行内部连接。然后，对于表 T1 中不满足表 T2 中任何行连接条件的每一行，如果 T2 的列中有 null 值也会添加一个到结果中。此外，对于 T2 中不满足与 T1 中的任何行连接条件的每一行，将会添加 T1 列中包含 null 值的到结果中。

下面是外连接的基本语法：

SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...

基于上面两张表，可以建立一个外连接：

# PostgreSQL UNION 操作符 #

PostgreSQL UNION 操作符合并两个或多个 SELECT 语句的结果。

UNION 操作符用于合并两个或多个 SELECT 语句的结果集。

请注意，UNION 内部的每个 SELECT 语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时，每个 SELECT 语句中的列的顺序必须相同。

## 语法 ##

UNIONS 基础语法如下：

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

这里的条件语句可以根据您的需要设置任何表达式。

## 实例 ##

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

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

runoobdb=\# SELECT \* from DEPARTMENT;

id | dept        | emp_id
    ----+-------------+--------
      1 | IT Billing  |      1
      2 | Engineering |      2
      3 | Finance     |      7
      4 | Engineering |      3
      5 | Finance     |      4
      6 | Engineering |      5
      7 | Finance     |      6
    (7 rows)

现在，我们在 SELECT 语句中使用 UNION 子句将两张表连接起来，如下所示：

SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
       ON COMPANY.ID = DEPARTMENT.EMP_ID
       UNION
    SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
        ON COMPANY.ID = DEPARTMENT.EMP_ID;

得到结果如下：

--------------------

## UNION ALL 子句 ##

UNION ALL 操作符可以连接两个有重复行的 SELECT 语句，默认地，UNION 操作符选取不同的值。如果允许重复的值，请使用 UNION ALL。

### 语法 ###

UINON ALL 子句基础语法如下：

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

这里的条件语句可以根据您的需要设置任何表达式。

### 实例 ###

现在，让我们把上面提到的两张表用 SELECT 语句结合 UNION ALL 子句连接起来：

SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
       ON COMPANY.ID = DEPARTMENT.EMP_ID
       UNION ALL
    SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
        ON COMPANY.ID = DEPARTMENT.EMP_ID;

得到结果如下：

# PostgreSQL NULL 值 #

NULL 值代表遗漏的未知数据。

默认地，表的列可以存放 NULL 值。

本章讲解 IS NULL 和 IS NOT NULL 操作符。

### 语法 ###

当创建表时，NULL 的基本语法如下：

这里，NOT NULL 表示强制字段始终包含值。这意味着，如果不向字段添加值，就无法插入新记录或者更新记录。

具有 NULL 值的字段表示在创建记录时可以留空。

在查询数据时，NULL 值可能会导致一些问题，因为一个未知的值去与其他任何值比较，结果永远是未知的。

另外无法比较 NULL 和 0，因为它们是不等价的。

### 实例 ###

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

接下来我们用 UPDATE 语句把几个可设置为空的字段设置为 NULL ：

runoobdb=# UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

现在 COMPANY 表长这样：：

runoobdb=# 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           |  65000
      5 | David |  27 | Texas               |  85000
      6 | Kim   |  22 |                     |       
      7 | James |  24 |                     |       
    (7 rows)

**IS NOT NULL**

现在，我们用 IS NOT NULL 操作符把所有 SALARY（薪资） 值不为空的记录列出来：

runoobdb=# SELECT ID, NAME, AGE, ADDRESS, SALARY FROM COMPANY WHERE SALARY IS NOT NULL;

得到结果如下：

**IS NULL**

IS NULL 用来查找为 NULL 值的字段。

下面是 IS NULL 操作符的用法，列出 SALARY（薪资） 值为空的记录：

runoobdb=# SELECT ID, NAME, AGE, ADDRESS, SALARY FROM COMPANY WHERE SALARY IS NULL;

得到结果如下：

id | name  | age | address | salary
    ----+-------+-----+---------+--------
      6 | Kim   |  22 |         |
      7 | James |  24 |         |
    (2 rows)

# PostgreSQL 别名 #

我们可以用 SQL 重命名一张表或者一个字段的名称，这个名称就叫着该表或该字段的别名。

创建别名是为了让表名或列名的可读性更强。

SQL 中 使用 **AS** 来创建别名。

### 语法 ###

表的别名语法:

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

列的别名语法:

SELECT column_name AS alias_name
    FROM table_name
    WHERE [condition];

### 实例 ###

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

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

下面我们分别用 C 和 D 表示 COMPANY 表和 DEPAERMENT 表的别名：

runoobdb=# SELECT C.ID, C.NAME, C.AGE, D.DEPT FROM COMPANY AS C, DEPARTMENT AS D WHERE C.ID = D.EMP_ID;

得到结果如下：

下面，我们用 COMPANY\_ID 表示 ID 列，COMPANY\_NAME 表示 NAME 列，来展示列别名的用法：

runoobdb=# SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT FROM COMPANY AS C, DEPARTMENT AS D WHERE C.ID = D.EMP_ID;

得到结果如下：

# PostgreSQL ALTER TABLE 命令 #

在 PostgreSQL 中，**ALTER TABLE** 命令用于添加，修改，删除一张已经存在表的列。

另外你也可以用 **ALTER TABLE** 命令添加和删除约束。

### 语法 ###

用 ALTER TABLE 在一张已存在的表上添加列的语法如下：

ALTER TABLE table_name ADD column_name datatype;

在一张已存在的表上 DROP COLUMN（删除列），语法如下：

ALTER TABLE table_name DROP COLUMN column_name;

修改表中某列的 DATA TYPE（数据类型），语法如下：

ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;

给表中某列添加 NOT NULL 约束，语法如下：

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

给表中某列添加 NOT NULL 约束，语法如下：

alter table ${table_name} alter column ${column_name} set not null;

删除表中某列的 NOT NULL 约束，语法如下：

alter table ${table_name} alter column ${column_name} drop not null;

给表中某列 ADD UNIQUE CONSTRAINT（ 添加 UNIQUE 约束），语法如下：

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

给表中 ADD CHECK CONSTRAINT（添加 CHECK 约束），语法如下：

ALTER TABLE table_name
    ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

给表 ADD PRIMARY KEY（添加主键），语法如下：

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

DROP CONSTRAINT （删除约束），语法如下：

ALTER TABLE table_name
    DROP CONSTRAINT MyUniqueConstraint;

如果是 MYSQL ，代码是这样：

ALTER TABLE table_name
    DROP INDEX MyUniqueConstraint;

DROP PRIMARY KEY （删除主键），语法如下：

ALTER TABLE table_name
    DROP CONSTRAINT MyPrimaryKey;

如果是 MYSQL ，代码是这样：

ALTER TABLE table_name
    DROP PRIMARY KEY;

### 实例 ###

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

下面实例在这张表中添加新的列：

runoobdb=# ALTER TABLE COMPANY ADD GENDER char(1);

现在表长这样：

id | name  | age | address     | salary | gender
    ----+-------+-----+-------------+--------+--------
      1 | Paul  |  32 | California  |  20000 |
      2 | Allen |  25 | Texas       |  15000 |
      3 | Teddy |  23 | Norway      |  20000 |
      4 | Mark  |  25 | Rich-Mond   |  65000 |
      5 | David |  27 | Texas       |  85000 |
      6 | Kim   |  22 | South-Hall  |  45000 |
      7 | James |  24 | Houston     |  10000 |
    (7 rows)

下面实例删除 GENDER 列：

runoobdb=# ALTER TABLE COMPANY DROP GENDER;

得到结果如下：

# PostgreSQL TRUNCATE TABLE #

PostgreSQL 中 TRUNCATE TABLE 用于删除表的数据，但不删除表结构。

也可以用 DROP TABLE 删除表，但是这个命令会连表的结构一起删除，如果想插入数据，需要重新建立这张表。

TRUNCATE TABLE 与 DELETE 具有相同的效果，但是由于它实际上并不扫描表，所以速度更快。 此外，TRUNCATE TABLE 可以立即释放表空间，而不需要后续 VACUUM 操作，这在大型表上非常有用。

PostgreSQL VACUUM 操作用于释放、再利用更新/删除行所占据的磁盘空间。

### 语法 ###

TRUNCATE TABLE 基础语法如下：

TRUNCATE TABLE  table_name;

### 实例 ###

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

下面实例使用了 TRUNCATE TABLE 来清除 COMPANY 表：

runoobdb=# TRUNCATE TABLE COMPANY;

得到结果如下：

runoobdb=# SELECT * FROM CUSTOMERS;
     id | name | age | address | salary
    ----+------+-----+---------+--------
    (0 rows)

# PostgreSQL 子查询 #

子查询或称为内部查询、嵌套查询，指的是在 PostgreSQL 查询中的 WHERE 子句中嵌入查询语句。

一个 SELECT 语句的查询结果能够作为另一个语句的输入值。

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

以下是子查询必须遵循的几个规则：

*  子查询必须用括号括起来。
 *  子查询在 SELECT 子句中只能有一个列，除非在主查询中有多列，与子查询的所选列进行比较。
 *  ORDER BY 不能用在子查询中，虽然主查询可以使用 ORDER BY。可以在子查询中使用 GROUP BY，功能与 ORDER BY 相同。
 *  子查询返回多于一行，只能与多值运算符一起使用，如 IN 运算符。
 *  BETWEEN 运算符不能与子查询一起使用，但是，BETWEEN 可在子查询内使用。

## SELECT 语句中的子查询使用 ##

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

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

### 实例 ###

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

现在，让我们在 SELECT 语句中使用子查询：

runoobdb=# SELECT * FROM COMPANY WHERE ID IN (SELECT ID FROM COMPANY WHERE SALARY > 45000) ;

得到结果如下：

--------------------

## INSERT 语句中的子查询使用 ##

子查询也可以与 INSERT 语句一起使用。INSERT 语句使用子查询返回的数据插入到另一个表中。

在子查询中所选择的数据可以用任何字符、日期或数字函数修改。

基本语法如下：

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

### 实例 ###

假设 COMPANY\_BKP 的结构与 COMPANY 表相似，且可使用相同的 CREATE TABLE 进行创建，只是表名改为 COMPANY\_BKP。现在把整个 COMPANY 表复制到 COMPANY\_BKP，语法如下：

runoobdb=# INSERT INTO COMPANY_BKP SELECT * FROM COMPANY WHERE ID IN (SELECT ID FROM COMPANY) ;

--------------------

## UPDATE 语句中的子查询使用 ##

子查询可以与 UPDATE 语句结合使用。当通过 UPDATE 语句使用子查询时，表中单个或多个列被更新。

基本语法如下：

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

### 实例 ###

假设，我们有 COMPANY\_BKP 表，是 COMPANY 表的备份。

下面的实例把 COMPANY 表中所有 AGE 大于 27 的客户的 SALARY 更新为原来的 0.50 倍：

runoobdb=# UPDATE COMPANY SET SALARY = SALARY * 0.50 WHERE AGE IN (SELECT AGE FROM COMPANY_BKP WHERE AGE >= 27 );

这将影响两行，最后 COMPANY 表中的记录如下：

id | name  | age | address     | salary
    ----+-------+-----+-------------+--------
      2 | Allen |  25 | Texas       |  15000
      3 | Teddy |  23 | Norway      |  20000
      4 | Mark  |  25 | Rich-Mond   |  65000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
      1 | Paul  |  32 | California  |  10000
      5 | David |  27 | Texas       |  42500
    (7 rows)

--------------------

## DELETE 语句中的子查询使用 ##

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

基本语法如下：

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

### 实例 ###

假设，我们有 COMPANY\_BKP 表，是 COMPANY 表的备份。

下面的实例删除 COMPANY 表中所有 AGE 大于或等于 27 的客户记录：

runoobdb=# DELETE FROM COMPANY WHERE AGE IN (SELECT AGE FROM COMPANY_BKP WHERE AGE > 27 );

这将影响两行，最后 COMPANY 表中的记录如下：

id | name  | age | address     | salary
    ----+-------+-----+-------------+--------
      2 | Allen |  25 | Texas       |  15000
      3 | Teddy |  23 | Norway      |  20000
      4 | Mark  |  25 | Rich-Mond   |  65000
      6 | Kim   |  22 | South-Hall  |  45000
      7 | James |  24 | Houston     |  10000
      5 | David |  27 | Texas       |  42500
    (6 rows)

# PostgreSQL AUTO INCREMENT（自动增长） #

AUTO INCREMENT（自动增长） 会在新记录插入表中时生成一个唯一的数字。

PostgreSQL 使用序列来标识字段的自增长，数据类型有 smallserial、serial 和 bigserial 。这些属性类似于 MySQL 数据库支持的 AUTO\_INCREMENT 属性。

使用 MySQL 设置自动增长的语句如下:

CREATE TABLE IF NOT EXISTS `runoob_tbl`(
       `runoob_id` INT UNSIGNED AUTO_INCREMENT,
       `runoob_title` VARCHAR(100) NOT NULL,
       `runoob_author` VARCHAR(40) NOT NULL,
       `submission_date` DATE,
       PRIMARY KEY ( `runoob_id` )
    )ENGINE=InnoDB DEFAULT CHARSET=utf8;

MySQL 是用 AUTO\_INCREMENT 这个属性来标识字段的自增。

PostgreSQL 使用序列来标识字段的自增长：

CREATE TABLE runoob
    (
        id serial NOT NULL,
        alttext text,
        imgurl text
    )

SMALLSERIAL、SERIAL 和 BIGSERIAL 范围：

<table> 
 <thead> 
  <tr> 
   <th align="left">伪类型</th> 
   <th align="left">存储大小</th> 
   <th align="left">范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>SMALLSERIAL</code></td> 
   <td align="left">2字节</td> 
   <td align="left">1 到 32,767</td> 
  </tr> 
  <tr> 
   <td align="left"><code>SERIAL</code></td> 
   <td align="left">4字节</td> 
   <td align="left">1 到 2,147,483,647</td> 
  </tr> 
  <tr> 
   <td align="left"><code>BIGSERIAL</code></td> 
   <td align="left">8字节</td> 
   <td align="left">1 到 922,337,2036,854,775,807</td> 
  </tr> 
 </tbody> 
</table>

### 语法 ###

SERIAL 数据类型基础语法如下：

CREATE TABLE tablename (
       colname SERIAL
    );

### 实例 ###

假定我们要创建一张 COMPANY 表，并创建下面几个字段：

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

现在往表中插入几条记录：

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ( 'Paul', 32, 'California', 20000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ('Allen', 25, 'Texas', 15000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ('Teddy', 23, 'Norway', 20000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ( 'David', 27, 'Texas', 85000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );
    
    INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
    VALUES ( 'James', 24, 'Houston', 10000.00 );

查看 COMPANY 表的记录如下：

# PostgreSQL PRIVILEGES（权限） #

无论何时创建数据库对象，都会为其分配一个所有者，所有者通常是执行 create 语句的人。

对于大多数类型的对象，初始状态是只有所有者(或超级用户)才能修改或删除对象。要允许其他角色或用户使用它，必须为该用户设置权限。

在 PostgreSQL 中，权限分为以下几种：

*  SELECT
 *  INSERT
 *  UPDATE
 *  DELETE
 *  TRUNCATE
 *  REFERENCES
 *  TRIGGER
 *  CREATE
 *  CONNECT
 *  TEMPORARY
 *  EXECUTE
 *  USAGE

根据对象的类型(表、函数等)，将指定权限应用于该对象。

要向用户分配权限，可以使用 GRANT 命令。

### GRANT 语法 ###

GRANT 命令的基本语法如下：

GRANT privilege [, ...]
    ON object [, ...]
    TO { PUBLIC | GROUP group | username }

*  privilege − 值可以为：SELECT，INSERT，UPDATE，DELETE， RULE，ALL。
 *  object − 要授予访问权限的对象名称。可能的对象有： table， view，sequence。
 *  PUBLIC − 表示所有用户。
 *  GROUP group − 为用户组授予权限。
 *  username − 要授予权限的用户名。PUBLIC 是代表所有用户的简短形式。

另外，我们可以使用 REVOKE 命令取消权限，REVOKE 语法：

REVOKE privilege [, ...]
    ON object [, ...]
    FROM { PUBLIC | GROUP groupname | username }

### 实例 ###

为了理解权限，创建一个用户：

runoobdb=# CREATE USER runoob WITH PASSWORD 'password';
    CREATE ROLE

信息 CREATE ROLE 表示创建了一个用户 “runoob”。

### 实例 ###

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

现在给用户 “runoob” 分配权限：

runoobdb=# GRANT ALL ON COMPANY TO runoob;
    GRANT

信息 GRANT 表示所有权限已经分配给了 “runoob”。

下面撤销用户 “runoob” 的权限：

runoobdb=# REVOKE ALL ON COMPANY FROM runoob;
    REVOKE

信息 REVOKE 表示已经将用户的权限撤销。

你也可以删除用户：

runoobdb=# DROP USER runoob;
    DROP ROLE

信息 DROP ROLE 表示用户 “runoob” 已经从数据库中删除。

# PostgreSQL 时间/日期函数和操作符 #

### 日期/时间操做符 ###

下表演示了基本算术操作符的行为(+,\*, 等)：

<table> 
 <thead> 
  <tr> 
   <th align="left">操作符</th> 
   <th align="left">例子</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>date '2001-09-28' + integer '7'</code></td> 
   <td align="left"><code>date '2001-10-05'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>date '2001-09-28' + interval '1 hour'</code></td> 
   <td align="left"><code>timestamp '2001-09-28 01:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>date '2001-09-28' + time '03:00'</code></td> 
   <td align="left"><code>timestamp '2001-09-28 03:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>interval '1 day' + interval '1 hour'</code></td> 
   <td align="left"><code>interval '1 day 01:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>timestamp '2001-09-28 01:00' + interval '23 hours'</code></td> 
   <td align="left"><code>timestamp '2001-09-29 00:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left"><code>time '01:00' + interval '3 hours'</code></td> 
   <td align="left"><code>time '04:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>- interval '23 hours'</code></td> 
   <td align="left"><code>interval '-23:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>date '2001-10-01' - date '2001-09-28'</code></td> 
   <td align="left"><code>integer '3'</code> (days)</td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>date '2001-10-01' - integer '7'</code></td> 
   <td align="left"><code>date '2001-09-24'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>date '2001-09-28' - interval '1 hour'</code></td> 
   <td align="left"><code>timestamp '2001-09-27 23:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>time '05:00' - time '03:00'</code></td> 
   <td align="left"><code>interval '02:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>time '05:00' - interval '2 hours'</code></td> 
   <td align="left"><code>time '03:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>timestamp '2001-09-28 23:00' - interval '23 hours'</code></td> 
   <td align="left"><code>timestamp '2001-09-28 00:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>interval '1 day' - interval '1 hour'</code></td> 
   <td align="left"><code>interval '1 day -01:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left"><code>timestamp '2001-09-29 03:00' - timestamp '2001-09-27 12:00'</code></td> 
   <td align="left"><code>interval '1 day 15:00:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>*</code></td> 
   <td align="left"><code>900 * interval '1 second'</code></td> 
   <td align="left"><code>interval '00:15:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>*</code></td> 
   <td align="left"><code>21 * interval '1 day'</code></td> 
   <td align="left"><code>interval '21 days'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>*</code></td> 
   <td align="left"><code>double precision '3.5' * interval '1 hour'</code></td> 
   <td align="left"><code>interval '03:30:00'</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>/</code></td> 
   <td align="left"><code>interval '1 hour' / double precision '1.5'</code></td> 
   <td align="left"><code>interval '00:40:00'</code></td> 
  </tr> 
 </tbody> 
</table>

### 日期/时间函数 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">返回类型</th> 
   <th align="left">描述</th> 
   <th align="left">例子</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>age(timestamp, timestamp)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">减去参数后的"符号化"结果，使用年和月，不只是使用天</td> 
   <td align="left"><code>age(timestamp '2001-04-10', timestamp '1957-06-13')</code></td> 
   <td align="left"><code>43 years 9 mons 27 days</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>age(timestamp)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">从<code>current_date</code>减去参数后的结果（在午夜）</td> 
   <td align="left"><code>age(timestamp '1957-06-13')</code></td> 
   <td align="left"><code>43 years 8 mons 3 days</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>clock_timestamp()</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">实时时钟的当前时间戳（在语句执行时变化）</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>current_date</code></td> 
   <td align="left"><code>date</code></td> 
   <td align="left">当前的日期；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>current_time</code></td> 
   <td align="left"><code>time with time zone</code></td> 
   <td align="left">当日时间；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>current_timestamp</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">当前事务开始时的时间戳；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>date_part(text, timestamp)</code></td> 
   <td align="left"><code>double precision</code></td> 
   <td align="left">获取子域(等效于<code>extract</code>)；</td> 
   <td align="left"><code>date_part('hour', timestamp '2001-02-16 20:38:40')</code></td> 
   <td align="left"><code>20</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>date_part(text, interval)</code></td> 
   <td align="left"><code>double precision</code></td> 
   <td align="left">获取子域(等效于<code>extract</code>)；</td> 
   <td align="left"><code>date_part('month', interval '2 years 3 months')</code></td> 
   <td align="left"><code>3</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>date_trunc(text, timestamp)</code></td> 
   <td align="left"><code>timestamp</code></td> 
   <td align="left">截断成指定的精度；</td> 
   <td align="left"><code>date_trunc('hour', timestamp '2001-02-16 20:38:40')</code></td> 
   <td align="left"><code>2001-02-16 20:00:00</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>date_trunc(text, interval)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">截取指定的精度，</td> 
   <td align="left"><code>date_trunc('hour', interval '2 days 3 hours 40 minutes')</code></td> 
   <td align="left"><code>2 days 03:00:00</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>extract(field from timestamp)</code></td> 
   <td align="left"><code>double precision</code></td> 
   <td align="left">获取子域；</td> 
   <td align="left"><code>extract(hour from timestamp '2001-02-16 20:38:40')</code></td> 
   <td align="left"><code>20</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>extract(field from interval)</code></td> 
   <td align="left"><code>double precision</code></td> 
   <td align="left">获取子域；</td> 
   <td align="left"><code>extract(month from interval '2 years 3 months')</code></td> 
   <td align="left"><code>3</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>isfinite(date)</code></td> 
   <td align="left"><code>boolean</code></td> 
   <td align="left">测试是否为有穷日期(不是 +/-无穷)</td> 
   <td align="left"><code>isfinite(date '2001-02-16')</code></td> 
   <td align="left"><code>true</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>isfinite(timestamp)</code></td> 
   <td align="left"><code>boolean</code></td> 
   <td align="left">测试是否为有穷时间戳(不是 +/-无穷)</td> 
   <td align="left"><code>isfinite(timestamp '2001-02-16 21:28:30')</code></td> 
   <td align="left"><code>true</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>isfinite(interval)</code></td> 
   <td align="left"><code>boolean</code></td> 
   <td align="left">测试是否为有穷时间间隔</td> 
   <td align="left"><code>isfinite(interval '4 hours')</code></td> 
   <td align="left"><code>true</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>justify_days(interval)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">按照每月 30 天调整时间间隔</td> 
   <td align="left"><code>justify_days(interval '35 days')</code></td> 
   <td align="left"><code>1 mon 5 days</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>justify_hours(interval)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">按照每天 24 小时调整时间间隔</td> 
   <td align="left"><code>justify_hours(interval '27 hours')</code></td> 
   <td align="left"><code>1 day 03:00:00</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>justify_interval(interval)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">使用<code>justify_days</code>和<code>justify_hours</code>调整时间间隔的同时进行正负号调整</td> 
   <td align="left"><code>justify_interval(interval '1 mon -1 hour')</code></td> 
   <td align="left"><code>29 days 23:00:00</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>localtime</code></td> 
   <td align="left"><code>time</code></td> 
   <td align="left">当日时间；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>localtimestamp</code></td> 
   <td align="left"><code>timestamp</code></td> 
   <td align="left">当前事务开始时的时间戳；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>make_date(year int, month int, day int)</code></td> 
   <td align="left"><code>date</code></td> 
   <td align="left">为年、月和日字段创建日期</td> 
   <td align="left"><code>make_date(2013, 7, 15)</code></td> 
   <td align="left"><code>2013-07-15</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>make_interval(years int DEFAULT 0, months int DEFAULT 0, weeks int DEFAULT 0, days int DEFAULT 0, hours int DEFAULT 0, mins int DEFAULT 0, secs double precision DEFAULT 0.0)</code></td> 
   <td align="left"><code>interval</code></td> 
   <td align="left">从年、月、周、天、小时、分钟和秒字段中创建间隔</td> 
   <td align="left"><code>make_interval(days := 10)</code></td> 
   <td align="left"><code>10 days</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>make_time(hour int, min int, sec double precision)</code></td> 
   <td align="left"><code>time</code></td> 
   <td align="left">从小时、分钟和秒字段中创建时间</td> 
   <td align="left"><code>make_time(8, 15, 23.5)</code></td> 
   <td align="left"><code>08:15:23.5</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>make_timestamp(year int, month int, day int, hour int, min int, sec double precision)</code></td> 
   <td align="left"><code>timestamp</code></td> 
   <td align="left">从年、月、日、小时、分钟和秒字段中创建时间戳</td> 
   <td align="left"><code>make_timestamp(2013, 7, 15, 8, 15, 23.5)</code></td> 
   <td align="left"><code>2013-07-15 08:15:23.5</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>make_timestamptz(year int, month int, day int, hour int, min int, sec double precision, [ timezone text ])</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">从年、月、日、小时、分钟和秒字段中创建带有时区的时间戳。 没有指定<code>timezone</code>时，使用当前的时区。</td> 
   <td align="left"><code>make_timestamptz(2013, 7, 15, 8, 15, 23.5)</code></td> 
   <td align="left"><code>2013-07-15 08:15:23.5+01</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>now()</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">当前事务开始时的时间戳；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>statement_timestamp()</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">实时时钟的当前时间戳；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>timeofday()</code></td> 
   <td align="left"><code>text</code></td> 
   <td align="left">与<code>clock_timestamp</code>相同，但结果是一个<code>text</code> 字符串；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>transaction_timestamp()</code></td> 
   <td align="left"><code>timestamp with time zone</code></td> 
   <td align="left">当前事务开始时的时间戳；</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

# PostgreSQL 常用函数 #

PostgreSQL 内置函数也称为聚合函数，用于对字符串或数字数据执行处理。

下面是所有通用 PostgreSQL 内置函数的列表：

*  COUNT 函数：用于计算数据库表中的行数。
 *  MAX 函数：用于查询某一特定列中最大值。
 *  MIN 函数：用于查询某一特定列中最小值。
 *  AVG 函数：用于计算某一特定列中平均值。
 *  SUM 函数：用于计算数字列所有值的总和。
 *  ARRAY 函数：用于输入值(包括null)添加到数组中。
 *  Numeric 函数：完整列出一个 SQL 中所需的操作数的函数。
 *  String 函数：完整列出一个 SQL 中所需的操作字符的函数。

--------------------

## 数学函数 ##

下面是PostgreSQL中提供的数学函数列表，需要说明的是，这些函数中有许多都存在多种形式，区别只是参数类型不同。除非特别指明，任何特定形式的函数都返回和它的参数相同的数据类型。

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">返回类型</th> 
   <th align="left">描述</th> 
   <th align="left">例子</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">abs(x)</td> 
   <td align="left"></td> 
   <td align="left">绝对值</td> 
   <td align="left">abs(-17.4)</td> 
   <td align="left">17.4</td> 
  </tr> 
  <tr> 
   <td align="left">cbrt(double)</td> 
   <td align="left"></td> 
   <td align="left">立方根</td> 
   <td align="left">cbrt(27.0)</td> 
   <td align="left">3</td> 
  </tr> 
  <tr> 
   <td align="left">ceil(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">不小于参数的最小的整数</td> 
   <td align="left">ceil(-42.8)</td> 
   <td align="left">-42</td> 
  </tr> 
  <tr> 
   <td align="left">degrees(double)</td> 
   <td align="left"></td> 
   <td align="left">把弧度转为角度</td> 
   <td align="left">degrees(0.5)</td> 
   <td align="left">28.6478897565412</td> 
  </tr> 
  <tr> 
   <td align="left">exp(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">自然指数</td> 
   <td align="left">exp(1.0)</td> 
   <td align="left">2.71828182845905</td> 
  </tr> 
  <tr> 
   <td align="left">floor(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">不大于参数的最大整数</td> 
   <td align="left">floor(-42.8)</td> 
   <td align="left">-43</td> 
  </tr> 
  <tr> 
   <td align="left">ln(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">自然对数</td> 
   <td align="left">ln(2.0)</td> 
   <td align="left">0.693147180559945</td> 
  </tr> 
  <tr> 
   <td align="left">log(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">10为底的对数</td> 
   <td align="left">log(100.0)</td> 
   <td align="left">2</td> 
  </tr> 
  <tr> 
   <td align="left">log(b numeric,x numeric)</td> 
   <td align="left">numeric</td> 
   <td align="left">指定底数的对数</td> 
   <td align="left">log(2.0, 64.0)</td> 
   <td align="left">6.0000000000</td> 
  </tr> 
  <tr> 
   <td align="left">mod(y, x)</td> 
   <td align="left"></td> 
   <td align="left">取余数</td> 
   <td align="left">mod(9,4)</td> 
   <td align="left">1</td> 
  </tr> 
  <tr> 
   <td align="left">pi()</td> 
   <td align="left">double</td> 
   <td align="left">"π"常量</td> 
   <td align="left">pi()</td> 
   <td align="left">3.14159265358979</td> 
  </tr> 
  <tr> 
   <td align="left">power(a double, b double)</td> 
   <td align="left">double</td> 
   <td align="left">求a的b次幂</td> 
   <td align="left">power(9.0, 3.0)</td> 
   <td align="left">729</td> 
  </tr> 
  <tr> 
   <td align="left">power(a numeric, b numeric)</td> 
   <td align="left">numeric</td> 
   <td align="left">求a的b次幂</td> 
   <td align="left">power(9.0, 3.0)</td> 
   <td align="left">729</td> 
  </tr> 
  <tr> 
   <td align="left">radians(double)</td> 
   <td align="left">double</td> 
   <td align="left">把角度转为弧度</td> 
   <td align="left">radians(45.0)</td> 
   <td align="left">0.785398163397448</td> 
  </tr> 
  <tr> 
   <td align="left">random()</td> 
   <td align="left">double</td> 
   <td align="left">0.0到1.0之间的随机数值</td> 
   <td align="left">random()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">round(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">圆整为最接近的整数</td> 
   <td align="left">round(42.4)</td> 
   <td align="left">42</td> 
  </tr> 
  <tr> 
   <td align="left">round(v numeric, s int)</td> 
   <td align="left">numeric</td> 
   <td align="left">圆整为s位小数数字</td> 
   <td align="left">round(42.438,2)</td> 
   <td align="left">42.44</td> 
  </tr> 
  <tr> 
   <td align="left">sign(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">参数的符号(-1,0,+1)</td> 
   <td align="left">sign(-8.4)</td> 
   <td align="left">-1</td> 
  </tr> 
  <tr> 
   <td align="left">sqrt(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">平方根</td> 
   <td align="left">sqrt(2.0)</td> 
   <td align="left">1.4142135623731</td> 
  </tr> 
  <tr> 
   <td align="left">trunc(double/numeric)</td> 
   <td align="left"></td> 
   <td align="left">截断(向零靠近)</td> 
   <td align="left">trunc(42.8)</td> 
   <td align="left">42</td> 
  </tr> 
  <tr> 
   <td align="left">trunc(v numeric, s int)</td> 
   <td align="left">numeric</td> 
   <td align="left">截断为s小数位置的数字</td> 
   <td align="left">trunc(42.438,2)</td> 
   <td align="left">42.43</td> 
  </tr> 
 </tbody> 
</table>

### 三角函数列表 ###

--------------------

## 字符串函数和操作符 ##

下面是 PostgreSQL 中提供的字符串操作符列表：

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">返回类型</th> 
   <th align="left">描述</th> 
   <th align="left">例子</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">string 丨丨 string</td> 
   <td align="left">text</td> 
   <td align="left">字串连接</td> 
   <td align="left">‘Post’ 丨丨 ‘greSQL’</td> 
   <td align="left">PostgreSQL</td> 
  </tr> 
  <tr> 
   <td align="left">bit_length(string)</td> 
   <td align="left">int</td> 
   <td align="left">字串里二进制位的个数</td> 
   <td align="left">bit_length(‘jose’)</td> 
   <td align="left">32</td> 
  </tr> 
  <tr> 
   <td align="left">char_length(string)</td> 
   <td align="left">int</td> 
   <td align="left">字串中的字符个数</td> 
   <td align="left">char_length(‘jose’)</td> 
   <td align="left">4</td> 
  </tr> 
  <tr> 
   <td align="left">convert(string using conversion_name)</td> 
   <td align="left">text</td> 
   <td align="left">使用指定的转换名字改变编码。</td> 
   <td align="left">convert(‘PostgreSQL’ using iso_8859_1_to_utf8)</td> 
   <td align="left">‘PostgreSQL’</td> 
  </tr> 
  <tr> 
   <td align="left">lower(string)</td> 
   <td align="left">text</td> 
   <td align="left">把字串转化为小写</td> 
   <td align="left">lower(‘TOM’)</td> 
   <td align="left">tom</td> 
  </tr> 
  <tr> 
   <td align="left">octet_length(string)</td> 
   <td align="left">int</td> 
   <td align="left">字串中的字节数</td> 
   <td align="left">octet_length(‘jose’)</td> 
   <td align="left">4</td> 
  </tr> 
  <tr> 
   <td align="left">overlay(string placing string from int [for int])</td> 
   <td align="left">text</td> 
   <td align="left">替换子字串</td> 
   <td align="left">overlay(‘Txxxxas’ placing ‘hom’ from 2 for 4)</td> 
   <td align="left">Thomas</td> 
  </tr> 
  <tr> 
   <td align="left">position(substring in string)</td> 
   <td align="left">int</td> 
   <td align="left">指定的子字串的位置</td> 
   <td align="left">position(‘om’ in ‘Thomas’)</td> 
   <td align="left">3</td> 
  </tr> 
  <tr> 
   <td align="left">substring(string [from int] [for int])</td> 
   <td align="left">text</td> 
   <td align="left">抽取子字串</td> 
   <td align="left">substring(‘Thomas’ from 2 for 3)</td> 
   <td align="left">hom</td> 
  </tr> 
  <tr> 
   <td align="left">substring(string from pattern)</td> 
   <td align="left">text</td> 
   <td align="left">抽取匹配 POSIX 正则表达式的子字串</td> 
   <td align="left">substring(‘Thomas’ from ‘…$’)</td> 
   <td align="left">mas</td> 
  </tr> 
  <tr> 
   <td align="left">substring(string from pattern for escape)</td> 
   <td align="left">text</td> 
   <td align="left">抽取匹配SQL正则表达式的子字串</td> 
   <td align="left">substring(‘Thomas’ from ‘%#“o_a#”_’ for ‘#’)</td> 
   <td align="left">oma</td> 
  </tr> 
  <tr> 
   <td align="left">trim([leading丨trailing 丨 both] [characters] from string)</td> 
   <td align="left">text</td> 
   <td align="left">从字串string的开头/结尾/两边/ 删除只包含characters(默认是一个空白)的最长的字串</td> 
   <td align="left">trim(both ‘x’ from ‘xTomxx’)</td> 
   <td align="left">Tom</td> 
  </tr> 
  <tr> 
   <td align="left">upper(string)</td> 
   <td align="left">text</td> 
   <td align="left">把字串转化为大写。</td> 
   <td align="left">upper(‘tom’)</td> 
   <td align="left">TOM</td> 
  </tr> 
  <tr> 
   <td align="left">ascii(text)</td> 
   <td align="left">int</td> 
   <td align="left">参数第一个字符的ASCII码</td> 
   <td align="left">ascii(‘x’)</td> 
   <td align="left">120</td> 
  </tr> 
  <tr> 
   <td align="left">btrim(string text [, characters text])</td> 
   <td align="left">text</td> 
   <td align="left">从string开头和结尾删除只包含在characters里(默认是空白)的字符的最长字串</td> 
   <td align="left">btrim(‘xyxtrimyyx’,‘xy’)</td> 
   <td align="left">trim</td> 
  </tr> 
  <tr> 
   <td align="left">chr(int)</td> 
   <td align="left">text</td> 
   <td align="left">给出ASCII码的字符</td> 
   <td align="left">chr(65)</td> 
   <td align="left">A</td> 
  </tr> 
  <tr> 
   <td align="left">convert(string text, [src_encoding name,] dest_encoding name)</td> 
   <td align="left">text</td> 
   <td align="left">把字串转换为dest_encoding</td> 
   <td align="left">convert( ‘text_in_utf8’, ‘UTF8’, ‘LATIN1’)</td> 
   <td align="left">以ISO 8859-1编码表示的text_in_utf8</td> 
  </tr> 
  <tr> 
   <td align="left">initcap(text)</td> 
   <td align="left">text</td> 
   <td align="left">把每个单词的第一个子母转为大写，其它的保留小写。单词是一系列字母数字组成的字符，用非字母数字分隔。</td> 
   <td align="left">initcap(‘hi thomas’)</td> 
   <td align="left">Hi Thomas</td> 
  </tr> 
  <tr> 
   <td align="left">length(string text)</td> 
   <td align="left">int</td> 
   <td align="left">string中字符的数目</td> 
   <td align="left">length(‘jose’)</td> 
   <td align="left">4</td> 
  </tr> 
  <tr> 
   <td align="left">lpad(string text, length int [, fill text])</td> 
   <td align="left">text</td> 
   <td align="left">通过填充字符fill(默认为空白)，把string填充为长度length。 如果string已经比length长则将其截断(在右边)。</td> 
   <td align="left">lpad(‘hi’, 5, ‘xy’)</td> 
   <td align="left">xyxhi</td> 
  </tr> 
  <tr> 
   <td align="left">ltrim(string text [, characters text])</td> 
   <td align="left">text</td> 
   <td align="left">从字串string的开头删除只包含characters(默认是一个空白)的最长的字串。</td> 
   <td align="left">ltrim(‘zzzytrim’,‘xyz’)</td> 
   <td align="left">trim</td> 
  </tr> 
  <tr> 
   <td align="left">md5(string text)</td> 
   <td align="left">text</td> 
   <td align="left">计算给出string的MD5散列，以十六进制返回结果。</td> 
   <td align="left">md5(‘abc’)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">repeat(string text, number int)</td> 
   <td align="left">text</td> 
   <td align="left">重复string number次。</td> 
   <td align="left">repeat(‘Pg’, 4)</td> 
   <td align="left">PgPgPgPg</td> 
  </tr> 
  <tr> 
   <td align="left">replace(string text, from text, to text)</td> 
   <td align="left">text</td> 
   <td align="left">把字串string里出现地所有子字串from替换成子字串to。</td> 
   <td align="left">replace(‘abcdefabcdef’, ‘cd’, ‘XX’)</td> 
   <td align="left">abXXefabXXef</td> 
  </tr> 
  <tr> 
   <td align="left">rpad(string text, length int [, fill text])</td> 
   <td align="left">text</td> 
   <td align="left">通过填充字符fill(默认为空白)，把string填充为长度length。如果string已经比length长则将其截断。</td> 
   <td align="left">rpad(‘hi’, 5, ‘xy’)</td> 
   <td align="left">hixyx</td> 
  </tr> 
  <tr> 
   <td align="left">rtrim(string text [, character text])</td> 
   <td align="left">text</td> 
   <td align="left">从字串string的结尾删除只包含character(默认是个空白)的最长的字</td> 
   <td align="left">rtrim(‘trimxxxx’,‘x’)</td> 
   <td align="left">trim</td> 
  </tr> 
  <tr> 
   <td align="left">split_part(string text, delimiter text, field int)</td> 
   <td align="left">text</td> 
   <td align="left">根据delimiter分隔string返回生成的第field个子字串(1 Base)。</td> 
   <td align="left">split_part(‘abc<sub>@</sub>def<sub>@</sub>ghi’, ‘<sub>@</sub>’, 2)</td> 
   <td align="left">def</td> 
  </tr> 
  <tr> 
   <td align="left">strpos(string, substring)</td> 
   <td align="left">text</td> 
   <td align="left">声明的子字串的位置。</td> 
   <td align="left">strpos(‘high’,‘ig’)</td> 
   <td align="left">2</td> 
  </tr> 
  <tr> 
   <td align="left">substr(string, from [, count])</td> 
   <td align="left">text</td> 
   <td align="left">抽取子字串。</td> 
   <td align="left">substr(‘alphabet’, 3, 2)</td> 
   <td align="left">ph</td> 
  </tr> 
  <tr> 
   <td align="left">to_ascii(text [, encoding])</td> 
   <td align="left">text</td> 
   <td align="left">把text从其它编码转换为ASCII。</td> 
   <td align="left">to_ascii(‘Karel’)</td> 
   <td align="left">Karel</td> 
  </tr> 
  <tr> 
   <td align="left">to_hex(number int/bigint)</td> 
   <td align="left">text</td> 
   <td align="left">把number转换成其对应地十六进制表现形式。</td> 
   <td align="left">to_hex(9223372036854775807)</td> 
   <td align="left">7fffffffffffffff</td> 
  </tr> 
  <tr> 
   <td align="left">translate(string text, from text, to text)</td> 
   <td align="left">text</td> 
   <td align="left">把在string中包含的任何匹配from中的字符的字符转化为对应的在to中的字符。</td> 
   <td align="left">translate(‘12345’, ‘14’, ‘ax’)</td> 
   <td align="left">a23x5</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 类型转换相关函数 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">返回类型</th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">to_char(timestamp, text)</td> 
   <td align="left">text</td> 
   <td align="left">将时间戳转换为字符串</td> 
   <td align="left">to_char(current_timestamp, ‘HH12:MI:SS’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_char(interval, text)</td> 
   <td align="left">text</td> 
   <td align="left">将时间间隔转换为字符串</td> 
   <td align="left">to_char(interval ‘15h 2m 12s’, ‘HH24:MI:SS’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_char(int, text)</td> 
   <td align="left">text</td> 
   <td align="left">整型转换为字符串</td> 
   <td align="left">to_char(125, ‘999’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_char(double precision, text)</td> 
   <td align="left">text</td> 
   <td align="left">双精度转换为字符串</td> 
   <td align="left">to_char(125.8::real, ‘999D9’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_char(numeric, text)</td> 
   <td align="left">text</td> 
   <td align="left">数字转换为字符串</td> 
   <td align="left">to_char(-125.8, ‘999D99S’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_date(text, text)</td> 
   <td align="left">date</td> 
   <td align="left">字符串转换为日期</td> 
   <td align="left">to_date(‘05 Dec 2000’, ‘DD Mon YYYY’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_number(text, text)</td> 
   <td align="left">numeric</td> 
   <td align="left">转换字符串为数字</td> 
   <td align="left">to_number(‘12,454.8-’, ‘99G999D9S’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_timestamp(text, text)</td> 
   <td align="left">timestamp</td> 
   <td align="left">转换为指定的时间格式 time zone convert string to time stamp</td> 
   <td align="left">to_timestamp(‘05 Dec 2000’, ‘DD Mon YYYY’)</td> 
  </tr> 
  <tr> 
   <td align="left">to_timestamp(double precision)</td> 
   <td align="left">timestamp</td> 
   <td align="left">把UNIX纪元转换成时间戳</td> 
   <td align="left">to_timestamp(1284352323)</td> 
  </tr> 
 </tbody> 
</table>

> 参考文章：https://blog.csdn.net/sun5769675/article/details/50628979

[PostgreSQL]: https://www.runoob.com/manual/PostgreSQL/datatype.html
[1586321979975]: 
[INSERT INTO]: https://www.runoob.com/postgresql/postgresql-insert-into.html
[COMPANY SQL]: https://static.runoob.com/download/company.sql
[COMPANY SQL 1]: https://static.runoob.com/download/department.sql