Aurora PostgreSQL 無限資料庫的 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 無限制資料庫中不支援排除限制。

如需詳細資訊，請參閱外部索引鍵。

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 無限資料庫資料表。

在碎片資料表中，唯一金鑰必須包含碎片金鑰，也就是說，碎片金鑰必須是唯一金鑰的子集。將資料表類型變更為碎片時，會檢查此項目。在參考表中沒有限制。

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。

支援下列 DDLs：

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，其中我們具有customers具有碎片索引鍵 的碎片資料表customer_id。

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、Lockrelation、 LWLock:LockManager 和 LWlock:bufferscontent。

增加 rds_aurora.limitless_sequence_chunk_size 參數的值。

在 PostgreSQL 中，序列快取發生在工作階段層級。每個工作階段會在一次存取序列物件期間配置連續的序列值，並last_value相應地增加序列物件的 。然後，該工作階段nextval中的下一個 使用只會傳回預先配置的值，而不會接觸序列物件。

當工作階段結束時，任何配置但未在工作階段中使用的數字都會遺失，導致序列中出現「孔洞」。這可以快速使用 sequence_chunk，並導致爭用和等待事件，例如 LIMITLESS:AuroraLimitlessSequenceReplace、Lockrelation、 LWLock:LockManager 和 LWlock:bufferscontent。

減少序列快取設定。