Keterbatasan DDL dan informasi lainnya untuk Aurora PostgreSQL Limitless Database - Amazon Aurora

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.

ALTER TABLE

ALTER TABLEPerintah ini umumnya didukung di Aurora PostgreSQL Limitless Database. Untuk informasi selengkapnya, lihat ALTER TABLE dalam dokumentasi PostgreSQL.

Batasan

ALTER TABLEmemiliki 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
  • USINGEkspresi 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

  • ONLYbendera

  • 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 CONCURRENTLYdidukung untuk tabel sharded:

CREATE INDEX CONCURRENTLY index_name ON table_name(column_name);

CREATE UNIQUE INDEXdidukung untuk semua jenis tabel:

CREATE UNIQUE INDEX index_name ON table_name(column_name);

CREATE UNIQUE INDEX CONCURRENTLYtidak didukung:

CREATE UNIQUE INDEX CONCURRENTLY index_name ON table_name(column_name);

Untuk informasi selengkapnya, lihat UNIK. Untuk informasi umum tentang membuat indeks, lihat CREATE INDEX dalam dokumentasi 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 SCHEMAdengan 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);

IDENTITYkolom 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 AStidak menyebarkan kunci utama ke tabel baru.

Untuk informasi umum, lihat MEMBUAT TABEL AS dalam dokumentasi PostgreSQL.

DROP DATABASE

Anda dapat menjatuhkan database yang telah Anda buat.

DROP DATABASEPerintah 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 INTOsecara 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 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.

TIDAK NULL

NOT NULLkendala 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 );

UNIQUEKendala 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 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, 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 (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_stat_statement. Untuk informasi tentang penginstalanpg_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 ] [ SCHEMA schema_name ] [ VERSION version ] [ CASCADE ]

Untuk informasi selengkapnya, lihat CREATE EXTENSION 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 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 ADD member_object ALTER EXTENSION name DROP member_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 buffer 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 daripg_buffercache.

  • relname— Alih-alih menampilkan nomor node file seperti dalampg_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 dipg_buffercache, menampilkan induk relname jika nilai dalam relname 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 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 (kecualiroot_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_levelKolom 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 TABLEdengan FOREIGN 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

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 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:

  • function_prototypeFungsi 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 argumenfunction_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_proc. provolatileNilai 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 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 dalam dokumentasi PostgreSQL.

Urutan

Urutan bernama adalah objek database yang menghasilkan angka unik dalam urutan naik atau turun. CREATE SEQUENCEmembuat 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 PostgreSQL.

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_sequenceKatalog, 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 filechunk_size. (Setiap router memiliki dua potongan.)

  • CACHEOpsi 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

setvalFungsi ini tidak didukung. Untuk informasi selengkapnya, lihat Fungsi Manipulasi Urutan dalam 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 TABLEPerintah 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. cacheKolom minvalue maxvaluestart,inc,, dan memiliki arti yang sama seperti pada tampilan pg_sequences, dan menampilkan opsi yang dengannya urutan dibuat. lastvalKolom 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 sepertiLIMITLESS:AuroraLimitlessSequenceReplace,, LWLock:LockManagerLockrelation, 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 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_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.

Tunggu peristiwa yang disebabkan oleh masalah urutan.