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.
Topik
ALTER TABLE
ALTER TABLE
Perintah ini umumnya didukung di Aurora PostgreSQL Limitless Database. Untuk informasi selengkapnya, lihat ALTER TABLE dalam dokumentasi
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, lihatBatasan.
- Mengubah nilai default kolom
-
Nilai default didukung. Untuk informasi selengkapnya, lihat Nilai default.
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
ONtable_name
(column_name
);
CREATE UNIQUE INDEX
didukung untuk semua jenis tabel:
CREATE UNIQUE INDEX
index_name
ONtable_name
(column_name
);
CREATE UNIQUE INDEX CONCURRENTLY
tidak didukung:
CREATE UNIQUE INDEX CONCURRENTLY
index_name
ONtable_name
(column_name
);
Untuk informasi selengkapnya, lihat UNIK. Untuk informasi umum tentang membuat indeks, lihat CREATE INDEX dalam dokumentasi
- Menampilkan indeks
-
Tidak semua indeks terlihat pada router saat Anda menggunakan
\d
atau perintah serupa. Sebagai gantinya, gunakantable_name
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);
BUAT TABEL SEBAGAI
Untuk membuat tabel menggunakanCREATE 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.
-- 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
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 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.
-- 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
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.
- 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, lihatMembuat tabel Basis Data Tanpa Batas Aurora Postgre SQL.
-
- 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
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
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, silakan lihat dan Mengekspor data dari .
-
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_buffercache di Aurora PostgreSQL Limitless Database. -
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. -
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_preload_libraries
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_stat_statementpg_stat_statements
, lihat limitless_stat_statement.
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 ] [ SCHEMAschema_name
] [ VERSIONversion
] [ CASCADE ]Untuk informasi selengkapnya, lihat CREATE EXTENSION
di dokumentasi PostgreSQL. - ALTER EXTENSION
-
Berikut ini DDLs didukung:
ALTER EXTENSION
name
UPDATE [ TOnew_version
] ALTER EXTENSIONname
SET SCHEMAnew_schema
Untuk informasi selengkapnya, lihat ALTER EXTENSION dalam dokumentasi
PostgreSQL. - DROP EXTENSION
-
Anda dapat menjatuhkan ekstensi, seperti di PostgreSQL.
DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
Untuk informasi selengkapnya, lihat DROP EXTENSION
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
ADDmember_object
ALTER EXTENSIONname
DROPmember_object
perbedaan pg_buffercache di Aurora PostgreSQL Limitless Database
Di Aurora PostgreSQL Limitless Database, ketika Anda menginstal ekstensi pg_buffercache dan menggunakan pg_buffercache
tampilan, Anda menerima informasi terkait bufferpg_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 daripg_buffercache
. -
relname
— Alih-alih menampilkan nomor node file seperti dalampg_buffercache
,limitless_pg_buffercache
menyajikan yang terkaitrelname
jika tersedia dalam database saat ini atau katalog sistem bersama, jika tidak.NULL
-
parent_relname
- Kolom baru ini, tidak ada dipg_buffercache
, menampilkan indukrelname
jika nilai dalamrelname
kolom mewakili tabel yang dipartisi (dalam kasus tabel sharded). Jika tidak, itu akan ditampilkanNULL
. -
spcname
— Alih-alih menampilkan pengenal objek tablespace (OID) seperti padapg_buffercache
,limitless_pg_buffercache
menampilkan nama tablespace. -
datname
— Alih-alih menampilkan database OID seperti dalampg_buffercache
,limitless_pg_buffercache
menampilkan nama database. -
relforknumber
- Tetap tidak berubah daripg_buffercache
. -
relblocknumber
- Tetap tidak berubah daripg_buffercache
. -
isdirty
- Tetap tidak berubah daripg_buffercache
. -
usagecount
- Tetap tidak berubah daripg_buffercache
. -
pinning_backends
- Tetap tidak berubah daripg_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
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 denganpgstatindex
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_approx 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
denganFOREIGN KEY
didukung hanya untuk tabel standar. Untuk membuat tabel sharded atau referensi denganFOREIGN 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.
-
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 |
---|---|---|---|---|
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Tidak | Tidak | Tidak | Tidak |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Tidak | Tidak | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Tidak | Tidak | Tidak | Tidak |
|
Ya | Tidak | Tidak | Ya |
|
Tidak | Tidak | Tidak | Ya |
|
Ya | Ya | Ya | Ya |
|
Ya | Ya | Ya | Ya |
|
Tidak | Tidak | Tidak | Tidak |
|
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
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
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
dalam dokumentasi PostgreSQL.
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:
-
Fungsi yang akan didistribusikan. Sebutkan hanya argumen masukan, dan bukan argumen keluaran apa pun.function_prototype
Jika salah satu argumen didefinisikan sebagai
OUT
parameter, jangan sertakan tipenya dalam argumenfunction_prototype
. -
ARRAY['
— Daftar argumen fungsi yang diidentifikasi sebagai kunci shard untuk fungsi tersebut.shard_key
'] -
— Tabel sharded yang berisi rentang data pada pecahan target.collocating_table
Untuk mengidentifikasi pecahan tempat menekan fungsi ini untuk berjalan, sistem mengambil ARRAY['
argumen, melakukan hash, dan menemukan pecahan dari yang menampung rentang shard_key
']
yang berisi nilai hash ini.collocating_table
- 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 shardedcustomers
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
danOUT
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_proc.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 gunakanv
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 sebagaiIMMUTABLE
. 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
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
Topik
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
danmaxvalue
), 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, danSELECT * FROM
pernyataan semuanya hanya menampilkan status urutan lokal, bukan status terdistribusi.sequence_name
-
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 filechunk_size
. (Setiap router memiliki dua potongan.) -
CACHE
Opsi ini didukung, tetapi cache harus lebih kecil darichunk_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 Urutandalam dokumentasi PostgreSQL. - BUAT URUTAN
-
Opsi berikut tidak didukung.
CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE [[ NO ] CYCLE]
Untuk informasi selengkapnya, lihat CREATE SEQUENCE
dalam dokumentasi PostgreSQL. - MENGUBAH URUTAN
-
Opsi berikut tidak didukung.
ALTER SEQUENCE [[ NO ] CYCLE]
Untuk informasi selengkapnya, lihat ALTER SEQUENCE
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_aurora.limitless_distributed_sequence
-
Tampilan ini menunjukkan status urutan terdistribusi dan konfigurasi.
cache
Kolomminvalue
maxvalue
start
,inc
,, dan memiliki arti yang sama seperti pada tampilan pg_sequences, 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_aurora.limitless_sequence_metadata
-
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
, danLWlock: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 darinextval
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_chunk 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.
