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 のドキュメントの「機能の作成」を参照してください。

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 プロシージャを呼び出して分散させる場合です。シャードキーの引数を指定してこの関数を呼び出すと、実行の結果がそのシャードに存在する値によって制限される可能性があります。これらの結果は、関数を分散させずに生成された結果とは異なります。

シャードキー customer_id を持つシャードテーブル customers がある場合の次の関数 func について考えてみます。

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 では、シーケンスキャッシュはセッションレベルで行われます。各セッションは、シーケンスオブジェクトへの 1 回のアクセス中に連続するシーケンス値を割り当て、それに応じてシーケンスオブジェクトの last_value を増やします。その後、そのセッション内で次回 nextval を使用する際に、シーケンスオブジェクトにアクセスせずに、単純に事前に割り当てられた値を返します。

セッション内で割り当てられたが使用されなかった番号は、セッションが終了すると失われ、シーケンスに「ホール」が発生します。これにより、sequence_chunk がすばやく消費され、LIMITLESS:AuroraLimitlessSequenceReplace、LWLock:LockManager、Lockrelation、LWlock:bufferscontent などの競合イベントや待機イベントが発生する可能性があります。

シーケンスキャッシュ設定を減らします。