Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Referensi Basis Data Tanpa Batas Aurora Postgre SQL
Kami menyediakan topik referensi berikut untuk Aurora SQL Postgre Limitless Database.
**Topics**
+ [Perintah Bahasa Definisi Data (DDL) SQL yang didukung dan tidak didukung](limitless-reference.DDL-support.md)
+ [Keterbatasan DDL dan informasi lainnya untuk Aurora PostgreSQL Limitless Database](limitless-reference.DDL-limitations.md)
+ [Didukung dan tidak didukung Data Manipulation Language (DHTML) dan perintah query processing SQL](limitless-reference.DML-support.md)
+ [DMLketerbatasan dan informasi lainnya untuk Aurora SQL Postgre Limitless Database](limitless-reference.DML-limitations.md)
+ [Variabel dalam Basis Data Tanpa Batas Aurora Postgre SQL](limitless-reference.variables.md)
+ [Parameter cluster DB di Aurora SQL Postgre Limitless Database](limitless-reference.DBCparams.md)
# Perintah Bahasa Definisi Data (DDL) SQL yang didukung dan tidak didukung
Tabel berikut mencantumkan DDL perintah yang didukung dan tidak didukung oleh Aurora Postgre SQL Limitless Database, dengan referensi ke batasan atau informasi lebih lanjut.
| Perintah | Didukung? | Keterbatasan atau informasi lebih lanjut |
| --- | --- | --- |
| ALTER AGGREGATE | Tidak | Tidak berlaku |
| ALTER COLLATION | Ya | Tidak ada |
| ALTER CONVERSION | Ya | Tidak ada |
| ALTER DATABASE | Tidak | Tidak berlaku |
| ALTER DEFAULT PRIVILEGES | Tidak | Tidak berlaku |
| ALTER DOMAIN | Tidak | Tidak berlaku |
| ALTER EVENT TRIGGER | Tidak | Tidak berlaku |
| ALTER EXTENSION | Ya | [Ekstensi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| ALTER FOREIGN DATA WRAPPER | Tidak | Tidak berlaku |
| ALTER FOREIGN TABLE | Tidak | Tidak berlaku |
| ALTER FUNCTION | Ya | [Fungsi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| ALTER GROUP | Ya | Tidak ada |
| ALTER INDEX | Ya | Tidak ada |
| ALTER LANGUAGE | Tidak | Tidak berlaku |
| ALTER LARGE OBJECT | Tidak | Tidak berlaku |
| ALTER MATERIALIZED VIEW | Tidak | Tidak berlaku |
| ALTER OPERATOR | Ya | Tidak ada |
| ALTER OPERATOR CLASS | Ya | Tidak ada |
| ALTER OPERATOR FAMILY | Ya | Tidak ada |
| ALTER POLICY | Tidak | Tidak berlaku |
| ALTER PROCEDURE | Ya | Tidak ada |
| ALTER PUBLICATION | Tidak | Tidak berlaku |
| ALTER ROLE | Ya | Tidak ada |
| ALTER ROUTINE | Tidak | Tidak berlaku |
| ALTER RULE | Tidak | Tidak berlaku |
| ALTER SCHEMA | Ya | Tidak ada |
| ALTER SEQUENCE | Ya | [Urutan](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| ALTER SERVER | Tidak | Tidak berlaku |
| ALTER STATISTICS | Tidak | Tidak berlaku |
| ALTER SUBSCRIPTION | Tidak | Tidak berlaku |
| ALTER SYSTEM | Tidak | Tidak berlaku |
| ALTER TABLE | Ya | [ALTER TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.ALTER_TABLE) |
| ALTER TABLESPACE | Tidak | Tidak berlaku |
| ALTER TEXT SEARCH CONFIGURATION | Tidak | Tidak berlaku |
| ALTER TEXT SEARCH DICTIONARY | Tidak | Tidak berlaku |
| ALTER TEXT SEARCH PARSER | Tidak | Tidak berlaku |
| ALTER TEXT SEARCH TEMPLATE | Tidak | Tidak berlaku |
| ALTER TRIGGER | Tidak | Tidak berlaku |
| ALTER TYPE | Ya | Tidak ada |
| ALTER USER | Ya | Tidak ada |
| ALTER USER MAPPING | Tidak | Tidak berlaku |
| ALTER VIEW | Ya | Tidak ada |
| COMMENT | Tidak | Tidak berlaku |
| CREATE ACCESS METHOD | Tidak | Tidak berlaku |
| CREATE AGGREGATE | Tidak | Tidak berlaku |
| CREATE CAST | Ya | Tidak ada |
| CREATE COLLATION | Ya | Tidak ada |
| CREATE CONVERSION | Ya | Tidak ada |
| CREATE DATABASE | Ya | [BUAT BASIS DATA](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_DATABASE) |
| CREATE DOMAIN | Tidak | Tidak berlaku |
| CREATE EVENT TRIGGER | Tidak | Tidak berlaku |
| CREATE EXTENSION | Ya | [Ekstensi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| CREATE FOREIGN DATA WRAPPER | Tidak | Tidak berlaku |
| CREATE FOREIGN TABLE | Tidak | Tidak berlaku |
| CREATE FUNCTION | Ya | [Fungsi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| CREATE GROUP | Ya | Tidak ada |
| CREATE INDEX | Ya | [CREATE INDEX](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_INDEX) |
| CREATE LANGUAGE | Tidak | Tidak berlaku |
| CREATE MATERIALIZED VIEW | Tidak | Tidak berlaku |
| CREATE OPERATOR | Ya | Tidak ada |
| CREATE OPERATOR CLASS | Ya | Tidak ada |
| CREATE OPERATOR FAMILY | Ya | Tidak ada |
| CREATE POLICY | Ya | Tidak ada |
| CREATE PROCEDURE | Ya | Tidak ada |
| CREATE PUBLICATION | Tidak | Tidak berlaku |
| CREATE ROLE | Ya | Tidak ada |
| CREATE RULE | Tidak | Tidak berlaku |
| CREATE SCHEMA | Ya | [BUAT SKEMA](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_SCHEMA) |
| CREATE SEQUENCE | Ya | [Urutan](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| CREATE SERVER | Tidak | Tidak berlaku |
| CREATE STATISTICS | Tidak | Tidak berlaku |
| CREATE SUBSCRIPTION | Tidak | Tidak berlaku |
| CREATE TABLE | Ya | [CREATE TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE) |
| CREATETABLESEBAGAI | Ya | [BUAT TABEL SEBAGAI](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE_AS) |
| CREATE TABLESPACE | Tidak | Tidak berlaku |
| CREATE TEMPORARY TABLE | Tidak | Tidak berlaku |
| CREATETEMPORARYTABLESEBAGAI | Tidak | Tidak berlaku |
| CREATE TEXT SEARCH CONFIGURATION | Tidak | Tidak berlaku |
| CREATE TEXT SEARCH DICTIONARY | Tidak | Tidak berlaku |
| CREATE TEXT SEARCH PARSER | Tidak | Tidak berlaku |
| CREATE TEXT SEARCH TEMPLATE | Tidak | Tidak berlaku |
| CREATE TRANSFORM | Tidak | Tidak berlaku |
| CREATE TRIGGER | Tidak | Tidak berlaku |
| CREATE TYPE | Ya | Tidak ada |
| CREATE USER | Ya | Tidak ada |
| CREATE USER MAPPING | Tidak | Tidak berlaku |
| CREATE VIEW | Ya | Tidak ada |
| DROP ACCESS METHOD | Tidak | Tidak berlaku |
| DROP AGGREGATE | Ya | Tidak ada |
| DROP CAST | Ya | Tidak ada |
| DROP COLLATION | Ya | Tidak ada |
| DROP CONVERSION | Ya | Tidak ada |
| DROP DATABASE | Ya | [DROP DATABASE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.DROP_DATABASE) |
| DROP DOMAIN | Tidak | Tidak berlaku |
| DROP EVENT TRIGGER | Tidak | Tidak berlaku |
| DROP EXTENSION | Ya | [Ekstensi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| DROP FOREIGN DATA WRAPPER | Tidak | Tidak berlaku |
| DROP FOREIGN TABLE | Tidak | Tidak berlaku |
| DROP FUNCTION | Ya | [Fungsi](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| DROP GROUP | Ya | Tidak ada |
| DROP INDEX | Ya | Tidak ada |
| DROP LANGUAGE | Tidak | Tidak berlaku |
| DROP MATERIALIZED VIEW | Tidak | Tidak berlaku |
| DROP OPERATOR | Ya | Tidak ada |
| DROP OPERATOR CLASS | Ya | Tidak ada |
| DROP OPERATOR FAMILY | Ya | Tidak ada |
| DROP OWNED | Tidak | Tidak berlaku |
| DROP POLICY | Tidak | Tidak berlaku |
| DROP PROCEDURE | Ya | Tidak ada |
| DROP PUBLICATION | Tidak | Tidak berlaku |
| DROP ROLE | Ya | Tidak ada |
| DROP ROUTINE | Tidak | Tidak berlaku |
| DROP RULE | Tidak | Tidak berlaku |
| DROP SCHEMA | Ya | Tidak ada |
| DROP SEQUENCE | Ya | Tidak ada |
| DROP SERVER | Tidak | Tidak berlaku |
| DROP STATISTICS | Tidak | Tidak berlaku |
| DROP SUBSCRIPTION | Tidak | Tidak ada |
| DROP TABLE | Ya | Tidak ada |
| DROP TABLESPACE | Tidak | Tidak berlaku |
| DROP TEXT SEARCH CONFIGURATION | Tidak | Tidak berlaku |
| DROP TEXT SEARCH DICTIONARY | Tidak | Tidak berlaku |
| DROP TEXT SEARCH PARSER | Tidak | Tidak berlaku |
| DROP TEXT SEARCH TEMPLATE | Tidak | Tidak berlaku |
| DROP TRANSFORM | Tidak | Tidak berlaku |
| DROP TRIGGER | Tidak | Tidak berlaku |
| DROP TYPE | Ya | Tidak ada |
| DROP USER | Ya | Tidak ada |
| DROP USER MAPPING | Tidak | Tidak berlaku |
| DROP VIEW | Ya | Tidak ada |
| GRANT | Ya | Tidak ada |
| REASSIGN OWNED | Tidak | Tidak berlaku |
| REVOKE | Ya | Tidak ada |
| SECURITY LABEL | Tidak | Tidak berlaku |
| SELECT INTO | Ya | [PILIH KE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.SELECT_INTO) |
| SET | Ya | Tidak ada |
| SET CONSTRAINTS | Tidak | Tidak berlaku |
| SET ROLE | Ya | Tidak ada |
| SET SESSION AUTHORIZATION | Ya | Tidak ada |
| SET TRANSACTION | Ya | Tidak ada |
| TRUNCATE | Ya | Tidak ada |
# Keterbatasan DDL dan informasi lainnya untuk Aurora PostgreSQL Limitless Database
Topik berikut menjelaskan batasan atau memberikan informasi lebih lanjut untuk perintah DDL SQL di Aurora PostgreSQL Limitless Database.
**Topics**
+ [ALTER TABLE](#limitless-reference.DDL-limitations.ALTER_TABLE)
+ [BUAT BASIS DATA](#limitless-reference.DDL-limitations.CREATE_DATABASE)
+ [CREATE INDEX](#limitless-reference.DDL-limitations.CREATE_INDEX)
+ [BUAT SKEMA](#limitless-reference.DDL-limitations.CREATE_SCHEMA)
+ [CREATE TABLE](#limitless-reference.DDL-limitations.CREATE_TABLE)
+ [BUAT TABEL SEBAGAI](#limitless-reference.DDL-limitations.CREATE_TABLE_AS)
+ [DROP DATABASE](#limitless-reference.DDL-limitations.DROP_DATABASE)
+ [PILIH KE](#limitless-reference.DDL-limitations.SELECT_INTO)
+ [Batasan](#limitless-reference.DDL-limitations.Constraints)
+ [Nilai default](#limitless-reference.DDL-limitations.DefaultValues)
+ [Ekstensi](#limitless-reference.DDL-limitations.Extensions)
+ [Kunci asing](#limitless-reference.DDL-limitations.FKs)
+ [Fungsi](#limitless-reference.DDL-limitations.Functions)
+ [Urutan](#limitless-reference.DDL-limitations.Sequences)
## ALTER TABLE
`ALTER TABLE`Perintah ini umumnya didukung di Aurora PostgreSQL Limitless Database. Untuk informasi selengkapnya, lihat [ALTER TABLE dalam dokumentasi](https://www.postgresql.org/docs/current/sql-altertable.html) PostgreSQL.
### Batasan
`ALTER TABLE`memiliki batasan berikut untuk opsi yang didukung.
**Menghapus kolom**
+ Pada tabel sharded, Anda tidak dapat menghapus kolom yang merupakan bagian dari kunci shard.
+ Pada tabel referensi, Anda tidak dapat menghapus kolom kunci utama.
**Mengubah tipe data kolom**
+ `USING`Ekspresi tidak didukung.
+ Pada tabel sharded, Anda tidak dapat mengubah jenis kolom yang merupakan bagian dari kunci shard.
**Menambahkan atau menghapus kendala**
Untuk detail tentang apa yang tidak didukung, lihat[Batasan](#limitless-reference.DDL-limitations.Constraints).
**Mengubah nilai default kolom**
Nilai default didukung. Untuk informasi selengkapnya, lihat [Nilai default](#limitless-reference.DDL-limitations.DefaultValues).
### Opsi yang tidak didukung
Beberapa opsi tidak didukung karena bergantung pada fitur yang tidak didukung, seperti pemicu.
Opsi tingkat tabel berikut untuk `ALTER TABLE` tidak didukung:
+ `ALL IN TABLESPACE`
+ `ATTACH PARTITION`
+ `DETACH PARTITION`
+ `ONLY`bendera
+ `RENAME CONSTRAINT`
Opsi tingkat kolom berikut untuk `ALTER TABLE` tidak didukung:
+ TAMBAHKAN YANG DIHASILKAN
+ EKSPRESI DROP [JIKA ADA]
+ JATUHKAN IDENTITAS [JIKA ADA]
+ ATUR ULANG
+ MENGULANG KEMBALI
+ SET
+ MENGATUR KOMPRESI
+ SET STATISTICS
## BUAT BASIS DATA
Di Aurora PostgreSQL Limitless Database, hanya database tak terbatas yang didukung.
Saat `CREATE DATABASE` sedang berjalan, database yang berhasil dibuat dalam satu atau lebih node mungkin gagal di node lain, karena pembuatan database adalah operasi nontransaksional. Dalam hal ini, objek database yang berhasil dibuat secara otomatis dihapus dari semua node dalam jumlah waktu yang telah ditentukan untuk menjaga konsistensi dalam grup shard DB. Selama waktu ini, pembuatan ulang database dengan nama yang sama dapat mengakibatkan kesalahan yang menunjukkan bahwa database sudah ada.
Opsi berikut didukung:
+ Pemeriksaan:
```
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;
```
Opsi berikut tidak didukung:
+ `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`didukung untuk tabel sharded:
```
CREATE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX`didukung untuk semua jenis tabel:
```
CREATE UNIQUE INDEX index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX CONCURRENTLY`tidak didukung:
```
CREATE UNIQUE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
Untuk informasi selengkapnya, lihat [UNIK](#unique-constraint). Untuk informasi umum tentang membuat indeks, lihat [CREATE INDEX dalam dokumentasi](https://www.postgresql.org/docs/current/sql-createindex.html) PostgreSQL.
**Menampilkan indeks**
Tidak semua indeks terlihat pada router saat Anda menggunakan `\d table_name` atau perintah serupa. Sebagai gantinya, gunakan `pg_catalog.pg_indexes` tampilan untuk mendapatkan indeks, seperti yang ditunjukkan pada contoh berikut.
```
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)
```
## BUAT SKEMA
`CREATE SCHEMA`dengan elemen skema tidak didukung:
```
CREATE SCHEMA my_schema CREATE TABLE (column_name INT);
```
Ini menghasilkan kesalahan yang mirip dengan yang berikut:
```
ERROR: CREATE SCHEMA with schema elements is not supported
```
## CREATE TABLE
Relasi dalam `CREATE TABLE` pernyataan tidak didukung, misalnya:
```
CREATE TABLE orders (orderid int, customerId int, orderDate date) WITH (autovacuum_enabled = false);
```
`IDENTITY`kolom tidak didukung, misalnya:
```
CREATE TABLE orders (orderid INT GENERATED ALWAYS AS IDENTITY);
```
Aurora PostgreSQL Limitless Database mendukung hingga 54 karakter untuk nama tabel sharded.
## BUAT TABEL SEBAGAI
Untuk membuat tabel menggunakan`CREATE TABLE AS`, Anda harus menggunakan `rds_aurora.limitless_create_table_mode` variabel. Untuk tabel sharded, Anda juga harus menggunakan `rds_aurora.limitless_create_table_shard_key` variabel. Untuk informasi selengkapnya, lihat [Membuat tabel tanpa batas dengan menggunakan variabel](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;
```
Anda tidak dapat menggunakan `CREATE TABLE AS` untuk membuat tabel referensi, karena mereka memerlukan kendala kunci primer. `CREATE TABLE AS`tidak menyebarkan kunci utama ke tabel baru.
Untuk informasi umum, lihat [MEMBUAT TABEL AS dalam dokumentasi](https://www.postgresql.org/docs/current/sql-createtableas.html) PostgreSQL.
## DROP DATABASE
Anda dapat menjatuhkan database yang telah Anda buat.
`DROP DATABASE`Perintah berjalan secara asinkron di latar belakang. Saat sedang berjalan, Anda akan menerima kesalahan jika Anda mencoba membuat database baru dengan nama yang sama.
## PILIH KE
`SELECT INTO`secara fungsional mirip dengan. [BUAT TABEL SEBAGAI](#limitless-reference.DDL-limitations.CREATE_TABLE_AS) Anda harus menggunakan `rds_aurora.limitless_create_table_mode` variabel. Untuk tabel sharded, Anda juga harus menggunakan `rds_aurora.limitless_create_table_shard_key` variabel. Untuk informasi selengkapnya, lihat [Membuat tabel tanpa batas dengan menggunakan variabel](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;
```
Saat ini, `SELECT INTO` operasi dilakukan melalui router, tidak langsung melalui pecahan. Karena itu, kinerjanya bisa lambat.
Untuk informasi umum, lihat [SELECT INTO dalam](https://www.postgresql.org/docs/current/sql-selectinto.html) dokumentasi PostgreSQL.
## Batasan
Batasan berikut berlaku untuk kendala di Aurora PostgreSQL Limitless Database.
**MEMERIKSA**
Kendala sederhana yang melibatkan operator perbandingan dengan literal didukung. Ekspresi dan batasan yang lebih kompleks yang memerlukan validasi fungsi tidak didukung, seperti yang ditunjukkan pada contoh berikut.
```
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"
);
```
Anda dapat memberikan batasan nama eksplisit, seperti yang ditunjukkan pada contoh berikut.
```
CREATE TABLE my_table (
id INT CONSTRAINT positive_id CHECK (id > 0)
, val INT CONSTRAINT val_in_range CHECK (val > 0 AND val < 1000)
);
```
Anda dapat menggunakan sintaks kendala tingkat tabel dengan kendala, seperti yang `CHECK` ditunjukkan pada contoh berikut.
```
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)
);
```
**MENGECUALIKAN**
Batasan pengecualian tidak didukung di Aurora PostgreSQL Limitless Database.
**KUNCI ASING**
Untuk informasi selengkapnya, lihat [Kunci asing](#limitless-reference.DDL-limitations.FKs).
**TIDAK NULL**
`NOT NULL`kendala didukung tanpa batasan.
**KUNCI UTAMA**
Kunci primer menyiratkan kendala unik dan oleh karena itu pembatasan yang sama pada kendala unik berlaku pada kunci primer. Ini berarti:
+ Jika tabel diubah menjadi tabel sharded, kunci shard harus merupakan bagian dari kunci utama. Artinya, kunci utama berisi semua kolom kunci shard.
+ Jika tabel diubah menjadi tabel referensi, itu harus memiliki kunci utama.
Contoh berikut menggambarkan penggunaan kunci primer.
```
-- 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']);
```
Mencoba menambahkan kunci utama yang tidak berisi kunci pecahan:
```
-- 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
```
Mencoba menambahkan kunci utama yang memang berisi kunci pecahan:
```
-- 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
```
Ubah tabel standar menjadi tabel referensi.
```
-- 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');
```
Untuk informasi selengkapnya tentang membuat tabel sharded dan referensi, lihat[Membuat tabel Basis Data Tanpa Batas Aurora Postgre SQL](limitless-creating.md).
**UNIK**
Dalam tabel sharded, kunci unik harus berisi kunci shard, yaitu kunci shard harus merupakan bagian dari kunci unik. Ini dicentang saat mengubah jenis tabel menjadi sharded. Dalam tabel referensi tidak ada batasan.
```
CREATE TABLE customer (
customer_id INT NOT NULL
, zipcode INT
, email TEXT UNIQUE
);
```
`UNIQUE`Kendala tingkat tabel didukung, seperti yang ditunjukkan pada contoh berikut.
```
CREATE TABLE customer (
customer_id INT NOT NULL
, zipcode INT
, email TEXT
, CONSTRAINT zipcode_and_email UNIQUE (zipcode, email)
);
```
Contoh berikut menunjukkan penggunaan kunci utama dan kunci unik bersama-sama. Kedua kunci harus menyertakan kunci shard.
```
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)
);
```
Untuk informasi selengkapnya, lihat [Batasan dalam dokumentasi PostgreSQL](https://www.postgresql.org/docs/current/ddl-constraints.html).
## Nilai default
Aurora PostgreSQL Limitless Database mendukung ekspresi dalam nilai default.
Contoh berikut menunjukkan penggunaan nilai default.
```
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)
```
Ekspresi didukung, seperti yang ditunjukkan pada contoh berikut.
```
CREATE TABLE t1 (a NUMERIC DEFAULT random());
```
Contoh berikut menambahkan kolom baru yang `NOT NULL` dan memiliki nilai default.
```
ALTER TABLE t ADD COLUMN d BOOLEAN NOT NULL DEFAULT FALSE;
SELECT * FROM t;
a | b | c | d
---+-----+---+---
5 | NAN | | f
(1 row)
```
Contoh berikut mengubah kolom yang ada dengan nilai default.
```
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)
```
Contoh berikut menjatuhkan nilai default.
```
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)
```
Untuk informasi selengkapnya, lihat [Nilai default](https://www.postgresql.org/docs/current/ddl-default.html) dalam dokumentasi PostgreSQL.
## Ekstensi
Ekstensi PostgreSQL berikut didukung di Aurora PostgreSQL Limitless Database:
+ `aurora_limitless_fdw`- Ekstensi ini sudah diinstal sebelumnya. Anda tidak bisa menjatuhkannya.
+ `aws_s3`- Ekstensi ini bekerja di Aurora PostgreSQL Limitless Database mirip dengan cara yang dilakukannya di Aurora PostgreSQL.
Anda dapat mengimpor data dari bucket Amazon S3 ke cluster DB Database PostgreSQL Limitless Aurora, atau mengekspor data dari cluster DB Database PostgreSQL Limitless Aurora ke bucket Amazon S3. Untuk informasi selengkapnya, lihat [Mengimpor data dari Amazon S3 ke klaster DB Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) dan [Mengekspor data dari klaster DB Aurora PostgreSQL ke Amazon S3](postgresql-s3-export.md).
+ `btree_gin`
+ `citext`
+ `ip4r`
+ `pg_buffercache`— Ekstensi ini berperilaku berbeda di Aurora PostgreSQL Limitless Database dari PostgreSQL komunitas PostgreSQL. Untuk informasi selengkapnya, lihat [perbedaan pg\$1buffercache di Aurora PostgreSQL Limitless Database](#limitless-reference.DDL-limitations.Extensions.pg_buffercache).
+ `pg_stat_statements`
+ `pg_trgm`
+ `pgcrypto`
+ `pgstattuple`— Ekstensi ini berperilaku berbeda di Aurora PostgreSQL Limitless Database dari PostgreSQL komunitas PostgreSQL. Untuk informasi selengkapnya, lihat [perbedaan pgstattuple di Aurora PostgreSQL Limitless Database](#limitless-reference.DDL-limitations.Extensions.pgstattuple).
+ `pgvector`
+ `plpgsql`— Ekstensi ini sudah diinstal sebelumnya, tetapi Anda dapat menjatuhkannya.
+ `PostGIS`— Transaksi panjang dan fungsi manajemen tabel tidak didukung. Memodifikasi tabel referensi spasial tidak didukung.
+ `unaccent`
+ `uuid`
Sebagian besar ekstensi PostgreSQL saat ini tidak didukung di Aurora PostgreSQL Limitless Database. Namun, Anda masih dapat menggunakan pengaturan konfigurasi [shared\$1preload\$1libraries](https://www.postgresql.org/docs/current/runtime-config-client.html#RUNTIME-CONFIG-CLIENT-PRELOAD) (SPL) untuk memuat ekstensi ke dalam cluster DB utama Aurora PostgreSQL. Mereka juga dimuat ke Aurora PostgreSQL Limitless Database, tetapi mungkin tidak berfungsi dengan benar.
Misalnya, Anda dapat memuat `pg_hint_plan` ekstensi, tetapi memuatnya tidak menjamin bahwa petunjuk yang diteruskan dalam komentar kueri digunakan.
**catatan**
Anda tidak dapat memodifikasi objek yang terkait dengan ekstensi [pg\$1stat\$1statement](https://www.postgresql.org/docs/current/pgstatstatements.html). Untuk informasi tentang penginstalan`pg_stat_statements`, lihat [limitless\$1stat\$1statement](limitless-monitoring-views.md#limitless_stat_statements).
Anda dapat menggunakan `pg_available_extensions` dan `pg_available_extension_versions` fungsi untuk menemukan ekstensi yang didukung di Aurora PostgreSQL Limitless Database.
DDLs Berikut ini didukung untuk ekstensi:
**CREATE EXTENSION**
Anda dapat membuat ekstensi, seperti di PostgreSQL.
```
CREATE EXTENSION [ IF NOT EXISTS ] extension_name
[ WITH ] [ SCHEMA schema_name ]
[ VERSION version ]
[ CASCADE ]
```
Untuk informasi selengkapnya, lihat [CREATE EXTENSION](https://www.postgresql.org/docs/current/sql-createextension.html) di dokumentasi PostgreSQL.
**ALTER EXTENSION**
Berikut ini DDLs didukung:
```
ALTER EXTENSION name UPDATE [ TO new_version ]
ALTER EXTENSION name SET SCHEMA new_schema
```
Untuk informasi selengkapnya, lihat [ALTER EXTENSION dalam dokumentasi](https://www.postgresql.org/docs/current/sql-alterextension.html) PostgreSQL.
**DROP EXTENSION**
Anda dapat menjatuhkan ekstensi, seperti di PostgreSQL.
```
DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
```
Untuk informasi selengkapnya, lihat [DROP EXTENSION](https://www.postgresql.org/docs/current/sql-dropextension.html) di dokumentasi PostgreSQL.
Berikut ini DDLs tidak didukung untuk ekstensi:
**ALTER EXTENSION**
Anda tidak dapat menambahkan atau menjatuhkan objek anggota dari ekstensi.
```
ALTER EXTENSION name ADD member_object
ALTER EXTENSION name DROP member_object
```
### perbedaan pg\$1buffercache di Aurora PostgreSQL Limitless Database
Di Aurora PostgreSQL Limitless Database, ketika Anda menginstal ekstensi [pg\$1buffercache dan menggunakan `pg_buffercache` tampilan, Anda menerima informasi terkait buffer](https://www.postgresql.org/docs/current/pgbuffercache.html) hanya dari node yang Anda sambungkan saat ini: router. Demikian pula, menggunakan fungsi `pg_buffercache_summary` atau `pg_buffercache_usage_counts` memberikan informasi hanya dari node yang terhubung.
Anda dapat memiliki banyak node dan mungkin perlu mengakses informasi buffer dari node apa pun untuk mendiagnosis masalah secara efektif. Oleh karena itu, Limitless Database menyediakan fungsi-fungsi berikut:
+ `rds_aurora.limitless_pg_buffercache(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_summary(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_usage_counts(subcluster_id)`
Dengan memasukkan ID subcluster dari setiap node, apakah itu router atau shard, Anda dapat dengan mudah mengakses informasi buffer khusus untuk node itu. Fungsi-fungsi ini langsung tersedia saat Anda menginstal `pg_buffercache` ekstensi di database tanpa batas.
**catatan**
Aurora PostgreSQL Limitless Database mendukung fungsi-fungsi ini untuk versi 1.4 dan lebih tinggi dari ekstensi. `pg_buffercache`
Kolom yang ditampilkan dalam `limitless_pg_buffercache` tampilan sedikit berbeda dari yang ada di `pg_buffercache` tampilan:
+ `bufferid`- Tetap tidak berubah dari`pg_buffercache`.
+ `relname`— Alih-alih menampilkan nomor node file seperti dalam`pg_buffercache`, `limitless_pg_buffercache` menyajikan yang terkait `relname` jika tersedia dalam database saat ini atau katalog sistem bersama, jika tidak. `NULL`
+ `parent_relname`- Kolom baru ini, tidak ada di`pg_buffercache`, menampilkan induk `relname` jika nilai dalam `relname` kolom mewakili tabel yang dipartisi (dalam kasus tabel sharded). Jika tidak, itu akan ditampilkan`NULL`.
+ `spcname`— Alih-alih menampilkan pengenal objek tablespace (OID) seperti pada`pg_buffercache`, `limitless_pg_buffercache` menampilkan nama tablespace.
+ `datname`— Alih-alih menampilkan database OID seperti dalam`pg_buffercache`, `limitless_pg_buffercache` menampilkan nama database.
+ `relforknumber`- Tetap tidak berubah dari`pg_buffercache`.
+ `relblocknumber`- Tetap tidak berubah dari`pg_buffercache`.
+ `isdirty`- Tetap tidak berubah dari`pg_buffercache`.
+ `usagecount`- Tetap tidak berubah dari`pg_buffercache`.
+ `pinning_backends`- Tetap tidak berubah dari`pg_buffercache`.
Kolom dalam `limitless_pg_buffercache_summary` dan `limitless_pg_buffercache_usage_counts` tampilan sama dengan yang ada di reguler `pg_buffercache_summary` dan `pg_buffercache_usage_counts` tampilan, masing-masing.
Dengan menggunakan fungsi-fungsi ini, Anda dapat mengakses informasi cache buffer terperinci di semua node di lingkungan Limitless Database Anda, memfasilitasi diagnosis dan pengelolaan sistem database Anda yang lebih efektif.
### perbedaan pgstattuple di Aurora PostgreSQL Limitless Database
Di Aurora PostgreSQL, ekstensi [pgstattuple](https://www.postgresql.org/docs/current/pgstattuple.html) saat ini tidak mendukung tabel asing, tabel yang dipartisi, atau indeks yang dipartisi. Namun, di Aurora PostgreSQL Limitless Database, objek yang dibuat pengguna sering di antara jenis yang tidak didukung ini. Meskipun ada tabel dan indeks reguler (misalnya, tabel katalog dan indeksnya), sebagian besar objek berada di node asing, menjadikannya benda asing untuk router.
Kami menyadari pentingnya ekstensi ini untuk mendapatkan statistik tingkat tuple, yang sangat penting untuk tugas-tugas seperti menghilangkan kembung dan mengumpulkan informasi diagnostik. Oleh karena itu, Aurora PostgreSQL Limitless Database menyediakan dukungan untuk ekstensi dalam database tanpa batas. `pgstattuple`
Aurora PostgreSQL Limitless Database mencakup fungsi-fungsi berikut dalam skema: `rds_aurora`
**Fungsi statistik tingkat tuple**
**`rds_aurora.limitless_pgstattuple(relation_name)`**
+ Tujuan: Ekstrak statistik tingkat tuple untuk tabel standar dan indeksnya
+ Input: `relation_name` (teks) — Nama relasi
+ Output: Kolom konsisten dengan yang dikembalikan oleh `pgstattuple` fungsi di Aurora PostgreSQL
**`rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak statistik tingkat tupel untuk tabel referensi, tabel sharded, tabel katalog, dan indeksnya
+ Masukan:
+ `relation_name`(teks) — Nama relasi
+ `subcluster_id`(text) — ID subcluster dari node tempat statistik akan diekstraksi
+ Output:
+ Untuk tabel referensi dan katalog (termasuk indeksnya), kolom konsisten dengan yang ada di Aurora PostgreSQL.
+ Untuk tabel sharded, statistik hanya mewakili partisi tabel sharded yang berada pada subcluster yang ditentukan.
**Fungsi statistik indeks**
**`rds_aurora.limitless_pgstatindex(relation_name)`**
+ Tujuan: Ekstrak statistik untuk indeks B-tree pada tabel standar
+ Masukan: `relation_name` (teks) — Nama indeks B-pohon
+ Output: Semua kolom `root_block_no` kecuali dikembalikan. Kolom yang dikembalikan konsisten dengan `pgstatindex` fungsi di Aurora PostgreSQL.
**`rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak statistik untuk indeks B-tree pada tabel referensi, tabel sharded, dan tabel katalog.
+ Masukan:
+ `relation_name`(teks) — Nama indeks B-pohon
+ `subcluster_id`(text) — ID subcluster dari node tempat statistik akan diekstraksi
+ Output:
+ Untuk indeks tabel referensi dan katalog, semua kolom (kecuali`root_block_no`) dikembalikan. Kolom yang dikembalikan konsisten dengan Aurora PostgreSQL.
+ Untuk tabel sharded, statistik hanya mewakili partisi indeks tabel sharded yang berada pada subcluster yang ditentukan. `tree_level`Kolom menunjukkan rata-rata di semua irisan tabel pada subcluster yang diminta.
**`rds_aurora.limitless_pgstatginindex(relation_name)`**
+ Tujuan: Ekstrak statistik untuk Indeks Terbalik Umum (GINs) pada tabel standar
+ Input: `relation_name` (teks) — Nama GIN
+ Output: Kolom konsisten dengan yang dikembalikan oleh `pgstatginindex` fungsi di Aurora PostgreSQL
**`rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak statistik untuk indeks GIN pada tabel referensi, tabel sharded, dan tabel katalog.
+ Masukan:
+ `relation_name`(teks) — Nama indeks
+ `subcluster_id`(text) — ID subcluster dari node tempat statistik akan diekstraksi
+ Output:
+ Untuk indeks GIN tabel referensi dan katalog, kolom konsisten dengan yang ada di Aurora PostgreSQL.
+ Untuk tabel sharded, statistik hanya mewakili partisi indeks tabel sharded yang berada pada subcluster yang ditentukan.
**`rds_aurora.limitless_pgstathashindex(relation_name)`**
+ Tujuan: Ekstrak statistik untuk indeks hash pada tabel standar
+ Input: `relation_name` (teks) — Nama indeks hash
+ Output: Kolom konsisten dengan yang dikembalikan oleh `pgstathashindex` fungsi di Aurora PostgreSQL
**`rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak statistik untuk indeks hash pada tabel referensi, tabel sharded, dan tabel katalog.
+ Masukan:
+ `relation_name`(teks) — Nama indeks
+ `subcluster_id`(text) — ID subcluster dari node tempat statistik akan diekstraksi
+ Output:
+ Untuk indeks hash tabel referensi dan katalog, kolom konsisten dengan Aurora PostgreSQL.
+ Untuk tabel sharded, statistik hanya mewakili partisi indeks tabel sharded yang berada pada subcluster yang ditentukan.
**Fungsi penghitungan halaman**
**`rds_aurora.limitless_pg_relpages(relation_name)`**
+ Tujuan: Ekstrak jumlah halaman untuk tabel standar dan indeksnya
+ Input: `relation_name` (teks) — Nama relasi
+ Output: Jumlah halaman dari relasi yang ditentukan
**`rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak jumlah halaman untuk tabel referensi, tabel sharded, dan tabel katalog (termasuk indeksnya)
+ Masukan:
+ `relation_name`(teks) — Nama relasi
+ `subcluster_id`(text) — ID subcluster dari node tempat jumlah halaman akan diekstraksi
+ Keluaran: Untuk tabel sharded, jumlah halaman adalah jumlah halaman di semua irisan tabel pada subcluster yang ditentukan.
**Perkiraan fungsi statistik tingkat tupel**
**`rds_aurora.limitless_pgstattuple_approx(relation_name)`**
+ Tujuan: Ekstrak perkiraan statistik tingkat tupel untuk tabel standar dan indeksnya
+ Input: `relation_name` (teks) — Nama relasi
+ Output: Kolom konsisten dengan yang dikembalikan oleh fungsi pgstattuple\$1approx di Aurora PostgreSQL
**`rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)`**
+ Tujuan: Ekstrak perkiraan statistik tingkat tupel untuk tabel referensi, tabel sharded, dan tabel katalog (termasuk indeksnya)
+ Masukan:
+ `relation_name`(teks) — Nama relasi
+ `subcluster_id`(text) — ID subcluster dari node tempat statistik akan diekstraksi
+ Output:
+ Untuk tabel referensi dan katalog (termasuk indeksnya), kolom konsisten dengan yang ada di Aurora PostgreSQL.
+ Untuk tabel sharded, statistik hanya mewakili partisi tabel sharded yang berada pada subcluster yang ditentukan.
**catatan**
Saat ini, Aurora PostgreSQL Limitless Database tidak mendukung `pgstattuple` ekstensi pada tampilan terwujud, tabel TOAST, atau tabel sementara.
Di Aurora PostgreSQL Limitless Database, Anda harus memberikan input sebagai teks, meskipun Aurora PostgreSQL mendukung format lain.
## Kunci asing
Kendala kunci asing (`FOREIGN KEY`) didukung dengan beberapa batasan:
+ `CREATE TABLE`dengan `FOREIGN KEY` didukung hanya untuk tabel standar. Untuk membuat tabel sharded atau referensi dengan`FOREIGN KEY`, pertama buat tabel tanpa kendala kunci asing. Kemudian memodifikasinya menggunakan pernyataan berikut:
```
ALTER TABLE ADD CONSTRAINT;
```
+ Mengonversi tabel standar ke tabel sharded atau referensi tidak didukung ketika tabel memiliki kendala kunci asing. Jatuhkan kendala, lalu tambahkan setelah konversi.
+ Batasan berikut berlaku untuk jenis tabel untuk kendala kunci asing:
+ Tabel standar dapat memiliki kendala kunci asing ke tabel standar lainnya.
+ Sebuah tabel sharded dapat memiliki kendala kunci asing jika tabel induk dan anak ditempatkan dan kunci asing adalah superset dari kunci shard.
+ Tabel sharded dapat memiliki kendala kunci asing ke tabel referensi.
+ Tabel referensi dapat memiliki kendala kunci asing ke tabel referensi lain.
**Topics**
+ [Opsi kunci asing](#limitless-reference.DDL-limitations.FKs.options)
+ [Contoh](#limitless-reference.DDL-limitations.FKs.examples)
### Opsi kunci asing
Kunci asing didukung di Aurora PostgreSQL Limitless Database untuk beberapa opsi DDL. Tabel berikut mencantumkan opsi yang didukung dan tidak didukung antara tabel Aurora PostgreSQL Limitless Database.
| Opsi DDL | Referensi untuk referensi | Sharded menjadi sharded (collocated) | Sharded ke referensi | Standar ke standar |
| --- | --- | --- | --- | --- |
| `DEFERRABLE` | Ya | Ya | Ya | Ya |
| `INITIALLY DEFERRED` | Ya | Ya | Ya | Ya |
| `INITIALLY IMMEDIATE` | Ya | Ya | Ya | Ya |
| `MATCH FULL` | Ya | Ya | Ya | Ya |
| `MATCH PARTIAL` | Tidak | Tidak | Tidak | Tidak |
| `MATCH SIMPLE` | Ya | Ya | Ya | Ya |
| `NOT DEFERRABLE` | Ya | Ya | Ya | Ya |
| `NOT VALID` | Ya | Tidak | Tidak | Ya |
| `ON DELETE CASCADE` | Ya | Ya | Ya | Ya |
| `ON DELETE NO ACTION` | Ya | Ya | Ya | Ya |
| `ON DELETE RESTRICT` | Ya | Ya | Ya | Ya |
| `ON DELETE SET DEFAULT` | Tidak | Tidak | Tidak | Tidak |
| `ON DELETE SET NULL` | Ya | Tidak | Tidak | Ya |
| `ON UPDATE CASCADE` | Tidak | Tidak | Tidak | Ya |
| `ON UPDATE NO ACTION` | Ya | Ya | Ya | Ya |
| `ON UPDATE RESTRICT` | Ya | Ya | Ya | Ya |
| `ON UPDATE SET DEFAULT` | Tidak | Tidak | Tidak | Tidak |
| `ON UPDATE SET NULL` | Ya | Tidak | Tidak | Ya |
### Contoh
+ Standar ke standar:
```
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)
```
+ Sharded ke sharded (collocated):
```
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);
```
+ Sharded ke referensi:
```
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);
```
+ Referensi untuk referensi:
```
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);
```
## Fungsi
Fungsi didukung di Aurora PostgreSQL Limitless Database.
DDLs Berikut ini didukung untuk fungsi:
**CREATE FUNCTION**
Anda dapat membuat fungsi, seperti di Aurora PostgreSQL, dengan pengecualian mengubah volatilitasnya saat menggantinya.
Untuk informasi selengkapnya, lihat [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html) dalam dokumentasi PostgreSQL.
**ALTER FUNCTION**
Anda dapat mengubah fungsi, seperti di Aurora PostgreSQL, dengan pengecualian mengubah volatilitasnya.
Untuk informasi selengkapnya, lihat [MENGUBAH FUNGSI dalam dokumentasi](https://www.postgresql.org/docs/current/sql-alterfunction.html) PostgreSQL.
**FUNGSI DROP**
Anda dapat menjatuhkan fungsi, seperti di Aurora PostgreSQL.
```
DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
[ CASCADE | RESTRICT ]
```
Untuk informasi selengkapnya, lihat [FUNGSI DROP](https://www.postgresql.org/docs/current/sql-dropfunction.html) dalam dokumentasi PostgreSQL.
**Topics**
+ [Distribusi fungsi](#limitless-function-distribution)
+ [Volatilitas fungsi](#limitless-function-volatility)
### Distribusi fungsi
Ketika semua pernyataan fungsi ditargetkan ke pecahan tunggal, ada baiknya untuk mendorong seluruh fungsi ke pecahan target. Kemudian hasilnya disebarkan kembali ke router, daripada mengurai fungsi di router itu sendiri. Fungsi dan kemampuan pushdown prosedur tersimpan berguna bagi pelanggan yang ingin menjalankan fungsinya atau prosedur tersimpan lebih dekat ke sumber data, yaitu pecahan.
Untuk mendistribusikan fungsi, pertama buat fungsi, lalu panggil `rds_aurora.limitless_distribute_function` prosedur untuk mendistribusikannya. Fungsi ini menggunakan sintaks berikut:
```
SELECT rds_aurora.limitless_distribute_function('function_prototype', ARRAY['shard_key'], 'collocating_table');
```
Fungsi ini mengambil parameter berikut:
+ `function_prototype`Fungsi yang akan didistribusikan. Sebutkan hanya argumen masukan, dan bukan argumen keluaran apa pun.
Jika salah satu argumen didefinisikan sebagai `OUT` parameter, jangan sertakan tipenya dalam argumen`function_prototype`.
+ `ARRAY['shard_key']`— Daftar argumen fungsi yang diidentifikasi sebagai kunci shard untuk fungsi tersebut.
+ `collocating_table`— Tabel sharded yang berisi rentang data pada pecahan target.
Untuk mengidentifikasi pecahan tempat menekan fungsi ini untuk berjalan, sistem mengambil `ARRAY['shard_key']` argumen, melakukan hash, dan menemukan pecahan dari yang menampung rentang `collocating_table` yang berisi nilai hash ini.
**Pembatasan**
Ketika Anda mendistribusikan fungsi atau prosedur, itu hanya berhubungan dengan data yang dibatasi oleh rentang kunci shard di pecahan itu. Dalam kasus di mana fungsi atau prosedur mencoba mengakses data dari pecahan yang berbeda, hasil yang dikembalikan oleh fungsi atau prosedur terdistribusi akan berbeda dibandingkan dengan yang tidak didistribusikan.
Misalnya, Anda membuat fungsi yang berisi kueri yang akan menyentuh beberapa pecahan, tetapi kemudian memanggil `rds_aurora.limitless_distribute_function` prosedur untuk mendistribusikannya. Saat Anda memanggil fungsi ini dengan memberikan argumen untuk kunci shard, kemungkinan hasil menjalankannya akan dibatasi oleh nilai yang ada dalam pecahan itu. Hasil ini berbeda dari yang dihasilkan tanpa mendistribusikan fungsi.
**Contoh**
Pertimbangkan fungsi berikut `func` di mana kita memiliki tabel sharded `customers` dengan kunci shard. `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;
$$;
```
Sekarang kami mendistribusikan fungsi ini:
```
SELECT rds_aurora.limitless_distribute_function('func(integer, integer)', ARRAY['c_id'], 'customers');
```
Berikut ini adalah contoh rencana query.
```
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)
```
Contoh berikut menunjukkan prosedur dengan `IN` dan `OUT` parameter sebagai argumen.
```
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;
```
Contoh berikut mendistribusikan prosedur hanya menggunakan `IN` parameter.
```
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)
```
### Volatilitas fungsi
[Anda dapat menentukan apakah suatu fungsi tidak dapat diubah, stabil, atau tidak stabil dengan memeriksa `provolatile` nilai dalam tampilan pg\$1proc.](https://www.postgresql.org/docs/current/catalog-pg-proc.html) `provolatile`Nilai menunjukkan apakah hasil fungsi hanya bergantung pada argumen masukan, atau dipengaruhi oleh faktor luar.
Nilainya adalah salah satu dari berikut ini:
+ `i`— Fungsi yang tidak dapat diubah, yang selalu memberikan hasil yang sama untuk input yang sama
+ `s`— Fungsi stabil, yang hasilnya (untuk input tetap) tidak berubah dalam pemindaian
+ `v`— Fungsi volatil, yang hasilnya dapat berubah sewaktu-waktu. Juga gunakan `v` untuk fungsi dengan efek samping, sehingga panggilan ke mereka tidak dapat dioptimalkan.
Contoh berikut menunjukkan fungsi volatile.
```
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)
```
Mengubah volatilitas fungsi yang ada tidak didukung di Aurora PostgreSQL Limitless Database. Ini berlaku untuk keduanya `ALTER FUNCTION` dan `CREATE OR REPLACE FUNCTION` perintah, seperti yang ditunjukkan pada contoh berikut.
```
-- 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;
```
Kami sangat menyarankan Anda menetapkan volatilitas yang benar ke fungsi. Misalnya, jika fungsi Anda menggunakan `SELECT` dari beberapa tabel atau referensi objek database, jangan atur sebagai`IMMUTABLE`. Jika isi tabel pernah berubah, kekekalan rusak.
Aurora PostgreSQL memungkinkan fungsi yang tidak dapat diubah `SELECT` di dalam, tetapi hasilnya mungkin salah. Aurora PostgreSQL Limitless Database dapat mengembalikan kesalahan dan hasil yang salah. Untuk informasi selengkapnya tentang volatilitas fungsi, lihat [Kategori volatilitas fungsi](https://www.postgresql.org/docs/current/xfunc-volatility.html) dalam dokumentasi PostgreSQL.
## Urutan
Urutan bernama adalah objek database yang menghasilkan angka unik dalam urutan naik atau turun. `CREATE SEQUENCE`membuat generator nomor urut baru. Nilai urutan dijamin unik.
Saat Anda membuat urutan bernama di Aurora PostgreSQL Limitless Database, objek urutan terdistribusi dibuat. Kemudian Aurora PostgreSQL Limitless Database mendistribusikan potongan nilai urutan yang tidak tumpang tindih di semua Router Transaksi Terdistribusi (router). Potongan direpresentasikan sebagai objek urutan lokal pada router; oleh karena itu, operasi urutan seperti `nextval` dan dijalankan `currval` secara lokal. Router beroperasi secara independen, dan meminta potongan baru dari urutan terdistribusi bila diperlukan.
Untuk informasi selengkapnya tentang urutan, lihat [CREATE SEQUENCE dalam dokumentasi](https://www.postgresql.org/docs/current/sql-createsequence.html) PostgreSQL.
**Topics**
+ [Meminta potongan baru](#limitless-reference.DDL-limitations.Sequences.request-chunk)
+ [Batasan](#limitless-reference.DDL-limitations.Sequences.limitations)
+ [Opsi yang tidak didukung](#limitless-reference.DDL-limitations.Sequences.unsupported)
+ [Contoh](#limitless-reference.DDL-limitations.Sequences.examples)
+ [Tampilan urutan](#limitless-reference.DDL-limitations.Sequences.views)
+ [Memecahkan masalah urutan](#limitless-reference.DDL-limitations.Sequences.troubleshooting)
### Meminta potongan baru
Anda mengkonfigurasi ukuran potongan yang dialokasikan pada router dengan menggunakan parameter. `rds_aurora.limitless_sequence_chunk_size` Nilai default-nya adalah `250000`. Setiap router awalnya memiliki dua potongan: aktif dan dicadangkan. Potongan aktif digunakan untuk mengonfigurasi objek urutan lokal (pengaturan `minvalue` dan`maxvalue`), dan potongan cadangan disimpan dalam tabel katalog internal. Ketika potongan aktif mencapai nilai minimum atau maksimum, itu diganti dengan potongan cadangan. Untuk melakukan itu, `ALTER SEQUENCE` digunakan secara internal, artinya `AccessExclusiveLock` diperoleh.
Pekerja latar belakang berjalan setiap 10 detik pada node router untuk memindai urutan potongan cadangan yang digunakan. Jika potongan bekas ditemukan, pekerja meminta potongan baru dari urutan terdistribusi. Pastikan untuk mengatur ukuran potongan cukup besar sehingga pekerja latar belakang memiliki cukup waktu untuk meminta yang baru. Permintaan jarak jauh tidak pernah terjadi dalam konteks sesi pengguna, yang berarti Anda tidak dapat meminta urutan baru secara langsung.
### Batasan
Batasan berikut berlaku untuk urutan di Aurora PostgreSQL Limitless Database:
+ `pg_sequence`Katalog, `pg_sequences` fungsi, dan `SELECT * FROM sequence_name` pernyataan semuanya hanya menampilkan status urutan lokal, bukan status terdistribusi.
+ Nilai urutan dijamin unik, dan dijamin monotonik dalam satu sesi. Tetapi mereka bisa rusak dengan `nextval` pernyataan yang dijalankan di sesi lain, jika sesi tersebut terhubung ke router lain.
+ Pastikan bahwa ukuran urutan (jumlah nilai yang tersedia) cukup besar untuk didistribusikan di semua router. Gunakan `rds_aurora.limitless_sequence_chunk_size` parameter untuk mengkonfigurasi file`chunk_size`. (Setiap router memiliki dua potongan.)
+ `CACHE`Opsi ini didukung, tetapi cache harus lebih kecil dari`chunk_size`.
### Opsi yang tidak didukung
Opsi berikut tidak didukung untuk urutan di Aurora PostgreSQL Limitless Database.
**Fungsi manipulasi urutan**
`setval`Fungsi ini tidak didukung. Untuk informasi selengkapnya, lihat [Fungsi Manipulasi Urutan](https://www.postgresql.org/docs/current/functions-sequence.html) dalam dokumentasi PostgreSQL.
**BUAT URUTAN**
Opsi berikut tidak didukung.
```
CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
[[ NO ] CYCLE]
```
Untuk informasi selengkapnya, lihat [CREATE SEQUENCE](https://www.postgresql.org/docs/current/sql-createsequence.html) dalam dokumentasi PostgreSQL.
**MENGUBAH URUTAN**
Opsi berikut tidak didukung.
```
ALTER SEQUENCE
[[ NO ] CYCLE]
```
Untuk informasi selengkapnya, lihat [ALTER SEQUENCE](https://www.postgresql.org/docs/current/sql-altersequence.html) dalam dokumentasi PostgreSQL.
**ALTER TABLE**
`ALTER TABLE`Perintah tidak didukung untuk urutan.
### Contoh
**MEMBUAT/MENJATUHKAN URUTAN**
```
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
```
**MENGUBAH URUTAN**
```
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)
```
**Fungsi manipulasi urutan**
```
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)
```
### Tampilan urutan
Aurora PostgreSQL Limitless Database menyediakan tampilan berikut untuk urutan.
**rds\$1aurora.limitless\$1distributed\$1sequence**
Tampilan ini menunjukkan status urutan terdistribusi dan konfigurasi. `cache`Kolom `minvalue` `maxvalue``start`,`inc`,, dan memiliki arti yang sama seperti pada tampilan [pg\$1sequences](https://www.postgresql.org/docs/current/view-pg-sequences.html), dan menampilkan opsi yang dengannya urutan dibuat. `lastval`Kolom menunjukkan nilai alokasi atau cadangan terbaru dalam objek urutan terdistribusi. Ini tidak berarti bahwa nilainya sudah digunakan, karena router menyimpan potongan urutan secara lokal.
```
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**
Tampilan ini menunjukkan metadata urutan terdistribusi dan metadata urutan agregat dari node cluster. Ini menggunakan kolom berikut:
+ `subcluster_id`— ID node cluster yang memiliki potongan.
+ Active chunk — Sebuah potongan dari urutan yang sedang digunakan (`active_minvalue`,`active_maxvalue`).
+ Potongan cadangan — Potongan lokal yang akan digunakan next (`reserved_minvalue`,`reserved_maxvalue`).
+ `local_last_value`— Nilai terakhir yang diamati dari urutan lokal.
+ `chunk_size`— Ukuran potongan, seperti yang dikonfigurasi pada pembuatan.
```
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)
```
### Memecahkan masalah urutan
Masalah berikut dapat terjadi dengan urutan.
**Ukuran potongan tidak cukup besar**
Jika ukuran potongan tidak diatur cukup besar dan tingkat transaksi tinggi, pekerja latar belakang mungkin tidak memiliki cukup waktu untuk meminta potongan baru sebelum potongan aktif habis. Hal ini dapat menyebabkan pertengkaran dan peristiwa menunggu seperti`LIMITLESS:AuroraLimitlessSequenceReplace`,, `LWLock:LockManager``Lockrelation`, dan`LWlock:bufferscontent`.
Tingkatkan nilai parameter `rds_aurora.limitless_sequence_chunk_size`.
**Cache urutan diatur terlalu tinggi**
Di PostgreSQL, caching urutan terjadi pada tingkat sesi. Setiap sesi mengalokasikan nilai urutan berturut-turut selama satu akses ke objek urutan, dan meningkatkan objek urutan yang sesuai. `last_value` Kemudian, penggunaan berikutnya dari `nextval` dalam sesi itu hanya mengembalikan nilai yang telah dialokasikan sebelumnya tanpa menyentuh objek urutan.
Setiap angka yang dialokasikan tetapi tidak digunakan dalam sesi akan hilang ketika sesi itu berakhir, menghasilkan “lubang” dalam urutan. Ini dapat menghabiskan sequence\$1chunk dengan cepat dan menyebabkan pertengkaran dan peristiwa menunggu seperti,,, dan. `LIMITLESS:AuroraLimitlessSequenceReplace` `LWLock:LockManager` `Lockrelation` `LWlock:bufferscontent`
Kurangi pengaturan cache urutan.
Gambar berikut menunjukkan peristiwa tunggu yang disebabkan oleh masalah urutan.
![\[Tunggu peristiwa yang disebabkan oleh masalah urutan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/limitless_sequence_waits.png)
# Didukung dan tidak didukung Data Manipulation Language (DHTML) dan perintah query processing SQL
Tabel berikut mencantumkan perintah DHTML yang didukung dan tidak didukung oleh Aurora PostgreSQL Limitless Database, dengan referensi ke batasan atau informasi lebih lanjut.
| Perintah | Didukung? | Keterbatasan atau informasi lebih lanjut |
| --- | --- | --- |
| MENGGUGURKAN | Ya | Tidak ada |
| MENGANALISA | Ya | [ANALYZE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.ANALYZE) |
| MULAI | Ya | Tidak ada |
| PANGGILAN | Ya | Tidak ada |
| CHECKPOINT | Ya | Tidak ada |
| TUTUP | Ya | Tidak ada |
| GUGUS | Ya | [CLUSTER](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.CLUSTER) |
| COMMIT | Ya | Tidak ada |
| KOMIT DISIAPKAN | Tidak | Tidak berlaku |
| MENYONTEK | Ya | Tidak ada |
| DEALOKASI | Ya | Tidak ada |
| MENYATAKAN | Ya | Tidak ada |
| DELETE | Ya | Tidak ada |
| MEMBUANG | Ya | Tidak ada |
| BERBUAT | Ya | Tidak ada |
| AKHIR | Ya | Tidak ada |
| EXECUTE | Ya | Tidak ada |
| EXPLAIN | Ya | [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN) |
| AMBIL | Ya | Tidak ada |
| IMPOR SKEMA ASING | Tidak | Tidak berlaku |
| INSERT | Ya | [INSERT](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.INSERT) |
| DENGARKAN | Tidak | Tidak berlaku |
| GEMBOK | Ya | Tidak ada |
| MERGE | Tidak | Tidak berlaku |
| PINDAH | Ya | Tidak ada |
| MEMBERITAHUKAN | Tidak | Tidak berlaku |
| BUKA | Ya | Tidak ada |
| MEMPERSIAPKAN | Ya | Tidak ada |
| MENYIAPKAN TRANSAKSI | Tidak | Tidak berlaku |
| MENYEGARKAN TAMPILAN TERWUJUD | Tidak | Tidak berlaku |
| INDEKS ULANG | Tidak | Tidak berlaku |
| RILIS SAVEPOINT | Ya | Tidak ada |
| ROLLBACK | Ya | Tidak ada |
| ROLLBACK DISIAPKAN | Tidak | Tidak berlaku |
| ROLLBACK KE SAVEPOINT | Ya | Tidak ada |
| SAVEPOINT | Ya | Tidak ada |
| SELECT | Ya | Tidak ada |
| PILIH KE DALAM | Ya | Tidak ada |
| MEMPERLIHATKAN | Ya | Tidak ada |
| START TRANSACTION | Ya | Tidak ada |
| TIDAK MENDENGARKAN | Tidak | Tidak ada |
| UPDATE | Ya | [UPDATE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.UPDATE) |
| PERBARUI... DI MANA SAAT INI | Tidak | Tidak berlaku |
| VAKUM | Ya | [VACUUM](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.VACUUM) |
| NILAI | Ya | Tidak ada |
# DMLketerbatasan dan informasi lainnya untuk Aurora SQL Postgre Limitless Database
Topik berikut menjelaskan batasan atau memberikan informasi lebih lanjut untuk DML dan SQL perintah pemrosesan kueri di Aurora SQL Postgre Limitless Database.
**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`Perintah mengumpulkan statistik tentang isi tabel dalam database. Selanjutnya, perencana kueri menggunakan statistik ini untuk membantu menentukan rencana eksekusi yang paling efisien untuk kueri. Untuk informasi lebih lanjut, lihat [ANALYZE](https://www.postgresql.org/docs/current/sql-analyze.html)di dokumentasi PostgreSQL.
Dalam Aurora Postgre SQL Limitless Database, `ANALYZE` perintah mengumpulkan statistik tabel di semua router dan pecahan saat dijalankan.
Untuk mencegah perhitungan statistik pada setiap router selama `ANALYZE` berjalan, statistik tabel dihitung pada salah satu router dan kemudian disalin ke router peer.
## CLUSTER
`CLUSTER`Perintah secara fisik menyusun ulang tabel berdasarkan indeks. Indeks harus sudah ditentukan di atas meja. Dalam Aurora Postgre SQL Limitless Database, pengelompokan bersifat lokal ke bagian indeks yang ada pada setiap pecahan.
Untuk informasi lebih lanjut, lihat [CLUSTER](https://www.postgresql.org/docs/current/sql-cluster.html)di dokumentasi PostgreSQL.
## EXPLAIN
Anda menggunakan parameter berikut untuk mengkonfigurasi output dari `EXPLAIN` perintah:
+ `rds_aurora.limitless_explain_options`— Apa yang harus dimasukkan dalam `EXPLAIN` output. Nilai defaultnya adalah`single_shard_optimization`: apakah paket dioptimalkan dengan pecahan tunggal ditampilkan, tetapi paket pecahan tidak disertakan.
Dalam contoh ini, `EXPLAIN` output tidak menampilkan rencana dari pecahan.
```
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)
```
Sekarang kita mengatur `rds_aurora.limitless_explain_options` untuk memasukkan `shard_plans` dan`single_shard_optimization`. Kita dapat melihat rencana eksekusi pernyataan pada router dan pecahan. Selain itu, kami menonaktifkan `enable_seqscan` parameter untuk menegakkan bahwa pemindaian indeks digunakan pada lapisan pecahan.
```
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)
```
Untuk informasi lebih lanjut tentang `EXPLAIN` perintah, lihat [EXPLAIN](https://www.postgresql.org/docs/current/sql-explain.html)di dokumentasi PostgreSQL.
## INSERT
Sebagian besar `INSERT` perintah didukung di Aurora SQL Postgre Limitless Database.
Postgre SQL tidak memiliki `UPSERT` perintah eksplisit, tetapi mendukung pernyataan. `INSERT ... ON CONFLICT`
`INSERT ... ON CONFLICT`tidak didukung jika tindakan konflik memiliki subquery atau fungsi yang bisa berubah:
```
-- 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.
```
Untuk informasi lebih lanjut tentang `INSERT` perintah, lihat [INSERT](https://www.postgresql.org/docs/current/sql-insert.html)di dokumentasi PostgreSQL.
## UPDATE
Memperbarui kunci shard tidak didukung. Misalnya, Anda memiliki tabel sharded yang disebut`customers`, dengan kunci pecahan. `customer_id` DMLPernyataan berikut menyebabkan kesalahan:
```
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
```
Untuk memperbarui kunci shard, pertama Anda harus `DELETE` baris dengan kunci shard, lalu baris baru `INSERT` dengan nilai kunci shard yang diperbarui.
Untuk informasi selengkapnya tentang `UPDATE` perintah, lihat [Memperbarui data](https://www.postgresql.org/docs/current/dml-update.html) dalam dokumentasi PostgreSQL.
## VACUUM
Anda dapat melakukan penyedot debu pada tabel sharded dan referensi. `VACUUM`Fungsi-fungsi berikut didukung penuh di Aurora SQL Postgre Limitless Database:
+ VACUUM
+ [ANALYZE](#limitless-reference.DML-limitations.ANALYZE)
+ DISABLE\$1PAGE\$1SKIPPING
+ FREEZE
+ FULL
+ INDEX\$1CLEANUP
+ PARALLEL
+ PROCESS\$1TOAST
+ TRUNCATE
+ VERBOSE
`VACUUM`pada Aurora Postgre SQL Limitless Database memiliki batasan sebagai berikut:
+ Ekstensi [pg\$1visibility\$1map](https://www.postgresql.org/docs/current/pgvisibility.html) tidak didukung.
+ Memeriksa indeks yang tidak digunakan dengan tampilan [pg\$1stat\$1all\$1indexes](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ALL-INDEXES-VIEW) tidak didukung.
+ [https://www.postgresql.org/docs/current/catalog-pg-class.html](https://www.postgresql.org/docs/current/catalog-pg-class.html)
Untuk informasi lebih lanjut tentang `VACUUM` perintah, lihat [VACUUM](https://www.postgresql.org/docs/current/sql-vacuum.html)di dokumentasi PostgreSQL. Untuk informasi lebih lanjut tentang cara kerja penyedot debu di Aurora SQL Postgre Limitless Database, lihat. [Merebut kembali ruang penyimpanan dengan menyedot debu](limitless-vacuum.md)
# Variabel dalam Basis Data Tanpa Batas Aurora Postgre SQL
Anda dapat menggunakan variabel berikut untuk mengkonfigurasi Aurora SQL Postgre Limitless Database.
**rds\$1aurora.limitless\$1active\$1shard\$1key**
Menetapkan kunci shard tunggal saat query database, menyebabkan semua `SELECT` dan DML query ditambahkan dengan kunci shard sebagai predikat konstan. Untuk informasi selengkapnya, lihat [Menyetel kunci pecahan aktif](limitless-query.single-shard.md#limitless-query.single-shard.active).
**rds\$1aurora.limitless\$1create\$1table\$1collocate\$1with**
Tetapkan variabel ini ke nama tabel tertentu untuk membentuk tabel yang baru dibuat dengan tabel itu. Untuk informasi selengkapnya, lihat [Membuat tabel tanpa batas dengan menggunakan variabel](limitless-creating-config.md).
**rds\$1aurora.limitless\$1create\$1table\$1mode**
Mengatur mode pembuatan tabel. Untuk informasi selengkapnya, lihat [Membuat tabel tanpa batas dengan menggunakan variabel](limitless-creating-config.md).
**rds\$1aurora.limitless\$1create\$1table\$1shard\$1key**
Atur variabel ini ke array nama kolom untuk digunakan sebagai kunci shard. Untuk informasi selengkapnya, lihat [Membuat tabel tanpa batas dengan menggunakan variabel](limitless-creating-config.md).
**rds\$1aurora.limitless\$1explain\$1options**
Apa yang harus dimasukkan dalam `EXPLAIN` output. Untuk informasi selengkapnya, lihat [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN).
# Parameter cluster DB di Aurora SQL Postgre Limitless Database
Anda dapat menggunakan parameter cluster DB berikut untuk mengkonfigurasi Aurora SQL Postgre Limitless Database.
**rds\$1aurora.limitless\$1adaptive\$1fetch\$1size**
Meningkatkan batch prefetching. Saat disetel ke`true`, parameter ini memungkinkan ukuran pengambilan yang dapat disesuaikan sendiri (adaptif) untuk prefetching. Ketika diatur ke`false`, ukuran fetch konstan.
**rds\$1aurora.limitless\$1auto\$1scale\$1options**
Menetapkan opsi yang tersedia untuk menambahkan router atau memisahkan pecahan dalam grup pecahan DB. Nilainya bisa`add_router`,`split_shard`, atau keduanya.
Untuk informasi selengkapnya, silakan lihat [Menambahkan router ke grup pecahan DB](limitless-add-router.md) dan [Memisahkan pecahan dalam grup pecahan DB](limitless-shard-split.md).
**rds\$1aurora.limitless\$1distributed\$1deadlock\$1timeout**
Jumlah waktu untuk menunggu di kunci sebelum memeriksa apakah ada kondisi kebuntuan yang didistribusikan, dalam milidetik. Defaultnya adalah `1000` (1 detik).
Untuk informasi selengkapnya, lihat [Kebuntuan yang didistribusikan di Aurora SQL Postgre Limitless Database](limitless-query.deadlocks.md).
**rds\$1aurora.limitless\$1enable\$1auto\$1scale**
Memungkinkan penambahan router dan pemisahan pecahan dalam grup pecahan DB.
Untuk informasi selengkapnya, silakan lihat [Menambahkan router ke grup pecahan DB](limitless-add-router.md) dan [Memisahkan pecahan dalam grup pecahan DB](limitless-shard-split.md).
**rds\$1aurora.limitless\$1finalize\$1split\$1shard\$1mode**
Menentukan bagaimana pemisahan pecahan yang diprakarsai sistem diselesaikan. Untuk informasi selengkapnya, lihat [Memisahkan pecahan dalam grup pecahan DB](limitless-shard-split.md).
**rds\$1aurora.limitless\$1maximum\$1adaptive\$1fetch\$1size**
Menetapkan batas atas untuk ukuran pengambilan adaptif. Kisarannya adalah `1` -`INT_MAX`. Default-nya adalah `1000`.