Aurora PostgreSQL Limitless Database 的 DDL 限制和其他信息

有关不支持的内容的详细信息，请参阅约束。

支持默认值。有关更多信息，请参阅 默认值。

当您使用 \d table_name 或类似命令时，并非所有索引在路由器上都可见。相反，可以使用 pg_catalog.pg_indexes 视图获取索引，如以下示例中所示。

SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"id"}';
CREATE TABLE items (id int PRIMARY KEY, val int);
CREATE INDEX items_my_index on items (id, val);

postgres_limitless=> SELECT * FROM pg_catalog.pg_indexes WHERE tablename='items';

 schemaname | tablename |   indexname    | tablespace |                                indexdef
------------+-----------+----------------+------------+------------------------------------------------------------------------
 public     | items     | items_my_index |            | CREATE INDEX items_my_index ON ONLY public.items USING btree (id, val)
 public     | items     | items_pkey     |            | CREATE UNIQUE INDEX items_pkey ON ONLY public.items USING btree (id)
(2 rows)

支持涉及文字比较运算符的简单约束。不支持需要函数验证的更复杂表达式和约束，如以下示例所示。

CREATE TABLE my_table (
    id  INT CHECK (id > 0)                                     -- supported
  , val INT CHECK (val > 0 AND val < 1000)                     -- supported
  , tag TEXT CHECK (length(tag) > 0)                           -- not supported: throws "Expression inside CHECK constraint is not supported"
  , op_date TIMESTAMP WITH TIME ZONE CHECK (op_date <= now())  -- not supported: throws "Expression inside CHECK constraint is not supported"
);

您还可以为约束提供显式名称，如以下示例所示。

CREATE TABLE my_table (
    id  INT CONSTRAINT positive_id  CHECK (id > 0)
  , val INT CONSTRAINT val_in_range CHECK (val > 0 AND val < 1000)
);

您还可以将表级约束语法与 CHECK 约束一起使用，如以下示例所示。

CREATE TABLE my_table (
    id INT CONSTRAINT positive_id  CHECK (id > 0)
  , min_val INT CONSTRAINT min_val_in_range CHECK (min_val > 0 AND min_val < 1000)
  , max_val INT
  , CONSTRAINT max_val_in_range CHECK (max_val > 0 AND max_val < 1000 AND max_val > min_val)
);

Aurora PostgreSQL Limitless Database 不支持排除约束。

有关更多信息，请参阅 外键。

支持 NOT NULL 约束，无任何限制。

主键意味着唯一约束，因此对唯一约束的相同限制也适用于主键。这意味着：

以下示例演示了如何使用主键。

-- Create a standard table.
CREATE TABLE public.my_table (
    item_id INT
  , location_code INT
  , val INT
  , comment text
);

-- Change the table to a sharded table using the 'item_id' and 'location_code' columns as shard keys.
CALL rds_aurora.limitless_alter_table_type_sharded('public.my_table', ARRAY['item_id', 'location_code']);

正在尝试添加不包含分片键的主键：

-- Add column 'item_id' as the primary key.
-- Invalid because the primary key doesnt include all columns from the shard key:
-- 'location_code' is part of the shard key but not part of the primary key
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id); -- ERROR

-- add column "val" as primary key
-- Invalid because primary key does not include all columns from shard key:
--  item_id and location_code iare part of shard key but not part of the primary key
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id); -- ERROR

正在尝试添加包含分片键的主键：

-- Add the 'item_id' and 'location_code' columns as the primary key.
-- Valid because the primary key contains the shard key.
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id, location_code); -- OK

-- Add the 'item_id', 'location_code', and 'val' columns as the primary key.
-- Valid because the primary key contains the shard key.
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id, location_code, val); -- OK

将标准表更改为引用表。

-- Create a standard table.
CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR);

-- Convert the table to a reference table.
CALL rds_aurora.limitless_alter_table_type_reference('public.zipcode');

有关创建分片表和引用表的更多信息，请参阅创建 Aurora PostgreSQL Limitless Database 表。

在分片表中，唯一键必须包含分片键，也就是说，分片键必须是唯一键的子集。将表类型更改为分片表时会检查此项。在引用表中没有任何限制。

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT UNIQUE
);

支持表级 UNIQUE 约束，如以下示例所示。

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT
  , CONSTRAINT zipcode_and_email UNIQUE (zipcode, email)
);

以下示例显示了如何同时使用主键和唯一键。两个键都必须包含分片键。

SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"p_id"}';
CREATE TABLE t1 (
p_id BIGINT NOT NULL,
c_id BIGINT NOT NULL,
PRIMARY KEY (p_id),
UNIQUE (p_id, c_id)
);

您可以像在 PostgreSQL 中那样创建扩展。

