Aurora PostgreSQL Limitless Database 的 DDL 限制和其他資訊

如需不支援之項目的詳細資訊，請參閱Constraints。

支援預設值。如需詳細資訊，請參閱預設值。

當您使用 \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 文件中的序列操作函數。

不支援下列選項。

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。

減少序列快取設定。