# Aurora PostgreSQL Limitless Database 참조
Aurora PostgreSQL Limitless Database에 대해 다음 참조 주제를 제공합니다.
**Topics**
+ [지원되는/지원되지 않는 데이터 정의 언어(DDL) SQL 명령](limitless-reference.DDL-support.md)
+ [Aurora PostgreSQL Limitless Database에 대한 DDL 제한 사항 및 기타 정보](limitless-reference.DDL-limitations.md)
+ [지원되는/지원되지 않는 데이터 조작 언어(DML) 및 쿼리 처리 SQL 명령](limitless-reference.DML-support.md)
+ [Aurora PostgreSQL Limitless Database에 대한 DML 제한 사항 및 기타 정보](limitless-reference.DML-limitations.md)
+ [Aurora PostgreSQL Limitless Database의 변수](limitless-reference.variables.md)
+ [Aurora PostgreSQL Limitless Database의 DB 클러스터 파라미터](limitless-reference.DBCparams.md)
# 지원되는/지원되지 않는 데이터 정의 언어(DDL) SQL 명령
다음 표에는 Aurora PostgreSQL Limitless Database에서 지원되는/지원되지 않는 DDL 명령과 제한 사항 또는 자세한 정보에 대한 참조가 나와 있습니다.
| Command | 지원? | 제한 사항 또는 추가 정보 |
| --- | --- | --- |
| ALTER AGGREGATE | No | 해당 사항 없음 |
| ALTER COLLATION | 예 | 없음 |
| ALTER CONVERSION | 예 | 없음 |
| ALTER DATABASE | No | 해당 사항 없음 |
| ALTER DEFAULT PRIVILEGES | No | 해당 사항 없음 |
| ALTER DOMAIN | No | 해당 사항 없음 |
| ALTER EVENT TRIGGER | No | 해당 사항 없음 |
| ALTER EXTENSION | 예 | [확장 프로그램](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| ALTER FOREIGN DATA WRAPPER | No | 해당 사항 없음 |
| ALTER FOREIGN TABLE | No | 해당 사항 없음 |
| ALTER FUNCTION | 예 | [함수](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| ALTER GROUP | 예 | 없음 |
| ALTER INDEX | 예 | 없음 |
| ALTER LANGUAGE | No | 해당 사항 없음 |
| ALTER LARGE OBJECT | No | 해당 사항 없음 |
| ALTER MATERIALIZED VIEW | No | 해당 사항 없음 |
| ALTER OPERATOR | 예 | 없음 |
| ALTER OPERATOR CLASS | 예 | 없음 |
| ALTER OPERATOR FAMILY | 예 | 없음 |
| ALTER POLICY | No | 해당 사항 없음 |
| ALTER PROCEDURE | 예 | 없음 |
| ALTER PUBLICATION | No | 해당 사항 없음 |
| 역할 변경 | 예 | 없음 |
| ALTER ROUTINE | No | 해당 사항 없음 |
| ALTER RULE | No | 해당 사항 없음 |
| ALTER SCHEMA | 예 | 없음 |
| ALTER SEQUENCE | 예 | [시퀀스](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| ALTER SERVER | No | 해당 사항 없음 |
| ALTER STATISTICS | No | 해당 사항 없음 |
| ALTER SUBSCRIPTION | No | 해당 사항 없음 |
| ALTER SYSTEM | No | 해당 사항 없음 |
| ALTER TABLE | 예 | [ALTER TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.ALTER_TABLE) |
| ALTER TABLESPACE | No | 해당 사항 없음 |
| ALTER TEXT SEARCH CONFIGURATION | No | 해당 사항 없음 |
| ALTER TEXT SEARCH DICTIONARY | No | 해당 사항 없음 |
| ALTER TEXT SEARCH PARSER | No | 해당 사항 없음 |
| ALTER TEXT SEARCH TEMPLATE | No | 해당 사항 없음 |
| ALTER TRIGGER | No | 해당 사항 없음 |
| ALTER TYPE | 예 | 없음 |
| ALTER USER | 예 | 없음 |
| ALTER USER MAPPING | No | 해당 사항 없음 |
| ALTER VIEW | 예 | 없음 |
| COMMENT | No | 해당 사항 없음 |
| CREATE ACCESS METHOD | No | 해당 사항 없음 |
| CREATE AGGREGATE | No | 해당 사항 없음 |
| CREATE CAST | 예 | 없음 |
| CREATE COLLATION | 예 | 없음 |
| CREATE CONVERSION | 예 | 없음 |
| 데이터베이스 생성 | 예 | [데이터베이스 생성](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_DATABASE) |
| CREATE DOMAIN | No | 해당 사항 없음 |
| CREATE EVENT TRIGGER | No | 해당 사항 없음 |
| CREATE EXTENSION | 예 | [확장 프로그램](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| CREATE FOREIGN DATA WRAPPER | No | 해당 사항 없음 |
| CREATE FOREIGN TABLE | No | 해당 사항 없음 |
| CREATE FUNCTION | 예 | [함수](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| create group | 예 | 없음 |
| CREATE INDEX | 예 | [CREATE INDEX](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_INDEX) |
| CREATE LANGUAGE | No | 해당 사항 없음 |
| CREATE MATERIALIZED VIEW | No | 해당 사항 없음 |
| CREATE OPERATOR | 예 | 없음 |
| CREATE OPERATOR CLASS | 예 | 없음 |
| CREATE OPERATOR FAMILY | 예 | 없음 |
| CREATE POLICY | 예 | 없음 |
| CREATE PROCEDURE | 예 | 없음 |
| CREATE PUBLICATION | No | 해당 사항 없음 |
| 역할 생성 | 예 | 없음 |
| CREATE RULE | No | 해당 사항 없음 |
| CREATE SCHEMA | 예 | [CREATE SCHEMA](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_SCHEMA) |
| CREATE ANY SEQUENCE | 예 | [시퀀스](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| CREATE SERVER | No | 해당 사항 없음 |
| CREATE STATISTICS | No | 해당 사항 없음 |
| CREATE SUBSCRIPTION | No | 해당 사항 없음 |
| CREATE TABLE | 예 | [CREATE TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE) |
| CREATE TABLE AS | 예 | [CREATE TABLE AS](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE_AS) |
| CREATE TABLESPACE | No | 해당 사항 없음 |
| CREATE TEMPORARY TABLE | No | 해당 사항 없음 |
| CREATE TEMPORARY TABLE AS | No | 해당 사항 없음 |
| CREATE TEXT SEARCH CONFIGURATION | No | 해당 사항 없음 |
| CREATE TEXT SEARCH DICTIONARY | No | 해당 사항 없음 |
| CREATE TEXT SEARCH PARSER | No | 해당 사항 없음 |
| CREATE TEXT SEARCH TEMPLATE | No | 해당 사항 없음 |
| CREATE TRANSFORM | No | 해당 사항 없음 |
| CREATE TRIGGER | No | 해당 사항 없음 |
| CREATE TYPE | 예 | 없음 |
| 사용자 생성 | 예 | 없음 |
| CREATE USER MAPPING | No | 해당 사항 없음 |
| CREATE VIEW | 예 | 없음 |
| DROP ACCESS METHOD | No | 해당 사항 없음 |
| DROP AGGREGATE | 예 | 없음 |
| DROP CAST | 예 | 없음 |
| DROP COLLATION | 예 | 없음 |
| DROP CONVERSION | 예 | 없음 |
| DROP DATABASE | 예 | [DROP DATABASE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.DROP_DATABASE) |
| DROP DOMAIN | No | 해당 사항 없음 |
| DROP EVENT TRIGGER | No | 해당 사항 없음 |
| DROP EXTENSION | 예 | [확장 프로그램](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| DROP FOREIGN DATA WRAPPER | No | 해당 사항 없음 |
| DROP FOREIGN TABLE | No | 해당 사항 없음 |
| DROP FUNCTION | 예 | [함수](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| DROP GROUP | 예 | 없음 |
| DROP INDEX | 예 | 없음 |
| DROP LANGUAGE | No | 해당 사항 없음 |
| DROP MATERIALIZED VIEW | No | 해당 사항 없음 |
| DROP OPERATOR | 예 | 없음 |
| DROP OPERATOR CLASS | 예 | 없음 |
| DROP OPERATOR FAMILY | 예 | 없음 |
| DROP OWNED | No | 해당 사항 없음 |
| DROP POLICY | No | 해당 사항 없음 |
| DROP PROCEDURE | 예 | 없음 |
| DROP PUBLICATION | No | 해당 사항 없음 |
| DROP ROLE | 예 | 없음 |
| DROP ROUTINE | No | 해당 사항 없음 |
| DROP RULE | No | 해당 사항 없음 |
| DROP SCHEMA | 예 | 없음 |
| DROP SEQUENCE | 예 | 없음 |
| DROP SERVER | No | 해당 사항 없음 |
| DROP STATISTICS | No | 해당 사항 없음 |
| DROP SUBSCRIPTION | No | 없음 |
| DROP TABLE | 예 | 없음 |
| DROP TABLESPACE | No | 해당 사항 없음 |
| DROP TEXT SEARCH CONFIGURATION | No | 해당 사항 없음 |
| DROP TEXT SEARCH DICTIONARY | No | 해당 사항 없음 |
| DROP TEXT SEARCH PARSER | No | 해당 사항 없음 |
| DROP TEXT SEARCH TEMPLATE | No | 해당 사항 없음 |
| DROP TRANSFORM | No | 해당 사항 없음 |
| DROP TRIGGER | No | 해당 사항 없음 |
| DROP TYPE | 예 | 없음 |
| DROP USER | 예 | 없음 |
| DROP USER MAPPING | No | 해당 사항 없음 |
| DROP VIEW | 예 | 없음 |
| GRANT | 예 | 없음 |
| REASSIGN OWNED | No | 해당 사항 없음 |
| REVOKE | 예 | 없음 |
| SECURITY LABEL | No | 해당 사항 없음 |
| SELECT INTO | 예 | [SELECT INTO](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.SELECT_INTO) |
| SET | 예 | 없음 |
| SET CONSTRAINTS | No | 해당 사항 없음 |
| SET ROLE | 예 | 없음 |
| SET SESSION AUTHORIZATION | 예 | 없음 |
| SET TRANSACTION | 예 | 없음 |
| TRUNCATE | 예 | 없음 |
# Aurora PostgreSQL Limitless Database에 대한 DDL 제한 사항 및 기타 정보
다음 주제에서는 Aurora PostgreSQL Limitless Database의 DDL SQL 명령에 대한 제한 사항을 설명하거나 자세한 정보를 제공합니다.
**Topics**
+ [ALTER TABLE](#limitless-reference.DDL-limitations.ALTER_TABLE)
+ [데이터베이스 생성](#limitless-reference.DDL-limitations.CREATE_DATABASE)
+ [CREATE INDEX](#limitless-reference.DDL-limitations.CREATE_INDEX)
+ [CREATE SCHEMA](#limitless-reference.DDL-limitations.CREATE_SCHEMA)
+ [CREATE TABLE](#limitless-reference.DDL-limitations.CREATE_TABLE)
+ [CREATE TABLE AS](#limitless-reference.DDL-limitations.CREATE_TABLE_AS)
+ [DROP DATABASE](#limitless-reference.DDL-limitations.DROP_DATABASE)
+ [SELECT INTO](#limitless-reference.DDL-limitations.SELECT_INTO)
+ [제약 조건](#limitless-reference.DDL-limitations.Constraints)
+ [기본값](#limitless-reference.DDL-limitations.DefaultValues)
+ [확장 프로그램](#limitless-reference.DDL-limitations.Extensions)
+ [외래 키](#limitless-reference.DDL-limitations.FKs)
+ [함수](#limitless-reference.DDL-limitations.Functions)
+ [시퀀스](#limitless-reference.DDL-limitations.Sequences)
## ALTER TABLE
`ALTER TABLE` 명령은 일반적으로 Aurora PostgreSQL Limitless Database에서 지원됩니다. 자세한 내용은 PostgreSQL 설명서의 [ALTER TABLE](https://www.postgresql.org/docs/current/sql-altertable.html)을 참조하세요.
### 제한 사항
`ALTER TABLE`에는 지원되는 옵션에 대한 다음과 같은 제한 사항이 있습니다.
**열 제거**
+ 샤딩된 테이블에서는 샤드 키의 일부인 열을 제거할 수 없습니다.
+ 참조 테이블에서는 프라이머리 키 열을 제거할 수 없습니다.
**열의 데이터 형식 변경**
+ `USING` 표현식은 지원되지 않습니다.
+ 샤딩된 테이블에서는 샤드 키의 일부인 열의 유형을 변경할 수 없습니다.
**제약 추가 또는 제거**
지원되지 않는 사항에 대한 자세한 내용은 [제약 조건](#limitless-reference.DDL-limitations.Constraints) 섹션을 참조하세요.
**열의 기본값 변경**
기본값이 지원됩니다. 자세한 내용은 [기본값](#limitless-reference.DDL-limitations.DefaultValues) 섹션을 참조하세요.
### 지원되지 않는 옵션
일부 옵션은 트리거와 같은 지원되지 않는 기능에 의존하므로 지원되지 않습니다.
`ALTER TABLE`에 대한 다음 테이블 수준 옵션은 지원되지 않습니다.
+ `ALL IN TABLESPACE`
+ `ATTACH PARTITION`
+ `DETACH PARTITION`
+ `ONLY` 플래그
+ `RENAME CONSTRAINT`
`ALTER TABLE`에 대한 다음 열 수준 옵션은 지원되지 않습니다.
+ ADD GENERATED
+ DROP EXPRESSION [ IF EXISTS ]
+ DROP IDENTITY [ IF EXISTS ]
+ reset
+ RESTART
+ SET
+ SET COMPRESSION
+ SET STATISTICS
## 데이터베이스 생성
Aurora PostgreSQL Limitless Database에서는 무한 데이터베이스만 지원됩니다.
`CREATE DATABASE`가 실행되는 동안 데이터베이스 만들기는 비트랜잭션 작업이므로 하나 이상의 노드에서 성공적으로 만들어진 데이터베이스가 다른 노드에서 실패할 수 있습니다. 이 경우 DB 샤드 그룹 내의 일관성을 유지하기 위해 성공적으로 만들어진 데이터베이스 객체는 미리 정해진 시간 내에 모든 노드에서 자동으로 제거됩니다. 이 시간 동안 이름이 같은 데이터베이스를 다시 만들려면 데이터베이스가 이미 있음을 나타내는 오류가 발생할 수 있습니다.
지원되는 옵션은 다음과 같습니다.
+ 데이터 정리:
```
CREATE DATABASE name WITH
[LOCALE = locale]
[LC_COLLATE = lc_collate]
[LC_CTYPE = lc_ctype]
[ICU_LOCALE = icu_locale]
[ICU_RULES = icu_rules]
[LOCALE_PROVIDER = locale_provider]
[COLLATION_VERSION = collation_version];
```
+ `CREATE DATABASE WITH OWNER`:
```
CREATE DATABASE name WITH OWNER = user_name;
```
다음 옵션은 JSON에서 지원되지 않습니다.
+ `CREATE DATABASE WITH TABLESPACE`:
```
CREATE DATABASE name WITH TABLESPACE = tablespace_name;
```
+ `CREATE DATABASE WITH TEMPLATE`:
```
CREATE DATABASE name WITH TEMPLATE = template;
```
## CREATE INDEX
`CREATE INDEX CONCURRENTLY`는 샤딩된 테이블에 대해 지원됩니다.
```
CREATE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX`는 모든 테이블 유형에서 지원됩니다.
```
CREATE UNIQUE INDEX index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX CONCURRENTLY`는 지원되지 않습니다.
```
CREATE UNIQUE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
자세한 내용은 [UNIQUE](#unique-constraint)를 참조하세요. 인덱스 만들기에 대한 일반적인 내용은 PostgreSQL 설명서에서 [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html)를 참조하세요.
**인덱스 표시**
`\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 SCHEMA
스키마 요소가 있는 `CREATE SCHEMA`는 지원되지 않습니다.
```
CREATE SCHEMA my_schema CREATE TABLE (column_name INT);
```
이것은 다음과 비슷한 오류를 생성합니다.
```
ERROR: CREATE SCHEMA with schema elements is not supported
```
## CREATE TABLE
`CREATE TABLE` 문에서의 관계는 지원되지 않습니다. 예를 들면 다음과 같습니다.
```
CREATE TABLE orders (orderid int, customerId int, orderDate date) WITH (autovacuum_enabled = false);
```
`IDENTITY` 열은 지원되지 않습니다. 예를 들면 다음과 같습니다.
```
CREATE TABLE orders (orderid INT GENERATED ALWAYS AS IDENTITY);
```
Aurora PostgreSQL Limitless Database는 샤딩된 테이블 이름에 최대 54자를 지원합니다.
## CREATE TABLE AS
`CREATE TABLE AS`를 사용하여 테이블을 만들려면 `rds_aurora.limitless_create_table_mode` 변수를 사용해야 합니다. 샤딩된 테이블의 경우 `rds_aurora.limitless_create_table_shard_key` 변수도 사용해야 합니다. 자세한 내용은 [변수를 사용하여 무한 테이블 만들기](limitless-creating-config.md) 섹션을 참조하세요.
```
-- Set the variables.
SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"a"}';
CREATE TABLE ctas_table AS SELECT 1 a;
-- "source" is the source table whose columns and data types are used to create the new "ctas_table2" table.
CREATE TABLE ctas_table2 AS SELECT a,b FROM source;
```
참조 테이블에는 프라이머리 키 제약이 필요하므로 `CREATE TABLE AS`를 사용하여 참조 테이블을 만들 수 없습니다. `CREATE TABLE AS`는 프라이머리 키를 새 테이블에 전파하지 않습니다.
일반적인 내용은 PostgreSQL 설명서에서 [CREATE TABLE AS](https://www.postgresql.org/docs/current/sql-createtableas.html)를 참조하세요.
## DROP DATABASE
만든 데이터베이스를 삭제할 수 있습니다.
`DROP DATABASE` 명령은 백그라운드에서 비동기식으로 실행됩니다. 실행 중일 때 동일한 이름으로 새 데이터베이스를 만들려고 하면 오류가 발생합니다.
## SELECT INTO
`SELECT INTO`는 [CREATE TABLE AS](#limitless-reference.DDL-limitations.CREATE_TABLE_AS)와 기능적으로 유사합니다. `rds_aurora.limitless_create_table_mode` 변수를 사용해야 합니다. 샤딩된 테이블의 경우 `rds_aurora.limitless_create_table_shard_key` 변수도 사용해야 합니다. 자세한 내용은 [변수를 사용하여 무한 테이블 만들기](limitless-creating-config.md) 섹션을 참조하세요.
```
-- Set the variables.
SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"a"}';
-- "source" is the source table whose columns and data types are used to create the new "destination" table.
SELECT * INTO destination FROM source;
```
현재 `SELECT INTO` 작업은 샤드를 직접 통하지 않고 라우터를 통해 수행됩니다. 따라서 성능이 느릴 수 있습니다.
일반적인 내용은 PostgreSQL 설명서에서 [SELECT INTO](https://www.postgresql.org/docs/current/sql-selectinto.html)를 참조하세요.
## 제약 조건
Aurora PostgreSQL Limitless Database의 제약에는 다음 제한 사항이 적용됩니다.
**CHECK**
리터럴과 비교 연산자를 포함하는 간단한 제약이 지원됩니다. 다음 예시와 같이 함수 검증이 필요한 더 복잡한 표현식 및 제약은 지원되지 않습니다.
```
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)
);
```
**EXCLUDE**
Aurora PostgreSQL Limitless Database에서는 제외 제약이 지원되지 않습니다.
**FOREIGN KEY**
자세한 내용은 [외래 키](#limitless-reference.DDL-limitations.FKs) 섹션을 참조하세요.
**Null이 아님**
`NOT NULL` 제약은 제한 없이 지원됩니다.
**PRIMARY KEY**
프라이머리 키는 고유한 제약을 의미하므로 고유한 제약에 대한 제한이 프라이머리 키에도 적용됩니다. 이는 다음을 의미합니다.
+ 테이블이 샤딩된 테이블로 변환되는 경우 샤드 키는 프라이머리 키의 하위 집합이어야 합니다. 즉, 프라이머리 키에는 샤드 키의 모든 열이 포함됩니다.
+ 테이블이 참조 테이블로 변환되는 경우 프라이머리 키가 있어야 합니다.
다음 예시에서는 프라이머리 키의 사용을 보여줍니다.
```
-- 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 테이블 만들기](limitless-creating.md) 섹션을 참조하세요.
**UNIQUE**
샤딩된 테이블에서 고유 키에는 샤드 키가 포함되어야 합니다. 즉, 샤드 키는 고유 키의 하위 집합이어야 합니다. 테이블 유형을 샤딩됨으로 변경할 때 확인됩니다. 참조 테이블에는 제한이 없습니다.
```
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 설명서에서 [Constraints](https://www.postgresql.org/docs/current/ddl-constraints.html)를 참조하세요.
## 기본값
Aurora PostgreSQL Limitless Database는 기본값의 표현식을 지원합니다.
다음 예시는 기본값 사용을 보여줍니다.
```
CREATE TABLE t (
a INT DEFAULT 5,
b TEXT DEFAULT 'NAN',
c NUMERIC
);
CALL rds_aurora.limitless_alter_table_type_sharded('t', ARRAY['a']);
INSERT INTO t DEFAULT VALUES;
SELECT * FROM t;
a | b | c
---+-----+---
5 | NAN |
(1 row)
```
다음 예시와 같이 표현식이 지원됩니다.
```
CREATE TABLE t1 (a NUMERIC DEFAULT random());
```
다음 예시에서는 `NOT NULL`이고 기본값이 있는 새 열을 추가합니다.
```
ALTER TABLE t ADD COLUMN d BOOLEAN NOT NULL DEFAULT FALSE;
SELECT * FROM t;
a | b | c | d
---+-----+---+---
5 | NAN | | f
(1 row)
```
다음 예시에서는 기존 열을 기본값으로 변경합니다.
```
ALTER TABLE t ALTER COLUMN c SET DEFAULT 0.0;
INSERT INTO t DEFAULT VALUES;
SELECT * FROM t;
a | b | c | d
---+-----+-----+-----
5 | NAN | | f
5 | NAN | 0.0 | f
(2 rows)
```
다음 예시에서는 기본값을 삭제합니다.
```
ALTER TABLE t ALTER COLUMN a DROP DEFAULT;
INSERT INTO t DEFAULT VALUES;
SELECT * FROM t;
a | b | c | d
---+-----+-----+-----
5 | NAN | | f
5 | NAN | 0.0 | f
| NAN | 0.0 | f
(3 rows)
```
자세한 내용은 PostgreSQL 설명서에서 [Default values](https://www.postgresql.org/docs/current/ddl-default.html)를 참조하세요.
## 확장 프로그램
Aurora PostgreSQL Limitless Database에서 지원되는 PostgreSQL 확장은 다음과 같습니다.
+ `aurora_limitless_fdw` - 이 확장은 사전 설치되어 있습니다. 삭제할 수 없습니다.
+ `aws_s3` - 이 확장은 Aurora PostgreSQL에서와 유사한 방식으로 Aurora PostgreSQL Limitless Database에서 작동합니다.
Amazon S3 버킷에서 Aurora PostgreSQL Limitless Database DB 클러스터로 데이터를 가져오거나 Aurora PostgreSQL Limitless Database DB 클러스터에서 Amazon S3 버킷으로 데이터를 내보낼 수 있습니다. 자세한 내용은 [PostgreSQL DB 인스턴스용 Aurora PostgreSQL DB 클러스터](USER_PostgreSQL.S3Import.md) 및 [Aurora PostgreSQL DB 클러스터에서 Amazon S3로 데이터 내보내기](postgresql-s3-export.md)(을)를 참조하세요.
+ `btree_gin`
+ `citext`
+ `ip4r`
+ `pg_buffercache` - 이 확장은 Aurora PostgreSQL Limitless Database에서 커뮤니티 PostgreSQL과는 다르게 작동합니다. 자세한 내용은 [Aurora PostgreSQL Limitless Database의 pg\$1buffercache 차이점](#limitless-reference.DDL-limitations.Extensions.pg_buffercache) 섹션을 참조하세요.
+ `pg_stat_statements`
+ `pg_trgm`
+ `pgcrypto`
+ `pgstattuple` - 이 확장은 Aurora PostgreSQL Limitless Database에서 커뮤니티 PostgreSQL과는 다르게 작동합니다. 자세한 내용은 [Aurora PostgreSQL Limitless Database의 pgstattuple 차이점](#limitless-reference.DDL-limitations.Extensions.pgstattuple) 섹션을 참조하세요.
+ `pgvector`
+ `plpgsql` - 이 확장은 사전 설치되어 있지만 삭제할 수 있습니다.
+ `PostGIS` - 긴 트랜잭션 및 테이블 관리 함수는 지원되지 않습니다. 공간 참조 테이블 수정은 지원되지 않습니다.
+ `unaccent`
+ `uuid`
현재 대부분의 PostgreSQL 확장은 Aurora PostgreSQL Limitless Database에서 지원되지 않습니다. 그러나 [shared\$1preload\$1libraries](https://www.postgresql.org/docs/current/runtime-config-client.html#RUNTIME-CONFIG-CLIENT-PRELOAD)(SPL) 구성 설정을 사용하여 Aurora PostgreSQL 기본 DB 클러스터로 확장을 로드할 수 있습니다. 확장은 Aurora PostgreSQL Limitless Database에도 로드되지만 제대로 작동하지 않을 수 있습니다.
예를 들어 `pg_hint_plan` 확장을 로드할 수 있지만 로드한다고 해서 쿼리 주석에 전달된 힌트가 사용되는 것은 아닙니다.
**참고**
[pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html) 확장과 연결된 객체는 수정할 수 없습니다. `pg_stat_statements` 설치에 대한 자세한 내용은 [limitless\$1stat\$1statements](limitless-monitoring-views.md#limitless_stat_statements)를 참조하세요.
`pg_available_extensions` 및 `pg_available_extension_versions` 함수를 사용하여 Aurora PostgreSQL Limitless Database에서 지원되는 확장을 찾을 수 있습니다.
다음 DDL은 확장에 지원됩니다.
**CREATE EXTENSION**
PostgreSQL에서와 같이 확장을 만들 수 있습니다.
```
CREATE EXTENSION [ IF NOT EXISTS ] extension_name
[ WITH ] [ SCHEMA schema_name ]
[ VERSION version ]
[ CASCADE ]
```
자세한 내용은 PostgreSQL 설명서에서 [CREATE EXTENSION](https://www.postgresql.org/docs/current/sql-createextension.html)을 참조하세요.
**ALTER EXTENSION**
다음 DDL이 지원됩니다.
```
ALTER EXTENSION name UPDATE [ TO new_version ]
ALTER EXTENSION name SET SCHEMA new_schema
```
자세한 내용은 PostgreSQL 설명서에서 [ALTER EXTENSION](https://www.postgresql.org/docs/current/sql-alterextension.html)을 참조하세요.
**DROP EXTENSION**
PostgreSQL에서와 같이 확장을 삭제할 수 있습니다.
```
DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
```
자세한 내용은 PostgreSQL 설명서에서 [DROP EXTENSION](https://www.postgresql.org/docs/current/sql-dropextension.html)을 참조하세요.
다음 DDL은 확장에 지원되지 않습니다.
**ALTER EXTENSION**
확장에서 멤버 객체를 추가하거나 삭제할 수 없습니다.
```
ALTER EXTENSION name ADD member_object
ALTER EXTENSION name DROP member_object
```
### Aurora PostgreSQL Limitless Database의 pg\$1buffercache 차이점
Aurora PostgreSQL Limitless Database에서 [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) 확장을 설치하고 `pg_buffercache` 뷰를 사용하면 현재 연결된 노드인 라우터에서 오는 버퍼 관련 정보만 수신합니다. 마찬가지로 `pg_buffercache_summary` 또는 `pg_buffercache_usage_counts` 함수를 사용하면 연결된 노드의 정보만 제공됩니다.
노드가 많을 수 있으며 문제를 효과적으로 진단하기 위해 원하는 노드에서 버퍼 정보에 액세스해야 할 수 있습니다. 따라서 Limitless Database는 다음 함수를 제공합니다.
+ `rds_aurora.limitless_pg_buffercache(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_summary(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_usage_counts(subcluster_id)`
라우터든 샤드든 원하는 노드의 하위 클러스터 ID를 입력하면 해당 노드와 관련된 버퍼 정보에 쉽게 액세스할 수 있습니다. 이러한 함수는 무한 데이터베이스에 `pg_buffercache` 확장을 설치할 때 직접 사용할 수 있습니다.
**참고**
Aurora PostgreSQL Limitless Database는 `pg_buffercache` 확장 버전 1.4 이상에서 이러한 함수를 지원합니다.
`limitless_pg_buffercache` 뷰에 표시된 열은 `pg_buffercache` 뷰의 열과 약간 다릅니다.
+ `bufferid` - `pg_buffercache`에서도 동일합니다.
+ `relname` - `pg_buffercache`에서와 같이 파일 노드 번호를 표시하는 대신 `limitless_pg_buffercache`는 현재 데이터베이스 또는 공유 시스템 카탈로그에서 사용 가능한 경우 연결된 `relname`을, 사용 가능하지 않은 경우 `NULL`을 표시합니다.
+ `parent_relname` - `pg_buffercache`에 없는 이 새 열에는 `relname` 열의 값이 파티셔닝된 테이블(샤딩된 테이블의 경우)을 나타내는 경우 상위 `relname`이 표시됩니다. 그렇지 않으면 `NULL`이 표시됩니다.
+ `spcname` – `pg_buffercache`에서와 같이 테이블스페이스 객체 식별자(OID)가 표시되는 대신 `limitless_pg_buffercache`에서는 테이블스페이스 이름이 표시됩니다.
+ `datname` - `pg_buffercache`에서와 같이 데이터베이스 OID가 표시되는 대신 `limitless_pg_buffercache`에서는 데이터베이스 이름이 표시됩니다.
+ `relforknumber` - `pg_buffercache`에서도 동일합니다.
+ `relblocknumber` - `pg_buffercache`에서도 동일합니다.
+ `isdirty` - `pg_buffercache`에서도 동일합니다.
+ `usagecount` - `pg_buffercache`에서도 동일합니다.
+ `pinning_backends` - `pg_buffercache`에서도 동일합니다.
`limitless_pg_buffercache_summary` 및 `limitless_pg_buffercache_usage_counts` 뷰의 열은 각각 일반 `pg_buffercache_summary` 및 `pg_buffercache_usage_counts` 뷰의 열과 동일합니다.
이러한 함수를 사용하면 Limitless Database 환경의 모든 노드에서 자세한 버퍼 캐시 정보에 액세스하여 데이터베이스 시스템을 보다 효과적으로 진단하고 관리할 수 있습니다.
### Aurora PostgreSQL Limitless Database의 pgstattuple 차이점
Aurora PostgreSQL에서 [pgstattuple](https://www.postgresql.org/docs/current/pgstattuple.html) 확장은 현재 외부 테이블, 파티셔닝된 테이블 또는 파티셔닝된 인덱스를 지원하지 않습니다. 그러나 Aurora PostgreSQL Limitless Database에서는 사용자가 만든 객체가 이러한 지원되지 않는 유형 중 하나인 경우가 많습니다. 일반 테이블 및 인덱스(예: 카탈로그 테이블 및 해당 인덱스)가 있지만 대부분의 객체는 외부 노드에 상주하여 라우터의 외부 객체가 됩니다.
이 확장은 튜플 수준에서 통계를 얻는 데 중요하며, 이는 팽창 제거 및 진단 정보 수집과 같은 작업에 매우 중요합니다. 따라서 Aurora PostgreSQL Limitless Database는 무한 데이터베이스에서 `pgstattuple` 확장을 지원합니다.
Aurora PostgreSQL Limitless Database는 `rds_aurora` 스키마에 다음 함수를 포함합니다.
**튜플 수준 통계 함수**
**`rds_aurora.limitless_pgstattuple(relation_name)`**
+ 용도: 표준 테이블 및 해당 인덱스에 대한 튜플 수준 통계 추출
+ 입력: `relation_name`(텍스트) – 관계의 이름
+ 출력: Aurora PostgreSQL의 `pgstattuple` 함수에서 반환된 열과 일치하는 열
**`rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블, 카탈로그 테이블 및 해당 인덱스에 대한 튜플 수준 통계 추출
+ 입력:
+ `relation_name`(텍스트) – 관계의 이름
+ `subcluster_id`(텍스트) - 통계를 추출할 노드의 하위 클러스터 ID
+ 출력:
+ 참조 및 카탈로그 테이블(인덱스 포함)의 경우 열은 Aurora PostgreSQL의 열과 일치합니다.
+ 샤딩된 테이블의 경우 통계는 지정된 하위 클러스터에 있는 샤딩된 테이블의 파티션만 나타냅니다.
**인덱스 통계 함수**
**`rds_aurora.limitless_pgstatindex(relation_name)`**
+ 용도: 표준 테이블의 B트리 인덱스에 대한 통계 추출
+ 입력: `relation_name`(텍스트) – B트리 인덱스의 이름
+ 출력: `root_block_no`를 제외한 모든 열이 반환됩니다. 반환된 열은 Aurora PostgreSQL의 `pgstatindex` 함수와 일치합니다.
**`rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블 및 카탈로그 테이블의 B트리 인덱스에 대한 통계 추출
+ 입력:
+ `relation_name`(텍스트) - B트리 인덱스의 이름
+ `subcluster_id`(텍스트) - 통계를 추출할 노드의 하위 클러스터 ID
+ 출력:
+ 참조 및 카탈로그 테이블 인덱스의 경우 모든 열(`root_block_no` 제외)이 반환됩니다. 반환된 열은 Aurora PostgreSQL과 일치합니다.
+ 샤딩된 테이블의 경우 통계는 지정된 하위 클러스터에 있는 샤딩된 테이블 인덱스의 파티션만 나타냅니다. `tree_level` 열에는 요청된 하위 클러스터의 모든 테이블 조각에 대한 평균이 표시됩니다.
**`rds_aurora.limitless_pgstatginindex(relation_name)`**
+ 용도: 표준 테이블의 Generalized Inverted Indexes(GIN)에 대한 통계 추출
+ 입력: `relation_name`(텍스트) – GIN의 이름
+ 출력: Aurora PostgreSQL의 `pgstatginindex` 함수에서 반환된 열과 일치하는 열
**`rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블 및 카탈로그 테이블의 GIN 인덱스에 대한 통계 추출
+ 입력:
+ `relation_name`(텍스트) - 인덱스의 이름
+ `subcluster_id`(텍스트) - 통계를 추출할 노드의 하위 클러스터 ID
+ 출력:
+ 참조 및 카탈로그 테이블 GIN 인덱스의 경우 열은 Aurora PostgreSQL의 열과 일치합니다.
+ 샤딩된 테이블의 경우 통계는 지정된 하위 클러스터에 있는 샤딩된 테이블 인덱스의 파티션만 나타냅니다.
**`rds_aurora.limitless_pgstathashindex(relation_name)`**
+ 용도: 표준 테이블의 해시 인덱스에 대한 통계 추출
+ 입력: `relation_name` (텍스트) – 해시 인덱스의 이름
+ 출력: Aurora PostgreSQL의 `pgstathashindex` 함수에서 반환된 열과 일치하는 열
**`rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블 및 카탈로그 테이블의 해시 인덱스에 대한 통계 추출
+ 입력:
+ `relation_name`(텍스트) - 인덱스의 이름
+ `subcluster_id`(텍스트) - 통계를 추출할 노드의 하위 클러스터 ID
+ 출력:
+ 참조 및 카탈로그 테이블 해시 인덱스의 경우 열은 Aurora PostgreSQL의 열과 일치합니다.
+ 샤딩된 테이블의 경우 통계는 지정된 하위 클러스터에 있는 샤딩된 테이블 인덱스의 파티션만 나타냅니다.
**페이지 수 함수**
**`rds_aurora.limitless_pg_relpages(relation_name)`**
+ 용도: 표준 테이블 및 해당 인덱스의 페이지 수 추출
+ 입력: `relation_name`(텍스트) – 관계의 이름
+ 출력: 지정된 관계의 페이지 수
**`rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블 및 카탈로그 테이블(인덱스 포함)의 페이지 수 추출
+ 입력:
+ `relation_name`(텍스트) – 관계의 이름
+ `subcluster_id`(텍스트) - 페이지 수를 추출할 노드의 하위 클러스터 ID
+ 출력: 샤딩된 테이블의 경우 페이지 수는 지정된 하위 클러스터에 있는 모든 테이블 조각의 페이지 수 합계입니다.
**대략적인 튜플 수준 통계 함수**
**`rds_aurora.limitless_pgstattuple_approx(relation_name)`**
+ 용도: 표준 테이블 및 해당 인덱스에 대한 대략적인 튜플 수준 통계 추출
+ 입력: `relation_name`(텍스트) – 관계의 이름
+ 출력: Aurora PostgreSQL의 pgstattuple\$1approx 함수에서 반환된 열과 일치하는 열
**`rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)`**
+ 용도: 참조 테이블, 샤딩된 테이블 및 카탈로그 테이블(인덱스 포함)에 대한 대략적인 튜플 수준 통계 추출
+ 입력:
+ `relation_name`(텍스트) – 관계의 이름
+ `subcluster_id`(텍스트) - 통계를 추출할 노드의 하위 클러스터 ID
+ 출력:
+ 참조 및 카탈로그 테이블(인덱스 포함)의 경우 열은 Aurora PostgreSQL의 열과 일치합니다.
+ 샤딩된 테이블의 경우 통계는 지정된 하위 클러스터에 있는 샤딩된 테이블의 파티션만 나타냅니다.
**참고**
현재 Aurora PostgreSQL Limitless Database는 구체화된 뷰, TOAST 테이블 또는 임시 테이블에서 `pgstattuple` 확장을 지원하지 않습니다.
Aurora PostgreSQL은 다른 형식을 지원하지만 Aurora PostgreSQL Limitless Database에서는 입력을 텍스트로 제공해야 합니다.
## 외래 키
외래 키(`FOREIGN KEY`) 제약은 몇 가지 제한 사항과 함께 지원됩니다.
+ `FOREIGN KEY`를 사용한 `CREATE TABLE`은 표준 테이블에만 지원됩니다. `FOREIGN KEY`를 사용하여 샤딩된 테이블 또는 참조 테이블을 만들려면 먼저 외래 키 제약 없이 테이블을 만듭니다. 그런 다음, 다음 문을 사용하여 수정합니다.
```
ALTER TABLE ADD CONSTRAINT;
```
+ 테이블에 외래 키 제약이 있는 경우 표준 테이블을 샤딩된 테이블 또는 참조 테이블로 변환하는 것은 지원되지 않습니다. 제약을 삭제한 다음 변환 후 추가하세요.
+ 외래 키 제약에 대한 테이블 유형에는 다음 제한 사항이 적용됩니다.
+ 표준 테이블에는 다른 표준 테이블에 대한 외래 키 제약이 있을 수 있습니다.
+ 상위 테이블과 하위 테이블이 공동 배치되고 외래 키가 샤드 키의 슈퍼 집합인 경우 샤딩된 테이블에 외래 키 제약이 있을 수 있습니다.
+ 샤딩된 테이블에는 참조 테이블에 대한 외래 키 제약이 있을 수 있습니다.
+ 참조 테이블에는 다른 참조 테이블에 대한 외래 키 제약이 있을 수 있습니다.
**Topics**
+ [외래 키 옵션](#limitless-reference.DDL-limitations.FKs.options)
+ [예시](#limitless-reference.DDL-limitations.FKs.examples)
### 외래 키 옵션
일부 DDL 옵션의 경우 Aurora PostgreSQL Limitless Database에서 외래 키가 지원됩니다. 다음 표에는 Aurora PostgreSQL Limitless Database 테이블 간에 지원되거나 지원되지 않는 옵션이 나열되어 있습니다.
| DDL 옵션 | 참조에서 참조로 | 샤딩됨에서 샤딩됨으로(공동 배치됨) | 참조에서 샤딩됨으로 | 표준에서 표준으로 |
| --- | --- | --- | --- | --- |
| `DEFERRABLE` | 예 | 예 | 예 | 예 |
| `INITIALLY DEFERRED` | 예 | 예 | 예 | 예 |
| `INITIALLY IMMEDIATE` | 예 | 예 | 예 | 예 |
| `MATCH FULL` | 예 | 예 | 예 | 예 |
| `MATCH PARTIAL` | 아니요 | 아니요 | 아니요 | 아니요 |
| `MATCH SIMPLE` | 예 | 예 | 예 | 예 |
| `NOT DEFERRABLE` | 예 | 예 | 예 | 예 |
| `NOT VALID` | 예 | 아니요 | 아니요 | 예 |
| `ON DELETE CASCADE` | 예 | 예 | 예 | 예 |
| `ON DELETE NO ACTION` | 예 | 예 | 예 | 예 |
| `ON DELETE RESTRICT` | 예 | 예 | 예 | 예 |
| `ON DELETE SET DEFAULT` | 아니요 | 아니요 | 아니요 | 아니요 |
| `ON DELETE SET NULL` | 예 | 아니요 | 아니요 | 예 |
| `ON UPDATE CASCADE` | 아니요 | 아니요 | 아니요 | 예 |
| `ON UPDATE NO ACTION` | 예 | 예 | 예 | 예 |
| `ON UPDATE RESTRICT` | 예 | 예 | 예 | 예 |
| `ON UPDATE SET DEFAULT` | 아니요 | 아니요 | 아니요 | 아니요 |
| `ON UPDATE SET NULL` | 예 | 아니요 | 아니요 | 예 |
### 예시
+ 표준에서 표준으로:
```
set rds_aurora.limitless_create_table_mode='standard';
CREATE TABLE products(
product_no integer PRIMARY KEY,
name text,
price numeric
);
CREATE TABLE orders (
order_id integer PRIMARY KEY,
product_no integer REFERENCES products (product_no),
quantity integer
);
SELECT constraint_name, table_name, constraint_type
FROM information_schema.table_constraints WHERE constraint_type='FOREIGN KEY';
constraint_name | table_name | constraint_type
-------------------------+-------------+-----------------
orders_product_no_fkey | orders | FOREIGN KEY
(1 row)
```
+ 샤딩됨에서 샤딩됨으로(공동 배치됨):
```
set rds_aurora.limitless_create_table_mode='sharded';
set rds_aurora.limitless_create_table_shard_key='{"product_no"}';
CREATE TABLE products(
product_no integer PRIMARY KEY,
name text,
price numeric
);
set rds_aurora.limitless_create_table_shard_key='{"order_id"}';
set rds_aurora.limitless_create_table_collocate_with='products';
CREATE TABLE orders (
order_id integer PRIMARY KEY,
product_no integer,
quantity integer
);
ALTER TABLE orders ADD CONSTRAINT order_product_fk FOREIGN KEY (product_no) REFERENCES products (product_no);
```
+ 참조에서 샤딩됨으로:
```
set rds_aurora.limitless_create_table_mode='reference';
CREATE TABLE products(
product_no integer PRIMARY KEY,
name text,
price numeric
);
set rds_aurora.limitless_create_table_mode='sharded';
set rds_aurora.limitless_create_table_shard_key='{"order_id"}';
CREATE TABLE orders (
order_id integer PRIMARY KEY,
product_no integer,
quantity integer
);
ALTER TABLE orders ADD CONSTRAINT order_product_fk FOREIGN KEY (product_no) REFERENCES products (product_no);
```
+ 참조에서 참조로:
```
set rds_aurora.limitless_create_table_mode='reference';
CREATE TABLE products(
product_no integer PRIMARY KEY,
name text,
price numeric
);
CREATE TABLE orders (
order_id integer PRIMARY KEY,
product_no integer,
quantity integer
);
ALTER TABLE orders ADD CONSTRAINT order_product_fk FOREIGN KEY (product_no) REFERENCES products (product_no);
```
## 함수
함수는 Aurora PostgreSQL Limitless Database에서 지원됩니다.
함수에 지원되는 DDL은 다음과 같습니다.
**CREATE FUNCTION**
Aurora PostgreSQL에서와 마찬가지로 함수를 만들 수 있지만, 함수를 대체하는 동안 휘발성을 변경할 수는 없습니다.
자세한 내용은 PostgreSQL 설명서에서 [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html)을 참조하십시오.
**ALTER FUNCTION**
Aurora PostgreSQL에서와 마찬가지로 함수를 변경할 수 있지만, 휘발성 변경은 불가능합니다.
자세한 내용은 PostgreSQL 설명서에서 [ALTER FUNCTION](https://www.postgresql.org/docs/current/sql-alterfunction.html)을 참조하세요.
**DROP FUNCTION**
Aurora PostgreSQL에서와 마찬가지로 함수를 삭제할 수 있습니다.
```
DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
[ CASCADE | RESTRICT ]
```
자세한 내용은 PostgreSQL 설명서에서 [DROP FUNCTION](https://www.postgresql.org/docs/current/sql-dropfunction.html)을 참조하세요.
**Topics**
+ [함수 배포](#limitless-function-distribution)
+ [함수 휘발성](#limitless-function-volatility)
### 함수 배포
함수의 모든 문이 단일 샤드를 대상으로 하는 경우 전체 함수를 대상 샤드로 푸시하는 것이 좋습니다. 그러면 결과가 라우터 자체에서 함수를 풀지 않고 라우터로 다시 전파됩니다. 함수 및 저장 프로시저 푸시다운 기능은 데이터 소스, 즉 샤드에 더 가까이에서 함수 또는 저장 프로시저를 실행하려는 고객에게 유용합니다.
함수를 배포하려면 먼저 함수를 만든 다음 `rds_aurora.limitless_distribute_function` 프로시저를 직접 호출하여 함수를 배포합니다. 이 함수는 다음 구문을 사용합니다.
```
SELECT rds_aurora.limitless_distribute_function('function_prototype', ARRAY['shard_key'], 'collocating_table');
```
함수에 다음과 같은 파라미터가 있습니다.
+ `function_prototype` - 배포할 함수입니다. 입력 인수만 언급하고 출력 인수는 언급하지 않습니다.
`OUT` 파라미터로 정의된 인수가 있는 경우, `function_prototype`의 인수에 해당 유형을 포함하지 마세요.
+ `ARRAY['shard_key']` - 함수의 샤드 키로 식별되는 함수 인수 목록입니다.
+ `collocating_table` - 대상 샤드의 데이터 범위를 포함하는 샤딩된 테이블입니다.
실행을 위해 이 함수를 푸시다운할 샤드를 식별하기 위해 시스템은 `ARRAY['shard_key']` 인수를 가져와 해시하고 이 해시 값이 포함된 범위를 호스팅하는 `collocating_table`에서 샤드를 찾습니다.
**제한 사항**
함수 또는 프로시저를 배포하면 해당 샤드의 샤드 키 범위에 의해 경계가 지정된 데이터만 처리합니다. 함수 또는 프로시저가 다른 샤드의 데이터에 액세스하려고 하는 경우 배포된 함수 또는 프로시저에서 반환되는 결과는 배포되지 않은 것의 결과와 다릅니다.
예를 들어, 여러 샤드를 터치하는 쿼리가 포함된 함수를 만든 다음 `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)
```
### 함수 휘발성
[pg\$1proc](https://www.postgresql.org/docs/current/catalog-pg-proc.html) 뷰에서 `provolatile` 값을 확인하여 함수가 변경 불가능한지, 안정적인지, 휘발성인지 확인할 수 있습니다. `provolatile` 값은 함수의 결과가 입력 인수에만 의존하는지 아니면 외부 요인의 영향을 받는지를 나타냅니다.
값은 다음 중 하나입니다.
+ `i` - 동일한 입력에 대해 항상 동일한 결과를 제공하는 변경 불가능한 함수
+ `s` - 스캔 내에서 결과(고정 입력의 경우)가 변경되지 않는 안정적인 함수
+ `v` - 결과가 언제든지 변경될 수 있는 휘발성 함수 또한 부작용이 있는 함수에 `v`를 사용하여 이 함수에 대한 직접 호출이 최적화로 인해 제거되지 않도록 합니다.
다음 예시에서는 휘발성 함수를 보여줍니다.
```
SELECT proname, provolatile FROM pg_proc WHERE proname='pg_sleep';
proname | provolatile
----------+-------------
pg_sleep | v
(1 row)
SELECT proname, provolatile FROM pg_proc WHERE proname='uuid_generate_v4';
proname | provolatile
------------------+-------------
uuid_generate_v4 | v
(1 row)
SELECT proname, provolatile FROM pg_proc WHERE proname='nextval';
proname | provolatile
---------+-------------
nextval | v
(1 row)
```
Aurora PostgreSQL Limitless Database에서는 기존 함수의 휘발성 변경이 지원되지 않습니다. 이는 다음 예시와 같이 `ALTER FUNCTION` 및 `CREATE OR REPLACE FUNCTION` 명령 모두에 적용됩니다.
```
-- Create an immutable function
CREATE FUNCTION immutable_func1(name text) RETURNS text language plpgsql
AS $$
BEGIN
RETURN name;
END;
$$IMMUTABLE;
-- Altering the volatility throws an error
ALTER FUNCTION immutable_func1 STABLE;
-- Replacing the function with altered volatility throws an error
CREATE OR REPLACE FUNCTION immutable_func1(name text) RETURNS text language plpgsql
AS $$
BEGIN
RETURN name;
END;
$$VOLATILE;
```
함수에 올바른 휘발성을 할당하는 것이 좋습니다. 예를 들어 함수가 여러 테이블에서 `SELECT`를 사용하거나 데이터베이스 객체를 참조하는 경우 `IMMUTABLE`로 설정하지 마세요. 테이블 내용이 변경되면 변경 불가능성이 중단됩니다.
Aurora PostgreSQL은 변경 불가능한 함수 내부에 `SELECT`를 허용하지만 결과가 올바르지 않을 수 있습니다. Aurora PostgreSQL Limitless Database는 오류와 잘못된 결과를 모두 반환할 수 있습니다. 함수 휘발성에 대한 자세한 내용은 PostgreSQL 설명서에서 [Function volatility categories](https://www.postgresql.org/docs/current/xfunc-volatility.html)를 참조하세요.
## 시퀀스
명명된 시퀀스는 오름차순 또는 내림차순으로 고유 번호를 생성하는 데이터베이스 객체입니다. `CREATE SEQUENCE`는 새 시퀀스 번호 생성기를 만듭니다. 시퀀스 값은 고유하도록 보장됩니다.
Aurora PostgreSQL Limitless Database에서 명명된 시퀀스를 만들면 배포된 시퀀스 객체가 만들어집니다. 그런 다음 Aurora PostgreSQL Limitless Database는 모든 Distributed Transaction Routers(라우터)에 중첩되지 않는 시퀀스 값 청크를 배포합니다. 청크는 라우터에서 로컬 시퀀스 객체로 표시되므로 `nextval` 및 `currval`과 같은 시퀀스 작업은 로컬에서 실행됩니다. 라우터는 독립적으로 작동하며 필요한 경우 배포된 시퀀스에서 새 청크를 요청합니다.
시퀀스에 대한 자세한 내용은 PostgreSQL 설명서에서 [CREATE SEQUENCE](https://www.postgresql.org/docs/current/sql-createsequence.html)를 참조하세요.
**Topics**
+ [새 청크 요청](#limitless-reference.DDL-limitations.Sequences.request-chunk)
+ [제한 사항](#limitless-reference.DDL-limitations.Sequences.limitations)
+ [지원되지 않는 옵션](#limitless-reference.DDL-limitations.Sequences.unsupported)
+ [예시](#limitless-reference.DDL-limitations.Sequences.examples)
+ [시퀀스 뷰](#limitless-reference.DDL-limitations.Sequences.views)
+ [시퀀스 문제 해결](#limitless-reference.DDL-limitations.Sequences.troubleshooting)
### 새 청크 요청
`rds_aurora.limitless_sequence_chunk_size` 파라미터를 사용하여 라우터에 할당된 청크의 크기를 구성합니다. 기본값은 `250000`입니다. 각 라우터는 처음에 활성 청크와 예약된 청크라는 두 개의 청크를 소유합니다. 활성 청크는 로컬 시퀀스 객체(`minvalue` 및 `maxvalue` 설정)를 구성하는 데 사용되며 예약된 청크는 내부 카탈로그 테이블에 저장됩니다. 활성 청크가 최솟값 또는 최댓값에 도달하면 예약된 청크로 바뀝니다. 이를 위해 `ALTER SEQUENCE`는 내부적으로 사용되며, 즉 `AccessExclusiveLock`이 획득됩니다.
백그라운드 작업자는 라우터 노드에서 10초마다 실행하여 사용된 예약된 청크의 시퀀스를 스캔합니다. 사용된 청크가 발견되면 작업자는 배포된 시퀀스에서 새 청크를 요청합니다. 백그라운드 작업자가 새 청크를 요청할 시간이 있을 만큼 청크 크기를 충분히 크게 설정해야 합니다. 사용자 세션의 컨텍스트에서는 원격 요청이 절대 발생하지 않으므로 새 시퀀스를 직접 요청할 수 없습니다.
### 제한 사항
Aurora PostgreSQL Limitless Database의 시퀀스에는 다음 제한 사항이 적용됩니다.
+ `pg_sequence` 카탈로그, `pg_sequences` 함수 및 `SELECT * FROM sequence_name` 문은 모두 배포된 상태가 아닌 로컬 시퀀스 상태만 표시합니다.
+ 시퀀스 값은 고유하도록 보장되고 세션 내에서 변화가 없도록 보장됩니다. 그러나 다른 세션이 다른 라우터에 연결된 경우 다른 세션에서 `nextval` 문이 실행되면 순서가 잘못될 수 있습니다.
+ 시퀀스 크기(사용 가능한 값 수)가 모든 라우터에 배포될 수 있을 만큼 충분히 큰지 확인하세요. `chunk_size`를 구성하려면 `rds_aurora.limitless_sequence_chunk_size` 파라미터를 사용합니다. (각 라우터에는 두 개의 청크가 있습니다.)
+ `CACHE` 옵션이 지원되지만 캐시는 `chunk_size`보다 작아야 합니다.
### 지원되지 않는 옵션
Aurora PostgreSQL Limitless Database의 시퀀스에는 다음 옵션이 지원되지 않습니다.
**시퀀스 조작 함수**
`setval` 함수는 지원되지 않습니다. 자세한 내용은 PostgreSQL 설명서에서 [Sequence Manipulation Functions](https://www.postgresql.org/docs/current/functions-sequence.html)을 참조하세요.
**CREATE ANY SEQUENCE**
다음 옵션은 지원되지 않습니다.
```
CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
[[ NO ] CYCLE]
```
자세한 내용은 PostgreSQL 설명서에서 [CREATE SEQUENCE](https://www.postgresql.org/docs/current/sql-createsequence.html)를 참조하세요.
**ALTER SEQUENCE**
다음 옵션은 지원되지 않습니다.
```
ALTER SEQUENCE
[[ NO ] CYCLE]
```
자세한 내용은 PostgreSQL 설명서에서 [ALTER SEQUENCE](https://www.postgresql.org/docs/current/sql-altersequence.html)를 참조하세요.
**ALTER TABLE**
`ALTER TABLE` 명령은 시퀀스에서 지원되지 않습니다.
### 예시
**CREATE/DROP SEQUENCE**
```
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
```
**ALTER 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)
```
### 시퀀스 뷰
Aurora PostgreSQL Limitless Database는 시퀀스에 대해 다음 뷰를 제공합니다.
**rds\$1aurora.limitless\$1distributed\$1sequence**
이 뷰는 배포된 시퀀스 상태 및 구성을 보여줍니다. `minvalue`, `maxvalue`, `start`, `inc` 및 `cache` 열은 [pg\$1sequences](https://www.postgresql.org/docs/current/view-pg-sequences.html) 뷰와 동일한 의미를 가지며 시퀀스가 만들어질 때 사용된 옵션을 보여줍니다. `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)
```
**rds\$1aurora.limitless\$1sequence\$1metadata**
이 뷰는 배포된 시퀀스 메타데이터를 표시하고 클러스터 노드에서 시퀀스 메타데이터를 집계합니다. 이는 다음 열을 사용합니다.
+ `subcluster_id` - 청크를 소유한 클러스터 노드 ID입니다.
+ 활성 청크 - 사용 중인 시퀀스의 청크입니다(`active_minvalue`, `active_maxvalue`).
+ 예약된 청크 - 다음에 사용할 로컬 청크입니다(`reserved_minvalue`, `reserved_maxvalue`).
+ `local_last_value` - 로컬 시퀀스에서 마지막으로 관찰된 값입니다.
+ `chunk_size` - 만들 때 구성된 청크의 크기입니다.
```
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\$1chunk가 빠르게 소비되어 경합이 발생하고 `LIMITLESS:AuroraLimitlessSequenceReplace`, `LWLock:LockManager`, `Lockrelation`, `LWlock:bufferscontent` 등의 대기 이벤트가 발생할 수 있습니다.
시퀀스 캐시 설정을 줄이세요.
다음 그림은 시퀀스 문제로 인한 대기 이벤트를 보여줍니다.
![\[시퀀스 문제로 인한 대기 이벤트.\]](http://docs.aws.amazon.com/ko_kr/AmazonRDS/latest/AuroraUserGuide/images/limitless_sequence_waits.png)
# 지원되는/지원되지 않는 데이터 조작 언어(DML) 및 쿼리 처리 SQL 명령
다음 표에는 Aurora PostgreSQL Limitless Database에서 지원되는/지원되지 않는 DML 명령과 제한 사항 또는 자세한 정보에 대한 참조가 나와 있습니다.
| Command | 지원 여부 | 제한 사항 또는 추가 정보 |
| --- | --- | --- |
| ABORT | 예 | 없음 |
| ANALYZE | 예 | [ANALYZE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.ANALYZE) |
| BEGIN | 예 | 없음 |
| CALL | 예 | 없음 |
| CHECKPOINT | 예 | 없음 |
| CLOSE | 예 | 없음 |
| CLUSTER | 예 | [CLUSTER](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.CLUSTER) |
| COMMIT | 예 | 없음 |
| COMMIT PREPARED | 아니요 | 해당 사항 없음 |
| COPY | 예 | 없음 |
| DEALLOCATE | 예 | 없음 |
| DECLARE | 예 | 없음 |
| DELETE | 예 | 없음 |
| DISCARD | 예 | 없음 |
| DO | 예 | 없음 |
| END | 예 | 없음 |
| EXECUTE | 예 | 없음 |
| EXPLAIN | 예 | [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN) |
| FETCH | 예 | 없음 |
| IMPORT FOREIGN SCHEMA | 아니요 | 해당 사항 없음 |
| INSERT | 예 | [INSERT](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.INSERT) |
| LISTEN | 아니요 | 해당 사항 없음 |
| LOCK | 예 | 없음 |
| MERGE | 아니요 | 해당 사항 없음 |
| MOVE | 예 | 없음 |
| NOTIFY | 아니요 | 해당 사항 없음 |
| OPEN | 예 | 없음 |
| PREPARE | 예 | 없음 |
| PREPARE TRANSACTION | 아니요 | 해당 사항 없음 |
| REFRESH MATERIALIZED VIEW | 아니요 | 해당 사항 없음 |
| REINDEX | 아니요 | 해당 사항 없음 |
| RELEASE SAVEPOINT | 예 | 없음 |
| ROLLBACK | 예 | 없음 |
| ROLLBACK PREPARED | 아니요 | 해당 사항 없음 |
| ROLLBACK TO SAVEPOINT | 예 | 없음 |
| SAVEPOINT | 예 | 없음 |
| SELECT | 예 | 없음 |
| SELECT INTO | 예 | 없음 |
| SHOW | 예 | 없음 |
| START TRANSACTION | 예 | 없음 |
| UNLISTEN | 아니요 | 없음 |
| UPDATE | 예 | [UPDATE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.UPDATE) |
| UPDATE … WHERE CURRENT OF | 아니요 | 해당 사항 없음 |
| VACUUM | 예 | [VACUUM](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.VACUUM) |
| VALUES | 예 | 없음 |
# Aurora PostgreSQL Limitless Database에 대한 DML 제한 사항 및 기타 정보
다음 주제에서는 Aurora PostgreSQL Limitless Database의 DML 및 쿼리 처리 SQL 명령에 대한 제한 사항을 설명하거나 자세한 정보를 제공합니다.
**Topics**
+ [ANALYZE](#limitless-reference.DML-limitations.ANALYZE)
+ [CLUSTER](#limitless-reference.DML-limitations.CLUSTER)
+ [EXPLAIN](#limitless-reference.DML-limitations.EXPLAIN)
+ [INSERT](#limitless-reference.DML-limitations.INSERT)
+ [UPDATE](#limitless-reference.DML-limitations.UPDATE)
+ [VACUUM](#limitless-reference.DML-limitations.VACUUM)
## ANALYZE
`ANALYZE` 명령은 데이터베이스의 테이블 내용에 대한 통계를 수집합니다. 이후 쿼리 플래너는 이러한 통계를 사용하여 쿼리에 대한 가장 효율적인 실행 계획을 결정하는 데 도움을 줍니다. 자세한 내용은 PostgreSQL 설명서의 [ANALYZE](https://www.postgresql.org/docs/current/sql-analyze.html)를 참조하세요.
Aurora PostgreSQL Limitless Database에서 `ANALYZE` 명령은 실행 시 모든 라우터 및 샤드에 대한 테이블 통계를 수집합니다.
`ANALYZE` 실행 중 모든 라우터에 대한 통계 계산을 방지하기 위해 테이블 통계는 라우터 중 하나에 대해 계산된 다음 피어 라우터에 복사됩니다.
## CLUSTER
`CLUSTER` 명령은 인덱스를 기반으로 테이블을 물리적으로 재정렬합니다. 인덱스가 테이블에 이미 정의되어 있어야 합니다. Aurora PostgreSQL Limitless Database에서 클러스터링은 각 샤드에 있는 인덱스의 일부와 같은 위치에 있습니다(로컬).
자세한 내용은 PostgreSQL 설명서의 [CLUSTER](https://www.postgresql.org/docs/current/sql-cluster.html)를 참조하세요.
## EXPLAIN
다음 파라미터를 사용하여 `EXPLAIN` 명령의 출력을 구성합니다.
+ `rds_aurora.limitless_explain_options` - `EXPLAIN` 출력에 포함할 항목입니다. 기본값은 `single_shard_optimization`입니다. 계획이 단일 샤드에 최적화되어 있는지가 표시되지만 샤드 계획은 포함되지 않습니다.
이 예시에서는 `EXPLAIN` 출력에 샤드의 계획이 표시되지 않습니다.
```
postgres_limitless=> EXPLAIN SELECT * FROM employees where id =25;
QUERY PLAN
------------------------------------------------------
Foreign Scan (cost=100.00..101.00 rows=100 width=0)
Single Shard Optimized
(2 rows)
```
이제 `shard_plans` 및 `single_shard_optimization`을 포함하도록 `rds_aurora.limitless_explain_options`을 설정합니다. 라우터와 샤드 모두에서 문 실행 계획을 볼 수 있습니다. 또한 `enable_seqscan` 파라미터를 비활성화하여 인덱스 스캔이 샤드 계층에 사용되도록 합니다.
```
postgres_limitless=> SET rds_aurora.limitless_explain_options = shard_plans, single_shard_optimization;
SET
postgres_limitless=> SET enable_seqscan = OFF;
SET
postgres_limitless=> EXPLAIN SELECT * FROM employees WHERE id = 25;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
Foreign Scan (cost=100.00..101.00 rows=100 width=0)
Remote Plans from Shard postgres_s4:
Index Scan using employees_ts00287_id_idx on employees_ts00287 employees_fs00003 (cost=0.14..8.16 rows=1 width=15)
Index Cond: (id = 25)
Single Shard Optimized
(5 rows)
```
`EXPLAIN` 명령에 대한 자세한 내용은 PostgreSQL 설명서의 [EXPLAIN](https://www.postgresql.org/docs/current/sql-explain.html)을 참조하세요.
## INSERT
대부분의 `INSERT` 명령은 Aurora PostgreSQL Limitless Database에서 지원됩니다.
PostgreSQL에는 명시적 `UPSERT` 명령이 없지만 `INSERT ... ON CONFLICT` 문을 지원합니다.
충돌 작업에 하위 쿼리 또는 변경 가능한 함수가 있는 경우 `INSERT ... ON CONFLICT`는 지원되지 않습니다.
```
-- RANDOM is a mutable function.
INSERT INTO sharded_table VALUES (1, 100) ON CONFLICT (id) DO UPDATE SET other_id = RANDOM();
ERROR: Aurora Limitless Tables doesn't support pushdown-unsafe functions with DO UPDATE clauses.
```
`INSERT` 명령에 대한 자세한 내용은 PostgreSQL 설명서의 [INSERT](https://www.postgresql.org/docs/current/sql-insert.html)를 참조하세요.
## UPDATE
샤드 키 업데이트는 지원되지 않습니다. 예를 들어 `customer_id` 샤드 키가 포함된 `customers`라는 샤딩된 테이블이 있습니다. 다음 DML 문은 오류를 일으킵니다.
```
postgres_limitless=> UPDATE customers SET customer_id = 11 WHERE customer_id =1;
ERROR: Shard key column update is not supported
postgres_limitless=> UPDATE customers SET customer_id = 11 WHERE customer_name='abc';
ERROR: Shard key column update is not supported
```
샤드 키를 업데이트하려면 먼저 샤드 키를 사용하여 행에 `DELETE` 작업을 수행한 다음 업데이트된 샤드 키 값을 사용하여 `INSERT` 작업으로 새 행을 삽입해야 합니다.
`UPDATE` 명령에 대한 자세한 내용은 PostgreSQL 설명서의 [Updating data](https://www.postgresql.org/docs/current/dml-update.html)를 참조하세요.
## VACUUM
샤딩된 테이블과 참조 테이블 모두에 vacuum 작업을 수행할 수 있습니다. 다음 `VACUUM` 함수는 Aurora PostgreSQL Limitless Database에서 완전히 지원됩니다.
+ VACUUM
+ [ANALYZE](#limitless-reference.DML-limitations.ANALYZE)
+ DISABLE\$1PAGE\$1SKIPPING
+ FREEZE
+ FULL
+ INDEX\$1CLEANUP
+ PARALLEL
+ PROCESS\$1TOAST
+ TRUNCATE
+ 상세 표시
Aurora PostgreSQL Limitless Database에서 `VACUUM`에는 다음과 같은 제한 사항이 있습니다.
+ [pg\$1visibility\$1map](https://www.postgresql.org/docs/current/pgvisibility.html) 확장은 지원되지 않습니다.
+ [pg\$1stat\$1all\$1indexes](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ALL-INDEXES-VIEW) 뷰를 사용하여 미사용 인덱스를 확인하는 것은 지원되지 않습니다.
+ [pg\$1stat\$1user\$1indexes](https://www.postgresql.org/docs/current/monitoring-stats.html), [pg\$1class](https://www.postgresql.org/docs/current/catalog-pg-class.html) 및 [pg\$1stats](https://www.postgresql.org/docs/current/view-pg-stats.html)에 대한 통합 뷰는 구현되지 않습니다.
`VACUUM` 명령에 대한 자세한 내용은 PostgreSQL 설명서의 [VACUUM](https://www.postgresql.org/docs/current/sql-vacuum.html)을 참조하세요. Aurora PostgreSQL Limitless Database에서 vacuum 작업이 작동하는 방법에 대한 자세한 내용은 [Vacuum 작업을 통한 스토리지 공간 회수](limitless-vacuum.md) 섹션을 참조하세요.
# Aurora PostgreSQL Limitless Database의 변수
다음 변수를 사용하여 Aurora PostgreSQL Limitless Database를 구성할 수 있습니다.
**rds\$1aurora.limitless\$1active\$1shard\$1key**
데이터베이스를 쿼리하는 동안 단일 샤드 키를 설정하므로 모든 `SELECT` 및 DML 쿼리가 샤드 키와 함께 상수 조건자로 추가됩니다. 자세한 내용은 [활성 샤드 키 설정](limitless-query.single-shard.md#limitless-query.single-shard.active) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1create\$1table\$1collocate\$1with**
이 변수를 특정 테이블 이름으로 설정하여 새로 만든 테이블을 해당 테이블과 공동 배치합니다. 자세한 내용은 [변수를 사용하여 무한 테이블 만들기](limitless-creating-config.md) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1create\$1table\$1mode**
테이블 만들기 모드를 설정합니다. 자세한 내용은 [변수를 사용하여 무한 테이블 만들기](limitless-creating-config.md) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1create\$1table\$1shard\$1key**
이 변수를 샤드 키로 사용할 열 이름 배열로 설정합니다. 자세한 내용은 [변수를 사용하여 무한 테이블 만들기](limitless-creating-config.md) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1explain\$1options**
`EXPLAIN` 출력에 포함할 항목입니다. 자세한 내용은 [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN) 단원을 참조하십시오.
# Aurora PostgreSQL Limitless Database의 DB 클러스터 파라미터
다음 DB 클러스터 파라미터를 사용하여 Aurora PostgreSQL Limitless Database를 구성할 수 있습니다.
**rds\$1aurora.limitless\$1adaptive\$1fetch\$1size**
배치 미리 가져오기를 개선합니다. `true`로 설정하면 이 파라미터는 미리 가져오기에서 가져오기 크기 자체 조정(적응)을 허용합니다. `false`로 설정하면 가져오기 크기가 일정합니다.
**rds\$1aurora.limitless\$1auto\$1scale\$1options**
DB 샤드 그룹에서 라우터를 추가하거나 샤드를 분할하는 데 사용할 수 있는 옵션을 설정합니다. 값은 `add_router`, `split_shard` 또는 둘 다일 수 있습니다.
자세한 내용은 [DB 샤드 그룹에 라우터 추가](limitless-add-router.md) 및 [DB 샤드 그룹에서 샤드 분할](limitless-shard-split.md) 단원을 참조하세요.
**rds\$1aurora.limitless\$1distributed\$1deadlock\$1timeout**
분산 교착 상태가 있는지 확인하기 전에 잠금을 기다리는 데 걸리는 시간(밀리초)입니다. 기본값은 `1000`(1초)입니다.
자세한 내용은 [Aurora PostgreSQL Limitless Database의 분산 교착](limitless-query.deadlocks.md) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1enable\$1auto\$1scale**
DB 샤드 그룹에서 라우터 추가 및 샤드 분할을 활성화합니다.
자세한 내용은 [DB 샤드 그룹에 라우터 추가](limitless-add-router.md) 및 [DB 샤드 그룹에서 샤드 분할](limitless-shard-split.md) 단원을 참조하세요.
**rds\$1aurora.limitless\$1finalize\$1split\$1shard\$1mode**
시스템 시작한 샤드 분할을 마무리하는 방법을 결정합니다. 자세한 내용은 [DB 샤드 그룹에서 샤드 분할](limitless-shard-split.md) 단원을 참조하십시오.
**rds\$1aurora.limitless\$1maximum\$1adaptive\$1fetch\$1size**
적응형 가져오기 크기의 상한을 설정합니다. 범위는 `1`\$1`INT_MAX`입니다. 기본값은 `1000`입니다.