CREATE EXTENSION [ IF NOT EXISTS ] extension_name
    [ WITH ] [ SCHEMA schema_name ]
             [ VERSION version ]
             [ CASCADE ]

有关更多信息，请参阅 PostgreSQL 文档中的 CREATE EXTENSION。

支持以下 DDL：

ALTER EXTENSION name UPDATE [ TO new_version ]

ALTER EXTENSION name SET SCHEMA new_schema

有关更多信息，请参阅 PostgreSQL 文档中的 ALTER EXTENSION。

您可以像在 PostgreSQL 中那样删除扩展。

DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

有关更多信息，请参阅 PostgreSQL 文档中的 DROP EXTENSION。

您无法添加或删除扩展中的成员对象。

ALTER EXTENSION name ADD member_object

ALTER EXTENSION name DROP member_object

rds_aurora.limitless_pgstattuple(relation_name)

rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)

rds_aurora.limitless_pgstatindex(relation_name)

rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstatginindex(relation_name)

rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstathashindex(relation_name)

rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)

rds_aurora.limitless_pg_relpages(relation_name)

rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)

rds_aurora.limitless_pgstattuple_approx(relation_name)

rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)

您可以像在 Aurora PostgreSQL 中那样创建函数，但无法在替换函数时改变其波动性。

有关更多信息，请参阅 PostgreSQL 文档中的 CREATE FUNCTION。

您可以像在 Aurora PostgreSQL 中那样更改函数，但无法改变其波动性。

有关更多信息，请参阅 PostgreSQL 文档中的 ALTER FUNCTION。

您可以像在 Aurora PostgreSQL 中那样删除函数。

DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
    [ CASCADE | RESTRICT ]

有关更多信息，请参阅 PostgreSQL 文档中的 DROP FUNCTION。

当您分发函数或流程时，它只处理受该分片中分片键范围限制的数据。如果函数或流程尝试访问来自其他分片的数据，则分布式函数或流程返回的结果与非分布式函数或流程返回的结果会有所不同。

例如，您创建了一个包含查询的函数，这些查询将触及多个分片，随后调用 rds_aurora.limitless_distribute_function 流程进行分发。当您通过为分片键提供参数来调用此函数时，运行该函数的结果很可能会受该分片中存在的值的限制。这些结果不同于在不分配函数的情况下生成的结果。

请查看以下函数 func，其有一个带有分片键 customer_id 的分片表 customers。

postgres_limitless=> CREATE OR REPLACE FUNCTION func(c_id integer, sc integer) RETURNS int
    language SQL
    volatile
    AS $$
    UPDATE customers SET score = sc WHERE customer_id = c_id RETURNING score;
    $$;

现在我们分发这个函数：

SELECT rds_aurora.limitless_distribute_function('func(integer, integer)', ARRAY['c_id'], 'customers');

以下是查询计划示例。

EXPLAIN(costs false, verbose true) SELECT func(27+1,10);

                    QUERY PLAN
 --------------------------------------------------
  Foreign Scan
    Output: (func((27 + 1), 10))
    Remote SQL:  SELECT func((27 + 1), 10) AS func
  Single Shard Optimized
 (4 rows)

EXPLAIN(costs false, verbose true)
 SELECT * FROM customers,func(customer_id, score) WHERE customer_id=10 AND score=27;

                          QUERY PLAN
 ---------------------------------------------------------------------
  Foreign Scan
    Output: customer_id, name, score, func
    Remote SQL:  SELECT customers.customer_id,
      customers.name,
      customers.score,
      func.func
     FROM public.customers,
      LATERAL func(customers.customer_id, customers.score) func(func)
    WHERE ((customers.customer_id = 10) AND (customers.score = 27))
  Single Shard Optimized
 (10 rows)

以下示例演示一个以 IN 和 OUT 参数作为参数的存储过程。

CREATE OR REPLACE FUNCTION get_data(OUT id INTEGER, IN arg_id INT)
    AS $$
    BEGIN
        SELECT customer_id,
        INTO id
        FROM customer
        WHERE customer_id = arg_id;
    END;
    $$ LANGUAGE plpgsql;

以下示例仅使用 IN 参数来分发该流程。

EXPLAIN(costs false, verbose true) SELECT * FROM get_data(1);

             QUERY PLAN
 -----------------------------------
  Foreign Scan
    Output: id
    Remote SQL:  SELECT customer_id
     FROM get_data(1) get_data(id)
  Single Shard Optimized
 (6 rows)

不支持 setval 函数。有关更多信息，请参阅 PostgreSQL 文档中的 Sequence Manipulation Functions。

不支持以下选项。

CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
    [[ NO ] CYCLE]

有关更多信息，请参阅 PostgreSQL 文档中的 CREATE SEQUENCE。

不支持以下选项。

ALTER SEQUENCE
    [[ NO ] CYCLE]

