logo - 跳到首页

VastbaseG100

基于openGauss内核开发的企业级关系型数据库。

Menu

CREATE TABLE PARTITION

功能描述

创建分区表。分区表是把逻辑上的一张表根据某种方案分成几张物理块进行存储，这张逻辑上的表称之为分区表，物理块称之为分区。分区表是一张逻辑表，不存储数据，数据实际是存储在分区上的。

常见的分区方案有范围分区（Range Partitioning）、间隔分区（Interval Partitioning）、哈希分区（Hash Partitioning）、列表分区（List Partitioning）、数值分区（Value Partition）等。目前行存表支持范围分区、间隔分区、哈希分区、列表分区，列存表仅支持范围分区。

  • 范围分区是根据表的一列或者多列，将要插入表的记录分为若干个范围，这些范围在不同的分区里没有重叠。为每个范围创建一个分区，用来存储相应的数据。

    范围分区的分区策略是指记录插入分区的方式。目前范围分区仅支持范围分区策略。

    范围分区策略：根据分区键值将记录映射到已创建的某个分区上，如果可以映射到已创建的某一分区上，则把记录插入到对应的分区上，否则给出报错和提示信息。这是最常用的分区策略。

  • 间隔分区是一种特殊的范围分区，相比范围分区，新增间隔值定义，当插入记录找不到匹配的分区时，可以根据间隔值自动创建分区。

    间隔分区只支持基于表的一列分区，并且该列只支持TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE数据类型。

    间隔分区策略：根据分区键值将记录映射到已创建的某个分区上，如果可以映射到已创建的某一分区上，则把记录插入到对应的分区上，否则根据分区键值和表定义信息自动创建一个分区，然后将记录插入新分区中，新创建的分区数据范围等于间隔值。

  • 哈希分区是根据表的一列，为每个分区指定模数和余数，将要插入表的记录划分到对应的分区中，每个分区所持有的行都需要满足条件：分区键的值除以为其指定的模数将产生为其指定的余数。

    哈希分区策略：根据分区键值将记录映射到已创建的某个分区上，如果可以映射到已创建的某一分区上，则把记录插入到对应的分区上，否则返回报错和提示信息。

  • 列表分区是根据表的一列，将要插入表的记录通过每一个分区中出现的键值划分到对应的分区中，这些键值在不同的分区里没有重叠。为每组键值创建一个分区，用来存储相应的数据。

    列表分区策略：根据分区键值将记录映射到已创建的某个分区上，如果可以映射到已创建的某一分区上，则把记录插入到对应的分区上，否则给出报错和提示信息。

  • 系统分区（System Partitioning）可以对没有分区键的表进行分区。创建分区时可以指定分区名称，也可以不指定分区名称，由系统自动分配。

分区可以提供若干好处：

  • 某些类型的查询性能可以得到极大提升。特别是表中访问率较高的行位于一个单独分区或少数几个分区上的情况下。分区可以减少数据的搜索空间，提高数据访问效率。
  • 当查询或更新一个分区的大部分记录时，连续扫描那个分区而不是访问整个表可以获得巨大的性能提升。
  • 如果需要大量加载或者删除的记录位于单独的分区上，则可以通过直接读取或删除那个分区以获得巨大的性能提升，同时还可以避免由于大量DELETE导致的VACUUM超载（仅范围分区）。

注意事项

  • 唯一约束和主键约束的约束键包含所有分区键将为约束创建LOCAL索引，否则创建GLOBAL索引。
  • 目前哈希分区和列表分区仅支持单列构建分区键，暂不支持多列构建分区键。
  • 只需要有间隔分区表的INSERT权限，往该表INSERT数据时就可以自动创建分区。
  • 对于分区表PARTITION FOR (values)语法，values只能是常量。
  • 对于分区表PARTITION FOR (values)语法，values在需要数据类型转换时，建议使用强制类型转换，以防隐式类型转换结果与预期不符。
  • 分区数最大值为1048575个，一般情况下业务不可能创建这么多分区，这样会导致内存不足。应参照参数local_syscache_threshold的值合理创建分区，分区表使用内存大致为（分区数 * 3 / 1024）MB。理论上分区占用内存不允许大于local_syscache_threshold的值，同时还需要预留部分空间以供其他功能使用。
  • 指定分区语句目前不能走全局索引扫描。
  • 当分区数太多导致内存不足时，会间接导致性能急剧下降。
  • List分区是按分区数组的第一个元素排序的。

语法格式

