Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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)