有关更多信息，请参阅 PostgreSQL 文档中的 ALTER SEQUENCE。

序列不支持 ALTER TABLE 命令。

postgres_limitless=> CREATE SEQUENCE s;
CREATE SEQUENCE

postgres_limitless=> SELECT nextval('s');

 nextval
---------
       1
(1 row)

postgres_limitless=> SELECT * FROM pg_sequence WHERE seqrelid='s'::regclass;

 seqrelid | seqtypid | seqstart | seqincrement | seqmax | seqmin | seqcache | seqcycle 
----------+----------+----------+--------------+--------+--------+----------+----------
    16960 |       20 |        1 |            1 |  10000 |      1 |        1 | f
(1 row)

% connect to another router
postgres_limitless=> SELECT nextval('s');

 nextval 
---------
   10001
(1 row)

postgres_limitless=> SELECT * FROM pg_sequence WHERE seqrelid='s'::regclass;

 seqrelid | seqtypid | seqstart | seqincrement | seqmax | seqmin | seqcache | seqcycle 
----------+----------+----------+--------------+--------+--------+----------+----------
    16959 |       20 |    10001 |            1 |  20000 |  10001 |        1 | f
(1 row)

postgres_limitless=> DROP SEQUENCE s;
DROP SEQUENCE

postgres_limitless=> CREATE SEQUENCE s;
CREATE SEQUENCE

postgres_limitless=> ALTER SEQUENCE s RESTART 500;
ALTER SEQUENCE

postgres_limitless=> SELECT nextval('s');

 nextval
---------
     500
(1 row)

postgres_limitless=> SELECT currval('s');

 currval
---------
     500
(1 row)

postgres=# CREATE TABLE t(a bigint primary key, b bigint);
CREATE TABLE

postgres=# CREATE SEQUENCE s minvalue 0 START 0;
CREATE SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));
INSERT 0 1

postgres=# SELECT * FROM t;

 a | b
---+---
 0 | 0
 1 | 1
(2 rows)

postgres=# ALTER SEQUENCE s RESTART 10000;
ALTER SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# SELECT * FROM t;

   a   |   b
-------+-------
     0 |     0
     1 |     1
 10000 | 10000
(3 rows)

此视图显示分布式序列状态和配置。minvalue、maxvalue、start、inc 和 cache 列的含义与 pg_sequences 视图中的含义相同，它们显示了创建序列时使用的选项。lastval 列显示分布式序列对象中最新的分配值或保留值。这并不意味着该值已被使用，因为路由器会在本地保留序列区块。

postgres_limitless=> SELECT * FROM rds_aurora.limitless_distributed_sequence WHERE sequence_name='test_serial_b_seq';

 schema_name |   sequence_name   | lastval | minvalue |  maxvalue  | start | inc | cache
-------------+-------------------+---------+----------+------------+-------+-----+-------
 public      | test_serial_b_seq | 1250000 |        1 | 2147483647 |     1 |   1 |     1
(1 row)

此视图显示分布式序列元数据并聚合来自集群节点的序列元数据。它使用以下列：

postgres_limitless=> SELECT * FROM rds_aurora.limitless_sequence_metadata WHERE sequence_name='test_serial_b_seq' order by subcluster_id;

 subcluster_id |   sequence_name   | schema_name | active_minvalue | active_maxvalue | reserved_minvalue | reserved_maxvalue | chunk_size | chunk_state | local_last_value 
---------------+-------------------+-------------+-----------------+-----------------+-------------------+-------------------+------------+-------------+------------------
 1             | test_serial_b_seq | public      |          500001 |          750000 |           1000001 |           1250000 |     250000 |           1 |           550010
 2             | test_serial_b_seq | public      |          250001 |          500000 |            750001 |           1000000 |     250000 |           1 |                 
(2 rows)

如果区块大小设置得不够大，并且事务速率很高，则在活动区块用完之前，后台工作人员可能没有足够的时间请求新的区块。这可能会导致争用和等待事件，例如 LIMITLESS:AuroraLimitlessSequenceReplace、LWLock:LockManager、Lockrelation 和 LWlock:bufferscontent。

增大 rds_aurora.limitless_sequence_chunk_size 参数的值。

在 PostgreSQL 中，序列缓存发生在会话级别。在一次访问序列对象期间，每个会话都会分配连续的序列值，并相应地增加序列对象的 last_value 值。然后，在该会话中下次使用 nextval 时，只需返回预先分配的值，而无需涉及序列对象。

会话结束时，任何分配但未在会话中使用的数字都将丢失，从而导致序列中出现“空洞”。这可能会快速消耗 sequence_chunk，并导致争用和等待事件，例如 LIMITLESS:AuroraLimitlessSequenceReplace、LWLock:LockManager、Lockrelation 和 LWlock:bufferscontent。

减少序列缓存设置。