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 프로시저를 직접 호출하여 배포합니다. 샤드 키에 대한 인수를 제공하여 이 함수를 간접 호출하면 해당 함수를 실행한 결과가 해당 샤드에 있는 값에 의해 경계가 지정될 수 있습니다. 이러한 결과는 함수를 배포하지 않고 생성된 결과와 다릅니다.

다음과 같이 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에서는 세션 수준에서 시퀀스 캐싱이 수행됩니다. 각 세션은 시퀀스 객체에 대한 한 번의 액세스 중에 연속 시퀀스 값을 할당하고 그에 따라 시퀀스 객체의 last_value를 늘립니다. 그런 다음 해당 세션 내에서 다음번에 nextval을 사용하면 시퀀스 객체를 터치하지 않고 미리 할당된 값을 반환하기만 합니다.

세션 내에서 할당되었지만 사용되지 않은 모든 숫자는 세션이 종료될 때 손실되어 시퀀스에서 '구멍'이 됩니다. 이로 인해 sequence_chunk가 빠르게 소비되어 경합이 발생하고 LIMITLESS:AuroraLimitlessSequenceReplace, LWLock:LockManager, Lockrelation, LWlock:bufferscontent 등의 대기 이벤트가 발생할 수 있습니다.

시퀀스 캐시 설정을 줄이세요.