CREATE TABLE [ IF NOT EXISTS ] partition_table_name
( [
  { column_name data_type [ CHARACTER SET | CHARSET charset ]
    [ COLLATE collation ] [ column_constraint [ ... ] ]
    | table_constraint
    | LIKE source_table [ like_option [...] ] }
    [, ... ]
] )
[ [ DEFAULT ] CHARACTER SET | CHARSET [ = ] default_charset ][ [ DEFAULT ] COLLATE [ = ] default_collation ]
[ WITH ( {storage_parameter = value} [, ... ] ) ]
[ COMPRESS | NOCOMPRESS ]
[ TABLESPACE tablespace_name ]
[ DISTRIBUTE BY { REPLICATION | { [ HASH ] ( column_name ) } } ]
[ TO { GROUP groupname | NODE ( nodename [, ... ] ) } ]
{ PARTITION BY {
      { VALUES ( column_name [, ... ] ) } |
      {RANGE [ COLUMNS ] (partition_key) [ INTERVAL ('interval_expr') [ STORE IN ( tablespace_name [, ...] ) ] ] [ PARTITIONS integer ] ( partition_less_than_item [, ... ] )} |
      {RANGE [ COLUMNS ] (partition_key) [ INTERVAL ('interval_expr') [ STORE IN ( tablespace_name [, ...] ) ] ] [ PARTITIONS integer ] ( partition_start_end_item [, ... ] )} |
      {{{LIST [ COLUMNS ]} | HASH | KEY} (partition_key) [ PARTITIONS integer ] (PARTITION partition_name [ VALUES [ IN ] (list_values_clause)
 ] opt_table_space ) }
      | { COLUMN ( partition_name ( column_name [, ... ] ) [, ... ] ) }
      | { SYSTEM }
  } | { { RANGE | LIST | HASH } ( column_name ) }
}
[ SUBPARTITION BY [ RANGE | LIST | HASH ] ( column_name [, ... ] ) ]
[ { SUBPARTITION TEMPLATE ( subpartition_desc [, ... ] ) } | hash_subpartitions_by_quantity ]
table_partitioning_clauses
[ { ENABLE | DISABLE } ROW MOVEMENT ];

  • 列约束column_constraint：

    [ CONSTRAINT constraint_name ]
{ NOT NULL |
NULL |
CHECK ( expression ) |
DEFAULT default_expr |
GENERATED ALWAYS AS ( generation_expr ) [STORED] |
UNIQUE [KEY] index_parameters |
PRIMARY KEY index_parameters |
REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
[ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE | INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

  • 表约束table_constraint：

    [ CONSTRAINT constraint_name ]
{ CHECK ( expression ) |
UNIQUE ( column_name [, ... ] ) index_parameters |
PRIMARY KEY ( column_name [, ... ] ) index_parameters |
FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
[ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE | INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

  • 索引存储参数index_parameters：

    [ WITH ( {storage_parameter = value} [, ... ] ) ]
[ USING INDEX TABLESPACE tablespace_name ]

  • like选项like_option：

    { INCLUDING | EXCLUDING } { DEFAULTS | GENERATED | CONSTRAINTS | INDEXES | STORAGE | COMMENTS | RELOPTIONS | DISTRIBUTION | ALL }

  • partition_less_than_item：

    PARTITION partition_name VALUES LESS THAN { ( { partition_value | MAXVALUE } [, ... ] ) | MAXVALUE } [TABLESPACE [=] tablespace_name]

    不在括号内的MAVALUE只能在MySQL兼容模式中使用，并且只能有一个分区键。

  • table_partitioning_clauses：

    { ( { partition_desc [ ( subpartition_desc [, ... ] )
                   | hash_subpartitions_by_quantity ] } [, ... ] )
| hash_partitions_by_quantity }

  • partition_desc：

    { range_partition_less_than_desc
| range_partition_start_end_desc
| list_partition_desc
| hash_partition_desc
| system_partition_desc
}

  • subpartition_desc：

    { range_subpartition_less_than_desc
| range_subpartition_start_end_desc
| list_subpartition_desc
| hash_subpartition_desc
}

  • range_partition_less_than_desc / range_subpartition_less_than_desc：

    { PARTITION | SUBPARTITION } partition_name
VALUES LESS THAN ( { partition_value | MAXVALUE } [, ... ] )
[ TABLESPACE tablespace_name ]

  • range_partition_start_end_desc / range_subpartition_start_end_desc：

    { PARTITION | SUBPARTITION } partition_name
{ { START ( partition_value ) END ( partition_value ) EVERY ( interval_value ) } |
{ START ( partition_value ) END ( { partition_value | MAXVALUE } ) } |
{ START ( partition_value ) } |
{ END ( { partition_value | MAXVALUE } ) } }
[ TABLESPACE tablespace_name ]

  • list_partition_desc / list_subpartition_desc：

    { PARTITION | SUBPARTITION } partition_name
VALUES ( { partition_value [, ... ] } | DEFAULT )
[ TABLESPACE tablespace_name ]

  • hash_partition_desc / hash_subpartition_desc：

    { PARTITION | SUBPARTITION } partition_name
[ TABLESPACE tablespace_name ]

  • hash_partitions_by_quantity / hash_subpartitions_by_quantity：

    { PARTITIONS | SUBPARTITIONS } integer [ STORE IN ( tablespace_name [, ... ] ) ]

  • system_partition_desc：

    { PARTITION } partition_name
[ TABLESPACE tablespace_name ]

  • 以下兼容PG风格的分区声明语法仅在PostgreSQL兼容模式下支持，详见PostgreSQL兼容性手册中的CREATE TABLE PARTITION。

    In PG-Format Database, CREATE TABLE PARTITION OF can be:
CREATE TABLE [ IF NOT EXISTS ] partition_table_name PARTITION OF parent_table_name FOR VALUES
{ IN ( partition_value [, ...] ) |
FROM ( { partition_value | MINVALUE | MAXVALUE } [, ...] )
TO ( { partition_value | MINVALUE | MAXVALUE } [, ...] ) |
WITH ( MODULUS numeric_literal, REMAINDER numeric_literal ) }
[ PARTITION BY { RANGE | LIST | HASH } ( column_name ) ]

参数说明

  • IF NOT EXISTS

    如果已经存在相同名称的表，不会抛出一个错误，而会发出一个通知，告知表关系已存在。

  • partition_table_name

    分区表的名称。

    取值范围：字符串，要符合标识符的命名规范。

  • column_name

    新表中要创建的字段名。

    取值范围：字符串，要符合标识符的命名规范。

  • data_type

    字段的数据类型。

  • COLLATE collation

    COLLATE子句指定列的排序规则（该列必须是可排列的数据类型）。如果没有指定，则使用默认的排序规则。排序规则可以使用select * from pg_collation;命令从pg_collation系统表中查询，默认的排序规则为查询结果中以default开始的行。

  • [ column_constraint [ … ] ]

    列约束。可选的约束子句用于声明约束，新行或者更新的行必须满足这些约束才能成功插入或更新。

    列约束作为一个列定义的一部分，仅影响该列。

  • table_constraint

    表约束。不和某个列绑在一起，可以作用于多个列。

  • [ DEFAULT ] CHARACTER SET | CHARSET [ = ] default_charset

    指定模式的默认字符集，单独指定时会将模式的默认字符序设置为指定的字符集的默认字符序。

  • [ DEFAULT ] COLLATE [ = ] default_collation

    指定模式的默认字符序，单独指定时会将模式的默认字符集设置为指定的字符序对应的字符集。

  • WITH ( storage_parameter [= value] [, … ] )

    这个子句为表或索引指定一个可选的存储参数。参数的详细描述如下所示：

    • FILLFACTOR

      一个表的填充因子（fillfactor）是一个介于10和100之间的百分数。100（完全填充）是默认值。如果指定了较小的填充因子，INSERT操作仅按照填充因子指定的百分率填充表页。每个页上的剩余空间将用于在该页上更新行，这就使得UPDATE有机会在同一页上放置同一条记录的新版本，这比把新版本放置在其他页上更有效。对于一个从不更新的表将填充因子设为100是最佳选择，但是对于频繁更新的表，选择较小的填充因子则更加合适。该参数对于列存表没有意义。

      取值范围：10~100

    • ORIENTATION

      决定了表的数据的存储方式。

      取值范围：

      • COLUMN：表的数据将以列式存储。

      • ROW（缺省值）：表的数据将以行式存储。

        orientation不支持修改。

    • STORAGE_TYPE

      指定存储引擎类型，该参数设置成功后就不再支持修改。

      取值范围：

      • USTORE，表示表支持Inplace-Update存储引擎。特别需要注意，使用USTORE表，必须要开启track_counts和track_activities参数，否则会引起空间膨胀。
      • ASTORE，表示表支持Append-Only存储引擎。

      默认值：不指定表时，默认是Append-Only存储。

    • COMPRESSION

      • 列存表的有效值为LOW/MIDDLE/HIGH/YES/NO，压缩级别依次升高，默认值为LOW。

    • COMPRESSTYPE

      行存表参数，设置行存表压缩算法。1代表pglz算法（不推荐使用），2代表zstd算法，默认不压缩。该参数生效后不允许修改。（仅支持ASTORE下的普通表和分区表）

      取值范围：0~2，默认值为0。

    • COMPRESS_LEVEL

      行存表参数，设置行存表压缩算法等级，仅当COMPRESSTYPE为2时生效。压缩等级越高，表的压缩效果越好，表的访问速度越慢。该参数允许修改，修改后影响变更数据、新增数据的压缩等级。（仅支持ASTORE下的普通表和分区表）

      取值范围：-31~31，默认值为0。

    • COMPRESS_CHUNK_SIZE

      行存表参数，设置行存表压缩chunk块大小。chunk数据块越小，预期能达到的压缩效果越好，同时数据越离散，影响表的访问速度。该参数生效后不允许修改。（仅支持ASTORE下的普通表和分区表）

      取值范围：与页面大小有关。在页面大小为8k场景，取值范围为：512、1024、2048、4096。

      默认值：4096

    • COMPRESS_PREALLOC_CHUNKS

      行存表参数，设置行存表压缩chunk块预分配数量。预分配数量越大，表的压缩率相对越差，离散度越小，访问性能越好。该参数允许修改，修改后影响变更数据、新增数据的预分配数量。（仅支持ASTORE下的普通表和分区表）

      取值范围：0~7，默认值为0。

      • 当COMPRESS_CHUNK_SIZE为512和1024时，支持预分配设置最大为7。
      • 当COMPRESS_CHUNK_SIZE为2048时，支持预分配设置最大为3。
      • 当COMPRESS_CHUNK_SIZE为4096时，支持预分配设置最大为1。

    • COMPRESS_BYTE_CONVERT

      行存表参数，设置行存表压缩字节转换预处理。在一些场景下可以提升压缩效果，同时会导致一定性能劣化。该参数允许修改，修改后决定变更数据、新增数据是否进行字节转换预处理。当COMPRESS_DIFF_CONVERT为真时，该值不允许修改为假。

      取值范围：布尔值，默认关闭。

    • COMPRESS_DIFF_CONVERT

      行存表参数，设置行存表压缩字节差分预处理。只能与compress_byte_convert一起使用。在一些场景下可以提升压缩效果，同时会导致一定性能劣化。该参数允许修改，修改后决定变更数据、新增数据是否进行字节差分预处理。

      取值范围：布尔值，默认关闭。

    • MAX_BATCHROW

      指定了在数据加载过程中一个存储单元可以容纳记录的最大数目。该参数只对列存表有效。

      取值范围：10000~60000，默认60000。

    • PARTIAL_CLUSTER_ROWS

      指定了在数据加载过程中进行将局部聚簇存储的记录数目。该参数只对列存表有效。

      取值范围：大于等于MAX_BATCHROW，建议取值为MAX_BATCHROW的整数倍数。

    • DELTAROW_THRESHOLD

      预留参数。该参数只对列存表有效。

      取值范围：0～9999

    • segment

      使用段页式的方式存储。本参数仅支持行存表。不支持列存表、临时表、unlog表。不支持ustore存储引擎。

      取值范围：on/off

      默认值：off

  • COMPRESS | NOCOMPRESS

    创建一个新表时，需要在创建表语句中指定关键字COMPRESS，这样，当对该表进行批量插入时就会触发压缩特性。该特性会在页范围内扫描所有元组数据，生成字典、压缩元组数据并进行存储。指定关键字NOCOMPRESS则不对表进行压缩。该参数已废弃，列存表请使用COMPRESSION修改压缩等级。

    缺省值：NOCOMPRESS，即不对元组数据进行压缩。

  • TABLESPACE tablespace_name

    指定新表将要在tablespace_name表空间内创建。如果没有声明，将使用默认表空间。

  • DISTRIBUTE BY { REPLICATION | { [ HASH ] ( column_name ) } }

    此功能暂不支持。

  • TO { GROUP groupname | NODE ( nodename [, … ] ) }

    此语法仅在扩展模式（GUC参数support_extended_features为on）时可用。该模式谨慎打开，主要供内部扩容工具使用，一般用户不应使用该模式。

  • PARTITION BY VALUES ( column_name [, … ] )

    创建数值分区。通过column_name指定分区键。

  • PARTITION BY RANGE [ COLUMNS ] (partition_key)

    创建范围分区。partition_key为分区键的名称。

    COLUMNS关键字只能在MySQL兼容模式中使用，“PARTITION BY RANGE COLUMNS” 语义同 “PARTITION BY RANGE”。

    1、对于从句是VALUES LESS THAN的语法格式：

    对于从句是VALUE LESS THAN的语法格式，范围分区策略的分区键最多支持16列。

    该情形下，分区键支持的数据类型为：SMALLINT、INTEGER、BIGINT、DECIMAL、NUMERIC、REAL、DOUBLE PRECISION、CHARACTER VARYING(n)、VARCHAR(n)、CHARACTER(n)、CHAR(n)、CHARACTER、CHAR、TEXT、NVARCHAR、NVARCHAR2、NAME、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。

    2、对于从句是START END的语法格式：

    对于从句是START END的语法格式，范围分区策略的分区键仅支持1列。

    该情形下，分区键支持的数据类型为：SMALLINT、INTEGER、BIGINT、DECIMAL、NUMERIC、REAL、DOUBLE PRECISION、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。

    3、对于指定了INTERVAL子句的语法格式：

    对于指定了INTERVAL子句的语法格式，范围分区策略的分区键仅支持1列。

    该情形下，分区键支持的数据类型为：TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。

  • INTERVAL ('interval_expr') [ STORE IN (tablespace_name [, … ] ) ]

    间隔分区定义信息。

    • interval_expr： 自动创建分区的间隔，例如：1 day、1 month。

    • STORE IN (tablespace_name [, … ] )： 指定存放自动创建分区的表空间列表，如果有指定，则自动创建的分区从表空间列表中循环选择使用，否则使用分区表默认的表空间。

    列存表不支持间隔分区。

  • partition_less_than_item

    指定各范围分区的信息。通过LESS THAN指定分区的上边界。

  • partition_start_end_item

    通过START END语法指定各范围分区的端点值（起始或终点）。

  • {{LIST [ COLUMNS ] | HASH | KEY} (partition_key) [ PARTITIONS integer ] (PARTITION partition_name [ VALUES [ IN ] (list_values_clause) ] opt_table_space ) }

    • PARTITION BY LIST 表示创建列表分区。partition_key为分区键的名称。partition_name为列表分区的名称。

      COLUMNS关键字只能在sql_compatibility='B'时使用，“PARTITION BY LIST COLUMNS” 语义同 “PARTITION BY LIST”。

      对于partition_key，列表分区策略的分区键最多支持16列。

      对于从句是VALUES [IN] (list_values_clause)的语法格式，list_values_clause中包含了对应分区存在的键值，每个分区的键值数量不超过127个。

      从句“VALUES IN”只能在sql_compatibility='B'时使用，语义同“VALUES”。

      分区键支持的数据类型为：INT1、INT2、INT4、INT8、NUMERIC、VARCHAR(n)、CHAR、BPCHAR、NVARCHAR、NVARCHAR2、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。分区个数不能超过1048575个。

    • PARTITION BY HASH 表示创建哈希分区。partition_key为分区键的名称。partition_name为哈希分区的名称。

      对于partition_key，哈希分区策略的分区键仅支持1列。

      分区键支持的数据类型为：INT1、INT2、INT4、INT8、NUMERIC、VARCHAR(n)、CHAR、BPCHAR、TEXT、NVARCHAR、NVARCHAR2、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。分区个数不能超过1048575 个。

    • PARTITION BY KEY 只能在sql_compatibility='B'时使用，语义同“PARTITION BY HASH(partition_key)”。

    • PARTITIONS integer用于指定分区个数。integer必须为大于0的整数，且不得大于1048575。

      • 当在RANGE和LIST分区后指定此子句时，必须显式定义每个分区，且定义分区的数量必须与integer值相等。只能在MySQL兼容模式中，在RANGE和LIST分区后指定此子句。

      • 当在HASH和KEY分区后指定此子句时，若不列出各个分区定义，将自动生成integer个分区，自动生成的分区名为“p+数字”，数字依次为0到integer-1，分区的表空间默认为此表的表空间；也可以显式列出每个分区定义，此时定义分区的数量必须与integer值相等。

      • 若既不列出分区定义，也不指定分区数量，将创建唯一一个分区。

  • PARTITION BY SYSTEM

    创建系统分区表：系统分区可以对没有分区键的表进行分区。创建分区时可以指定分区名称，也可以不指定分区名称，由系统自动分配。

    system分区表仅在数据库兼容模式为Oracle时支持（即数据库初始化时指定DBCOMPATIBILITY='A'）。

    system分区表暂不支持二级分区、组合分区。

  • SUBPARTITION BY [ RANGE | LIST | HASH ] ( column_name [, … ] )

    创建二级分区，即在原有的range、list、hash分区的基础上再次进行分区。

    二级分区可以对表中的每个分区再次进行分区。一级与二级分区的分区类型可以任意组合。

  • { SUBPARTITION TEMPLATE ( subpartition_desc [, … ] ) } | hash_subpartitions_by_quantity

    常规子分区模板定义语法，适用于Range/List/Hash子分区，当分区定义中没有指定子分区的定义时会根据子分区模板自动生成二级分区。

    子分区模板用于快速定义子分区，简化子分区的规范。只需在子分区模板中定义一次子分区描述符，然后将该子分区模板应用于表中的每个分区，从而快速批量地为表中的分区定义子分区描述符。

    hash_subpartitions_by_quantity：Hash分区持有的子分区模板定义语法（也可用与子分区定义语法），指定创建N个Hash子分区，同时可选指定Hash子分区的tablespace名列表。

    如果分区未指定子分区描述符，也没有提供子分区模板，系统将默认将创建一个默认子分区。

  • { ENABLE | DISABLE } ROW MOVEMENT

    行迁移开关。

    如果进行UPDATE操作时，更新了元组在分区键上的值，造成了该元组所在分区发生变化，就会根据该开关给出报错信息，或者进行元组在分区间的转移。

    取值范围：

    • ENABLE（缺省值）：行迁移开关打开。
    • DISABLE：行迁移开关关闭。

    列表/哈希分区表暂不支持ROW MOVEMENT。

  • CONSTRAINT constraint_name

    列约束或表约束的名称。可选的约束子句用于声明约束，新行或者更新的行必须满足这些约束才能成功插入或更新。

    定义约束有两种方法：

    • 列约束：作为一个列定义的一部分，仅影响该列。
    • 表约束：不和某个列绑在一起，可以作用于多个列。在B模式数据库下（即sql_compatibility = 'B'）constraint_name为可选项，在其他模式数据库下，必须加上constraint_name。

  • NOT NULL | NULL

    • NOT NULL：字段值不允许为NULL。

    • NULL：字段值允许NULL，缺省值。

  • CHECK ( expression )

    CHECK约束声明一个布尔表达式，每次要插入的新行或者要更新的行的新值必须使表达式结果为真或未知才能成功，否则会抛出一个异常并且不会修改数据库。

    声明为字段约束的检查约束应该只引用该字段的数值，而在表约束里出现的表达式可以引用多个字段。

  • DEFAULT default_expr

    DEFAULT子句给字段指定缺省值。该数值可以是任何不含变量的表达式（不允许使用子查询和对本表中的其他字段的交叉引用）。缺省表达式的数据类型必须和字段类型匹配。

    缺省表达式将被用于任何未声明该字段数值的插入操作。如果没有指定缺省值则缺省值为NULL 。

  • GENERATED ALWAYS AS ( generation_expr ) [STORED]

    该子句将字段创建为生成列，生成列的值在写入（插入或更新）数据时由generation_expr计算得到，STORED表示像普通列一样存储生成列的值。

    • STORED关键字可省略，与不省略STORED语义相同。
    • 生成表达式不能以任何方式引用当前行以外的其他数据。生成表达式不能引用其他生成列，不能引用系统列。生成表达式不能返回结果集，不能使用子查询，不能使用聚集函数，不能使用窗口函数。生成表达式调用的函数只能是不可变（IMMUTABLE）函数。
    • 不能为生成列指定默认值。
    • 生成列不能作为分区键的一部分。
    • 生成列不能和ON UPDATE约束字句的CASCADE，SET NULL，SET DEFAULT动作同时指定。生成列不能和ON DELETE约束字句的SET NULL、SET DEFAULT动作同时指定。
    • 修改和删除生成列的方法和普通列相同。删除生成列依赖的普通列，生成列被自动删除。不能改变生成列所依赖的列的类型。
    • 生成列不能被直接写入。在INSERT或UPDATE命令中，不能为生成列指定值，但是可以指定关键字DEFAULT。
    • 生成列的权限控制和普通列一样。
    • 列存表、内存表MOT不支持生成列。外表中仅postgres_fdw支持生成列。

  • PARTITION BY LIST [ COLUMNS ] (partition_key)

    创建列表分区。partition_key为分区键的名称。

    • 对于partition_key，列表分区策略的分区键仅支持16列。
    • 对于从句是VALUES (list_values_clause)的语法格式，list_values_clause中包含了对应分区存在的键值，每个分区的键值数量不超过127个。

    分区键支持的数据类型为：INT1、INT2、INT4、INT8、NUMERIC、VARCHAR(n)、CHAR、BPCHAR、NVARCHAR、NVARCHAR2、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。分区个数不能超过1048575 个。

  • PARTITION BY HASH(partition_key)

    创建哈希分区。partition_key为分区键的名称。

    对于partition_key，哈希分区策略的分区键仅支持1列。

    分区键支持的数据类型为：INT1、INT2、INT4、INT8、NUMERIC、VARCHAR(n)、CHAR、BPCHAR、TEXT、NVARCHAR、NVARCHAR2、TIMESTAMP[(p)] [WITHOUT TIME ZONE]、TIMESTAMP[(p)] [WITH TIME ZONE]、DATE。分区个数不能超过1048575 个。

  • UNIQUE [KEY] index_parameters

    UNIQUE约束表示表里的一个字段或多个字段的组合必须在全表范围内唯一。对于唯一约束，NULL被认为是互不相等的。

    UNIQUE KEY只能在sql_compatibility='B'时使用，与UNIQUE语义相同。

  • PRIMARY KEY ( column_name [, … ] ) index_parameters

    主键约束声明表中的一个或者多个字段只能包含唯一的非NULL值。

    一个表只能声明一个主键。

  • USING INDEX TABLESPACE tablespace_name

    为UNIQUE或PRIMARY KEY约束相关的索引声明一个表空间。如果没有提供这个子句，这个索引将在default_tablespace中创建，如果default_tablespace为空，将使用数据库的缺省表空间。

  • FOREIGN KEY ( column_name [, … ] ) REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ]

    外键约束要求新表中一列或多列构成的组应该只包含、匹配被参考表中被参考字段值。若省略refcolum，则将使用reftable的主键。被参考列应该是被参考表中的唯一字段或主键。外键约束不能被定义在临时表和永久表之间。

    参考字段与被参考字段之间存在三种类型匹配，分别是：

    • MATCH FULL：不允许一个多字段外键的字段为NULL，除非全部外键字段都是NULL。
    • MATCH SIMPLE（缺省）：允许任意外键字段为NULL。
    • MATCH PARTIAL：目前暂不支持。

    另外，当被参考表中的数据发生改变时，某些操作也会在新表对应字段的数据上执行。ON DELETE子句声明当被参考表中的被参考行被删除时要执行的操作。ON UPDATE子句声明当被参考表中的被参考字段数据更新时要执行的操作。对于ON DELETE子句、ON UPDATE子句的可能动作：

    • NO ACTION（缺省）：删除或更新时，创建一个表明违反外键约束的错误。若约束可推迟，且若仍存在任何引用行，那这个错误将会在检查约束的时候产生。
    • RESTRICT：删除或更新时，创建一个表明违反外键约束的错误。与NO ACTION相同，只是动作不可推迟。
    • CASCADE：删除新表中任何引用了被删除行的行，或更新新表中引用行的字段值为被参考字段的新值。
    • SET NULL：设置引用字段为NULL。
    • SET DEFAULT：设置引用字段为它们的缺省值。

  • DEFERRABLE | NOT DEFERRABLE

    这两个关键字设置该约束是否可推迟。一个不可推迟的约束将在每条命令之后马上检查。可推迟约束可以推迟到事务结尾使用SET CONSTRAINTS命令检查。缺省是NOT DEFERRABLE。目前，UNIQUE约束、主键约束、外键约束可以接受这个子句。所有其他约束类型都是不可推迟的。

  • INITIALLY IMMEDIATE | INITIALLY DEFERRED

    如果约束是可推迟的，则这个子句声明检查约束的缺省时间。

    • 如果约束是INITIALLY IMMEDIATE（缺省），则在每条语句执行之后就立即检查它；
    • 如果约束是INITIALLY DEFERRED ，则只有在事务结尾才检查它。

    约束检查的时间可以用SET CONSTRAINTS命令修改。

  • { INCLUDING | EXCLUDING } { DEFAULTS | GENERATED | CONSTRAINTS | INDEXES | STORAGE | COMMENTS | RELOPTIONS | DISTRIBUTION | ALL }

    like_option子句声明一个表，新表自动从这个表中继承所有字段名及其数据类型和非空约束。

    新表与源表之间在创建动作完毕之后是完全无关的。在源表做的任何修改都不会传播到新表中，并且也不可能在扫描源表的时候包含新表的数据。

    被复制的列和约束并不使用相同的名称进行融合。如果明确的指定了相同的名称或者在另外一个LIKE子句中，将会报错。

    • 源表上的字段缺省表达式只有在指定INCLUDING DEFAULTS时，才会复制到新表中。缺省是不包含缺省表达式的，即新表中的所有字段的缺省值都是NULL。
    • 源表上的CHECK约束仅在指定INCLUDING CONSTRAINTS时，会复制到新表中，而其他类型的约束永远不会复制到新表中。非空约束总是复制到新表中。此规则同时适用于表约束和列约束。
    • 如果指定了INCLUDING INDEXES，则源表上的索引也将在新表上创建，默认不建立索引。
    • 如果指定了INCLUDING STORAGE，则复制列的STORAGE设置会复制到新表中，默认情况下不包含STORAGE设置。
    • 如果指定了INCLUDING COMMENTS，则源表列、约束和索引的注释会复制到新表中。默认情况下，不复制源表的注释。
    • 如果指定了INCLUDING PARTITION，则源表的分区定义会复制到新表中，同时新表将不能再使用PARTITION BY子句。默认情况下，不拷贝源表的分区定义。如果源表上带有索引，可以使用INCLUDING PARTITION INCLUDING INDEXES语法实现。如果对分区表只使用INCLUDING INDEXES，目标表定义将是普通表，但是索引是分区索引，最后结果会报错，因为普通表不支持分区索引。
    • 如果指定了INCLUDING RELOPTIONS，则源表的存储参数（即源表的WITH子句）会复制到新表中。默认情况下，不复制源表的存储参数。
    • INCLUDING ALL包含了INCLUDING DEFAULTS、INCLUDING CONSTRAINTS、INCLUDING INDEXES、INCLUDING STORAGE、INCLUDING COMMENTS、INCLUDING PARTITION和INCLUDING RELOPTIONS的内容。
    • ATUO_INCREMENT列需要为主键或唯一约束的第一个字段，若复制包含AUTO_INCREAMENT列的表时指定EXCLUDING INDEX，将会报错。其中AUTO_INCREAMENT只在B库中生效。
    • 如果源表包含serial、bigserial、smallserial、largeserial类型，或者源表字段的默认值是sequence，且sequence属于源表（通过CREATE SEQUENCE … OWNED BY创建），这些Sequence不会关联到新表中，新表中会重新创建属于自己的sequence。这和之前版本的处理逻辑不同。如果用户希望源表和新表共享Sequence，需要首先创建一个共享的Sequence（避免使用OWNED BY），并配置为源表字段默认值，这样创建的新表会和源表共享该Sequence。
    • 不建议将其他表私有的Sequence配置为源表字段的默认值，尤其是其他表只分布在特定的NodeGroup上，这可能导致CREATE TABLE … LIKE执行失败。另外，如果源表配置其他表私有的Sequence，当该表删除时Sequence也会连带删除，这样源表的Sequence将不可用。如果用户希望多个表共享Sequence，建议创建共享的Sequence。
    • 对于分区表EXCLUDING，需要配合INCLUDING ALL使用，如INCLUDING ALL EXCLUDING DEFAULTS，除源分区表的DEFAULTS，其它全包含。
    • 如果源表是本地临时表，则新表也必须是本地临时表，否则会报错。
    • 如果源表是hash或list分区表，则在CREATE TABLE … (LIKE … INCLUDIING PARTITION)时会报错，不支持复制hash或list分区表的分区，仅支持range分区。对于二级分区表，同样只支持range-range二级分区。

  • PARTITION partition_name VALUES LESS THAN {( { partition_value | MAXVALUE } [,…] ) | MAXVALUE }

    指定各分区的信息。partition_name为范围分区的名称。partition_value为范围分区的上边界，取值依赖于partition_key的类型。MAXVALUE表示分区的上边界，它通常用于设置最后一个范围分区的上边界。

    • 每个分区都需要指定一个上边界。
    • 分区上边界的类型应当和分区键的类型一致。
    • 分区列表是按照分区上边界升序排列的，值较小的分区位于值较大的分区之前。
    • 不在括号内的MAXVALUE只能在sql_compatibility='B'时使用，并且只能有一个分区键。

  • { PARTITION | SUBPARTITION } partition_name VALUES LESS THAN ( { partition_value | MAXVALUE } )

    指定各分区的信息。partition_name为范围分区的名称。partition_value为范围分区的上边界，取值依赖于partition_key的类型。MAXVALUE表示分区的上边界，它通常用于设置最后一个范围分区的上边界。

    • 每个分区都需要指定一个上边界。
    • 分区上边界的类型应当和分区键的类型一致。
    • 分区列表是按照分区上边界升序排列的，值较小的分区位于值较大的分区之前。

  • { PARTITION | SUBPARTITION } partition_name START … END…}

    通过START END语法指定各范围分区的端点值（起始或终点）。

    • partition_name：范围分区的名称或名称前缀，除以下情形外（假定其中的partition_name是p1），均为分区的名称。

      • 若该定义是START+END+EVERY从句，则语义上定义的分区的名称依次为p1_1，p1_2， …。例如对于定义“PARTITION p1 START(1) END(4) EVERY(1)”，则生成的分区是：[1, 2), [2, 3) 和 [3, 4)，名称依次为p1_1, p1_2和p1_3，即此处的p1是名称前缀。
      • 若该定义是第一个分区定义，且该定义有START值，则范围 (MINVALUE, START) 将自动作为第一个实际分区，其名称为p1_0，然后该定义语义描述的分区名称依次为p1_1， p1_2， …。例如对于完整定义“PARTITION p1 START(1), PARTITION p2 START(2)”，则生成的分区是：(MINVALUE, 1), [1, 2) 和 [2, MAXVALUE)，其名称依次为p1_0, p1_1和p2，即此处p1是名称前缀，p2是分区名称。这里MINVALUE表示最小值。

    • partition_value：范围分区的端点值（起始或终点），取值依赖于partition_key的类型，不可是MAXVALUE。

    • interval_value：对[START，END) 表示的范围进行切分，interval_value是指定切分后每个分区的宽度，不可是MAXVALUE；如果（END-START）值不能整除以EVERY值，则仅最后一个分区的宽度小于EVERY值。

    • MAXVALUE：表示最大值，它通常用于设置最后一个范围分区的上边界。

    1、在创建分区表若第一个分区定义含START值，则范围（MINVALUE，START）将自动作为实际的第一个分区。

    2、START END语法需要遵循以下限制：

    • 每个partition_start_end_item中的START值（如果有的话，下同）必须小于其END值。
    • 相邻的两个partition_start_end_item，第一个的END值必须等于第二个的START值；
    • 每个partition_start_end_item中的EVERY值必须是正向递增的，且必须小于（END-START）值；
    • 每个分区包含起始值，不包含终点值，即形如：[起始值，终点值)，起始值是MINVALUE时则不包含；
    • 一个partition_start_end_item创建的每个分区所属的TABLESPACE一样；
    • partition_name作为分区名称前缀时，其长度不要超过57字节，超过时自动截断；
    • 在创建、修改分区表时请注意分区表的分区总数不可超过最大限制（1048575）；

    3、 在创建分区表时START END与LESS THAN语法不可混合使用。

    4、 即使创建分区表时使用START END语法，备份（vb_dump）出的SQL语句也是VALUES LESS THAN语法格式。

  • { PARTITION | SUBPARTITION } partition_name VALUES ( { partition_value [, … ] } | DEFAULT )

    指定列表分区信息。列表分区是基于列值匹配一个离散值集合中的某个值来进行选择分区的。

    partition_name为列表分区的名称。partition_value是列表分区的键值。

    Vastbase支持DEFAULT分区，用于存储无法匹配其他任何分区的数据。

    • 已存在default分区的LIST分区不能新增分区。
    • 删除分区时不能只剩下一个default分区。
    • 在创建分区表时，不能只定义一个default分区，并且default分区必须定义在最后。
    • 已经存在default分区的分区表，不能新增分区。
    • 删除分区时，不能只剩下一个default分区。
    • default分区不能进行SPLIT和MERGE操作。

  • { PARTITIONS | SUBPARTITIONS } integer [ STORE IN ( tablespace_name [, … ] ) ]

    hash_partitions_by_quantity/hash_subpartitions_by_quantity子句用于按HASH分区数批量指定哈希分区，所有分区名称由系统生成。

    integer表示一级/二级哈希分区数量。

    STORE IN子句描述HASH分区所属的表空间，表空间可指定多个，且数量不需要与分区的数量一致， 系统将按本语句中表空间指定的顺序进行循环归属。不指定本语句时，系统默认使用表所在的表空间作为所有分区的表空间。

示例

示例1： 创建范围分区表web_returns_p1，含有8个分区，分区键为integer类型。 分区的范围分别为：wr_returned_date_sk< 2450815、2450815<= wr_returned_date_sk< 2451179、2451179<=wr_returned_date_sk< 2451544、2451544 <= wr_returned_date_sk< 2451910、2451910 <= wr_returned_date_sk< 2452275、2452275 <= wr_returned_date_sk< 2452640、2452640 <= wr_returned_date_sk< 2453005、wr_returned_date_sk>=2453005。

    --创建表web_returns。
vastbase=# CREATE TABLE web_returns
(
    W_WAREHOUSE_SK            INTEGER               NOT NULL,
    W_WAREHOUSE_ID            CHAR(16)              NOT NULL,
    W_WAREHOUSE_NAME          VARCHAR(20)                   ,
    W_WAREHOUSE_SQ_FT         INTEGER                       ,
    W_STREET_NUMBER           CHAR(10)                      ,
    W_STREET_NAME             VARCHAR(60)                   ,
    W_STREET_TYPE             CHAR(15)                      ,
    W_SUITE_NUMBER            CHAR(10)                      ,
    W_CITY                    VARCHAR(60)                   ,
    W_COUNTY                  VARCHAR(30)                   ,
    W_STATE                   CHAR(2)                       ,
    W_ZIP                     CHAR(10)                      ,
    W_COUNTRY                 VARCHAR(20)                   ,
    W_GMT_OFFSET              DECIMAL(5,2)
);
    --创建分区表web_returns_p1。
vastbase=# CREATE TABLE web_returns_p1
(
    WR_RETURNED_DATE_SK       INTEGER                       ,
    WR_RETURNED_TIME_SK       INTEGER                       ,
    WR_ITEM_SK                INTEGER               NOT NULL,
    WR_REFUNDED_CUSTOMER_SK   INTEGER                       ,
    WR_REFUNDED_CDEMO_SK      INTEGER                       ,
    WR_REFUNDED_HDEMO_SK      INTEGER                       ,
    WR_REFUNDED_ADDR_SK       INTEGER                       ,
    WR_RETURNING_CUSTOMER_SK  INTEGER                       ,
    WR_RETURNING_CDEMO_SK     INTEGER                       ,
    WR_RETURNING_HDEMO_SK     INTEGER                       ,
    WR_RETURNING_ADDR_SK      INTEGER                       ,
    WR_WEB_PAGE_SK            INTEGER                       ,
    WR_REASON_SK              INTEGER                       ,
    WR_ORDER_NUMBER           BIGINT                NOT NULL,
    WR_RETURN_QUANTITY        INTEGER                       ,
    WR_RETURN_AMT             DECIMAL(7,2)                  ,
    WR_RETURN_TAX             DECIMAL(7,2)                  ,
    WR_RETURN_AMT_INC_TAX     DECIMAL(7,2)                  ,
    WR_FEE                    DECIMAL(7,2)                  ,
    WR_RETURN_SHIP_COST       DECIMAL(7,2)                  ,
    WR_REFUNDED_CASH          DECIMAL(7,2)                  ,
    WR_REVERSED_CHARGE        DECIMAL(7,2)                  ,
    WR_ACCOUNT_CREDIT         DECIMAL(7,2)                  ,
    WR_NET_LOSS               DECIMAL(7,2)
)
WITH (ORIENTATION = COLUMN,COMPRESSION=MIDDLE)
PARTITION BY RANGE(WR_RETURNED_DATE_SK)
    (
            PARTITION P1 VALUES LESS THAN(2450815),
            PARTITION P2 VALUES LESS THAN(2451179),
            PARTITION P3 VALUES LESS THAN(2451544),
            PARTITION P4 VALUES LESS THAN(2451910),
            PARTITION P5 VALUES LESS THAN(2452275),
            PARTITION P6 VALUES LESS THAN(2452640),
            PARTITION P7 VALUES LESS THAN(2453005),
            PARTITION P8 VALUES LESS THAN(MAXVALUE)
    );
    
    --从示例数据表导入数据。
vastbase=# INSERT INTO web_returns_p1 SELECT * FROM web_returns;
    
    --删除分区P8。
vastbase=# ALTER TABLE web_returns_p1 DROP PARTITION P8;
    
    --增加分区WR_RETURNED_DATE_SK介于2453005和2453105之间。
vastbase=# ALTER TABLE web_returns_p1 ADD PARTITION P8 VALUES LESS THAN (2453105);
    
    --增加分区WR_RETURNED_DATE_SK介于2453105和MAXVALUE之间。
vastbase=# ALTER TABLE web_returns_p1 ADD PARTITION P9 VALUES LESS THAN (MAXVALUE);
    
    --删除分区P8。
vastbase=# ALTER TABLE web_returns_p1 DROP PARTITION FOR (2453005);
    
    --分区P7重命名为P10。
vastbase=# ALTER TABLE web_returns_p1 RENAME PARTITION P7 TO P10;
    
    --分区P6重命名为P11。
vastbase=# ALTER TABLE web_returns_p1 RENAME PARTITION FOR (2452639) TO P11;
    
    --查询分区P10的行数。
vastbase=# SELECT count(*) FROM web_returns_p1 PARTITION (P10);
 count  
--------
 0
(1 row)
    
    --查询分区P1的行数。
vastbase=# SELECT COUNT(*) FROM web_returns_p1 PARTITION FOR (2450815);
 count  
--------
 0
(1 row)

示例2： 创建范围分区表web_returns_p2，含有8个分区，分区键类型为integer类型，其中第8个分区上边界为MAXVALUE。

八个分区的范围分别为： wr_returned_date_sk< 2450815、2450815<= wr_returned_date_sk< 2451179、2451179<=wr_returned_date_sk< 2451544、2451544 <= wr_returned_date_sk< 2451910、2451910 <= wr_returned_date_sk< 2452275、2452275 <= wr_returned_date_sk< 2452640、2452640 <= wr_returned_date_sk< 2453005、wr_returned_date_sk>=2453005。

分区表web_returns_p2的表空间为example1；分区P1到P7没有声明表空间，使用采用分区表web_returns_p2的表空间example1；指定分区P8的表空间为example2。

假定数据库节点的数据目录/pg_location/mount1/path1，数据库节点的数据目录/pg_location/mount2/path2，数据库节点的数据目录/pg_location/mount3/path3，数据库节点的数据目录/pg_location/mount4/path4是dwsadmin用户拥有读写权限的空目录。

vastbase=# CREATE TABLESPACE example1 RELATIVE LOCATION 'tablespace1/tablespace_1';
vastbase=# CREATE TABLESPACE example2 RELATIVE LOCATION 'tablespace2/tablespace_2';
vastbase=# CREATE TABLESPACE example3 RELATIVE LOCATION 'tablespace3/tablespace_3';
vastbase=# CREATE TABLESPACE example4 RELATIVE LOCATION 'tablespace4/tablespace_4';
    
vastbase=# CREATE TABLE web_returns_p2
(
        WR_RETURNED_DATE_SK       INTEGER                       ,
        WR_RETURNED_TIME_SK       INTEGER                       ,
        WR_ITEM_SK                INTEGER               NOT NULL,
        WR_REFUNDED_CUSTOMER_SK   INTEGER                       ,
        WR_REFUNDED_CDEMO_SK      INTEGER                       ,
        WR_REFUNDED_HDEMO_SK      INTEGER                       ,
        WR_REFUNDED_ADDR_SK       INTEGER                       ,
        WR_RETURNING_CUSTOMER_SK  INTEGER                       ,
        WR_RETURNING_CDEMO_SK     INTEGER                       ,
        WR_RETURNING_HDEMO_SK     INTEGER                       ,
        WR_RETURNING_ADDR_SK      INTEGER                       ,
        WR_WEB_PAGE_SK            INTEGER                       ,
        WR_REASON_SK              INTEGER                       ,
        WR_ORDER_NUMBER           BIGINT                NOT NULL,
        WR_RETURN_QUANTITY        INTEGER                       ,
        WR_RETURN_AMT             DECIMAL(7,2)                  ,
        WR_RETURN_TAX             DECIMAL(7,2)                  ,
        WR_RETURN_AMT_INC_TAX     DECIMAL(7,2)                  ,
        WR_FEE                    DECIMAL(7,2)                  ,
        WR_RETURN_SHIP_COST       DECIMAL(7,2)                  ,
        WR_REFUNDED_CASH          DECIMAL(7,2)                  ,
        WR_REVERSED_CHARGE        DECIMAL(7,2)                  ,
        WR_ACCOUNT_CREDIT         DECIMAL(7,2)                  ,
        WR_NET_LOSS               DECIMAL(7,2)
    )
TABLESPACE example1
PARTITION BY RANGE(WR_RETURNED_DATE_SK)
    (
            PARTITION P1 VALUES LESS THAN(2450815),
            PARTITION P2 VALUES LESS THAN(2451179),
            PARTITION P3 VALUES LESS THAN(2451544),
            PARTITION P4 VALUES LESS THAN(2451910),
            PARTITION P5 VALUES LESS THAN(2452275),
            PARTITION P6 VALUES LESS THAN(2452640),
            PARTITION P7 VALUES LESS THAN(2453005),
            PARTITION P8 VALUES LESS THAN(MAXVALUE) TABLESPACE example2
    )
ENABLE ROW MOVEMENT;
    
    --以like方式创建一个分区表。
vastbase=# CREATE TABLE web_returns_p3 (LIKE web_returns_p2 INCLUDING PARTITION);
    
    --修改分区P1的表空间为example2。
vastbase=# ALTER TABLE web_returns_p2 MOVE PARTITION P1 TABLESPACE example2;
    
    --修改分区P2的表空间为example3。
vastbase=# ALTER TABLE web_returns_p2 MOVE PARTITION P2 TABLESPACE example3;
    
    --以2453010为分割点切分P8。
vastbase=# ALTER TABLE web_returns_p2 SPLIT PARTITION P8 AT (2453010) INTO
    (
            PARTITION P9,
            PARTITION P10
    ); 
    
    --将P6，P7合并为一个分区。
vastbase=# ALTER TABLE web_returns_p2 MERGE PARTITIONS P6, P7 INTO PARTITION P8;
    
    --修改分区表迁移属性。
vastbase=# ALTER TABLE web_returns_p2 DISABLE ROW MOVEMENT;
    --删除表和表空间。
vastbase=# DROP TABLE web_returns_p1;
vastbase=# DROP TABLE web_returns_p2;
vastbase=# DROP TABLE web_returns_p3;
vastbase=# DROP TABLESPACE example1;
vastbase=# DROP TABLESPACE example2;
vastbase=# DROP TABLESPACE example3;
vastbase=# DROP TABLESPACE example4;

示例3： START END语法创建、修改Range分区表。

假定/home/vastbase/startend_tbs1、/home/vastbase/startend_tbs2、/home/vastbase/startend_tbs3、/home/vastbase/startend_tbs4是vastbase用户拥有读写权限的空目录。

    -- 创建表空间
vastbase=# CREATE TABLESPACE startend_tbs1 LOCATION '/home/vastbase/startend_tbs1';
vastbase=# CREATE TABLESPACE startend_tbs2 LOCATION '/home/vastbase/startend_tbs2';
vastbase=# CREATE TABLESPACE startend_tbs3 LOCATION '/home/vastbase/startend_tbs3';
vastbase=# CREATE TABLESPACE startend_tbs4 LOCATION '/home/vastbase/startend_tbs4';
    
    -- 创建临时schema
vastbase=# CREATE SCHEMA tpcds;
vastbase=# SET CURRENT_SCHEMA TO tpcds;
    
    -- 创建分区表，分区键是integer类型
vastbase=# CREATE TABLE startend_pt (c1 INT, c2 INT) 
TABLESPACE startend_tbs1 
PARTITION BY RANGE (c2) (
        PARTITION p1 START(1) END(1000) EVERY(200) TABLESPACE startend_tbs2,
        PARTITION p2 END(2000),
        PARTITION p3 START(2000) END(2500) TABLESPACE startend_tbs3,
        PARTITION p4 START(2500),
        PARTITION p5 START(3000) END(5000) EVERY(1000) TABLESPACE startend_tbs4
    )
ENABLE ROW MOVEMENT;
    
    -- 查看分区表信息
vastbase=# SELECT relname, boundaries, spcname FROM pg_partition p JOIN pg_tablespace t ON p.reltablespace=t.oid and p.parentid='startend_pt'::regclass ORDER BY 1;
       relname   | boundaries |    spcname
    -------------+------------+---------------
     p1_0        | {1}        | startend_tbs2
     p1_1        | {201}      | startend_tbs2
     p1_2        | {401}      | startend_tbs2
     p1_3        | {601}      | startend_tbs2
     p1_4        | {801}      | startend_tbs2
     p1_5        | {1000}     | startend_tbs2
     p2          | {2000}     | startend_tbs1
     p3          | {2500}     | startend_tbs3
     p4          | {3000}     | startend_tbs1
     p5_1        | {4000}     | startend_tbs4
     p5_2        | {5000}     | startend_tbs4
     startend_pt |            | startend_tbs1
    (12 rows)
    
    -- 导入数据，查看分区数据量
vastbase=# INSERT INTO startend_pt VALUES (GENERATE_SERIES(0, 4999), GENERATE_SERIES(0, 4999));
vastbase=# SELECT COUNT(*) FROM startend_pt PARTITION FOR (0);
 count
-------
     1
(1 row)
    
vastbase=# SELECT COUNT(*) FROM startend_pt PARTITION (p3);
 count
-------
   500
(1 row)
    
    -- 增加分区: [5000, 5300), [5300, 5600), [5600, 5900), [5900, 6000)
vastbase=# ALTER TABLE startend_pt ADD PARTITION p6 START(5000) END(6000) EVERY(300) TABLESPACE startend_tbs4;
    
    -- 增加MAXVALUE分区: p7
vastbase=# ALTER TABLE startend_pt ADD PARTITION p7 END(MAXVALUE);
    
    -- 重命名分区p7为p8
vastbase=# ALTER TABLE startend_pt RENAME PARTITION p7 TO p8;
    
    -- 删除分区p8
vastbase=# ALTER TABLE startend_pt DROP PARTITION p8;
    
    -- 重命名5950所在的分区为：p71
vastbase=# ALTER TABLE startend_pt RENAME PARTITION FOR(5950) TO p71;
    
    -- 分裂4500所在的分区[4000, 5000)
vastbase=# ALTER TABLE startend_pt SPLIT PARTITION FOR(4500) INTO(PARTITION q1 START(4000) END(5000) EVERY(250) TABLESPACE startend_tbs3);
    
    -- 修改分区p2的表空间为startend_tbs4
vastbase=# ALTER TABLE startend_pt MOVE PARTITION p2 TABLESPACE startend_tbs4;
    
    -- 查看分区情形
vastbase=# SELECT relname, boundaries, spcname FROM pg_partition p JOIN pg_tablespace t ON p.reltablespace=t.oid and p.parentid='startend_pt'::regclass ORDER BY 1;
       relname   | boundaries |    spcname
    -------------+------------+---------------
     p1_0        | {1}        | startend_tbs2
     p1_1        | {201}      | startend_tbs2
     p1_2        | {401}      | startend_tbs2
     p1_3        | {601}      | startend_tbs2
     p1_4        | {801}      | startend_tbs2
     p1_5        | {1000}     | startend_tbs2
     p2          | {2000}     | startend_tbs4
     p3          | {2500}     | startend_tbs3
     p4          | {3000}     | startend_tbs1
     p5_1        | {4000}     | startend_tbs4
     p6_1        | {5300}     | startend_tbs4
     p6_2        | {5600}     | startend_tbs4
     p6_3        | {5900}     | startend_tbs4
     p71         | {6000}     | startend_tbs4
     q1_1        | {4250}     | startend_tbs3
     q1_2        | {4500}     | startend_tbs3
     q1_3        | {4750}     | startend_tbs3
     q1_4        | {5000}     | startend_tbs3
     startend_pt |            | startend_tbs1
    (19 rows)
    
    -- 删除表和表空间
vastbase=# DROP SCHEMA tpcds CASCADE;
vastbase=# DROP TABLESPACE startend_tbs1;
vastbase=# DROP TABLESPACE startend_tbs2;
vastbase=# DROP TABLESPACE startend_tbs3;
vastbase=# DROP TABLESPACE startend_tbs4;

示例4： 创建间隔分区表sales，初始包含2个分区，分区键为DATE类型。 分区的范围分别为：time_id < '2019-02-01 00:00:00'、'2019-02-01 00:00:00' <= time_id < '2019-02-02 00:00:00' 。

    --创建表sales
vastbase=# CREATE TABLE sales
    (prod_id NUMBER(6),
     cust_id NUMBER,
     time_id DATE,
     channel_id CHAR(1),
     promo_id NUMBER(6),
     quantity_sold NUMBER(3),
     amount_sold NUMBER(10,2)
    )
    PARTITION BY RANGE (time_id)
    INTERVAL('1 day')
    ( PARTITION p1 VALUES LESS THAN ('2019-02-01 00:00:00'),
      PARTITION p2 VALUES LESS THAN ('2019-02-02 00:00:00')
    );
    
    -- 数据插入分区p1
vastbase=# INSERT INTO sales VALUES(1, 12, '2019-01-10 00:00:00', 'a', 1, 1, 1);
    
    -- 数据插入分区p2
vastbase=# INSERT INTO sales VALUES(1, 12, '2019-02-01 00:00:00', 'a', 1, 1, 1);
    
    -- 查看分区信息
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'sales' AND t1.parttype = 'p';
 relname | partstrategy |       boundaries
---------+--------------+-------------------------
 p1      | r            | {"2019-02-01 00:00:00"}
 p2      | r            | {"2019-02-02 00:00:00"}
(2 rows)
    
    -- 插入数据没有匹配的分区，新创建一个分区，并将数据插入该分区
    -- 新分区的范围为 '2019-02-05 00:00:00' <= time_id < '2019-02-06 00:00:00'
vastbase=# INSERT INTO sales VALUES(1, 12, '2019-02-05 00:00:00', 'a', 1, 1, 1);
    
    -- 插入数据没有匹配的分区，新创建一个分区，并将数据插入该分区
    -- 新分区的范围为 '2019-02-03 00:00:00' <= time_id < '2019-02-04 00:00:00'
vastbase=# INSERT INTO sales VALUES(1, 12, '2019-02-03 00:00:00', 'a', 1, 1, 1);
    
    -- 查看分区信息
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'sales' AND t1.parttype = 'p';
 relname | partstrategy |       boundaries
---------+--------------+-------------------------
 sys_p1  | i            | {"2019-02-06 00:00:00"}
 sys_p2  | i            | {"2019-02-04 00:00:00"}
 p1      | r            | {"2019-02-01 00:00:00"}
 p2      | r            | {"2019-02-02 00:00:00"}
(4 rows)

示例5：创建LIST分区表test_list，初始包含4个分区，分区键为INT类型。4个分区的范围分别为：2000、3000、4000、5000。

    --创建表test_list
vastbase=# create table test_list (col1 int, col2 int)
    partition by list(col1)
    (
    partition p1 values (2000),
    partition p2 values (3000),
    partition p3 values (4000),
    partition p4 values (5000)
    );
    
    -- 数据插入
vastbase=# INSERT INTO test_list VALUES(2000, 2000);
INSERT 0 1
vastbase=# INSERT INTO test_list VALUES(3000, 3000);
INSERT 0 1
    
    -- 查看分区信息
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'test_list' AND t1.parttype = 'p';
 relname | partstrategy | boundaries
--------+--------------+------------
 p1      | l            | {2000}
 p2      | l            | {3000}
 p3      | l            | {4000}
 p4      | l            | {5000}
(4 rows)
    
    -- 插入数据没有匹配到分区，报错处理
vastbase=# INSERT INTO test_list VALUES(6000, 6000);
ERROR:  inserted partition key does not map to any table partition
    
    -- 添加分区
vastbase=# alter table test_list add partition p5 values (6000);
ALTER TABLE
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'test_list' AND t1.parttype = 'p';
 relname | partstrategy | boundaries
---------+--------------+------------
 p5      | l            | {6000}
 p4      | l            | {5000}
 p1      | l            | {2000}
 p2      | l            | {3000}
 p3      | l            | {4000}
(5 rows)
vastbase=# INSERT INTO test_list VALUES(6000, 6000);
INSERT 0 1
    
    -- 分区表和普通表交换数据
vastbase=# create table t1 (col1 int, col2 int);
CREATE TABLE
vastbase=# select * from test_list partition (p1);
 col1 | col2
------+------
 2000 | 2000
(1 row)
vastbase=# alter table test_list exchange partition (p1) with table t1;
ALTER TABLE
vastbase=# select * from test_list partition (p1);
 col1 | col2
------+------
(0 rows)
vastbase=# select * from t1;
 col1 | col2
------+------
 2000 | 2000
(1 row)
    
    -- truncate分区
vastbase=# select * from test_list partition (p2);
 col1 | col2
------+------
 3000 | 3000
(1 row)
vastbase=# alter table test_list truncate partition p2;
ALTER TABLE
vastbase=# select * from test_list partition (p2);
 col1 | col2
------+------
(0 rows)
    
    -- 删除分区
vastbase=# alter table test_list drop partition p5;
ALTER TABLE
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'test_list' AND t1.parttype = 'p';
 relname | partstrategy | boundaries
---------+--------------+------------
 p4      | l            | {5000}
 p1      | l            | {2000}
 p2      | l            | {3000}
 p3      | l            | {4000}
(4 rows)
    
vastbase=# INSERT INTO test_list VALUES(6000, 6000);
ERROR:  inserted partition key does not map to any table partition
    
   -- 删除分区表
vastbase=# drop table test_list;

示例6： 创建HASH分区表test_hash，初始包含2个分区，分区键为INT类型。

    --创建表test_hash
vastbase=# create table test_hash (col1 int, col2 int)
    partition by hash(col1)
    (
    partition p1,
    partition p2
    );
    
    -- 数据插入
vastbase=# INSERT INTO test_hash VALUES(1, 1);
INSERT 0 1
vastbase=# INSERT INTO test_hash VALUES(2, 2);
INSERT 0 1
vastbase=# INSERT INTO test_hash VALUES(3, 3);
INSERT 0 1
vastbase=# INSERT INTO test_hash VALUES(4, 4);
INSERT 0 1
    
    -- 查看分区信息
vastbase=# SELECT t1.relname, partstrategy, boundaries FROM pg_partition t1, pg_class t2 WHERE t1.parentid = t2.oid AND t2.relname = 'test_hash' AND t1.parttype = 'p';
 relname | partstrategy | boundaries
---------+--------------+------------
 p1      | h            | {0}
 p2      | h            | {1}
(2 rows)
    
    -- 查看数据
vastbase=# select * from test_hash partition (p1);
 col1 | col2
------+------
    3 |    3
    4 |    4
(2 rows)
    
vastbase=# select * from test_hash partition (p2);
 col1 | col2
------+------
    1 |    1
    2 |    2
(2 rows)
    
    -- 分区表和普通表交换数据
vastbase=# create table t1 (col1 int, col2 int);
CREATE TABLE
vastbase=# alter table test_hash exchange partition (p1) with table t1;
ALTER TABLE
vastbase=# select * from test_hash partition (p1);
 col1 | col2
------+------
(0 rows)
vastbase=# select * from t1;
 col1 | col2
------+------
    3 |    3
    4 |    4
(2 rows)
    
    -- truncate分区
vastbase=# alter table test_hash truncate partition p2;
ALTER TABLE
vastbase=#  select * from test_hash partition (p2);
 col1 | col2
------+------
(0 rows)
    
    -- 删除分区表
vastbase=# drop table test_hash;

相关链接

ALTER TABLE PARTITION，DROP TABLE