Limitazioni DDL e altre informazioni per Aurora PostgreSQL Limitless Database

Per i dettagli sulle opzioni non supportate, consulta Vincoli.

I valori predefiniti sono supportati. Per ulteriori informazioni, consulta Valori predefiniti.

Non tutti gli indici sono visibili sui router quando utilizzi \d table_name o comandi simili. In alternativa, utilizza la vista pg_catalog.pg_indexes per ottenere gli indici, come mostrato nell’esempio seguente.

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)

Sono supportati vincoli semplici che coinvolgono operatori di confronto con valori letterali. Le espressioni e i vincoli più complessi che richiedono convalide delle funzioni non sono supportati, come illustrato negli esempi seguenti.

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"
);

Puoi assegnare nomi espliciti ai vincoli, come illustrato nell’esempio seguente.

CREATE TABLE my_table (
    id  INT CONSTRAINT positive_id  CHECK (id > 0)
  , val INT CONSTRAINT val_in_range CHECK (val > 0 AND val < 1000)
);

Puoi utilizzare la sintassi dei vincoli a livello di tabella con il vincolo CHECK, come illustrato nell’esempio seguente.

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

I vincoli di esclusione non sono supportati in Aurora PostgreSQL Limitless Database.

Per ulteriori informazioni, consulta Chiavi esterne.

I vincoli NOT NULL non sono supportati senza restrizioni.

La chiave primaria implica vincoli univoci e pertanto si applicano le stesse restrizioni sui vincoli unici alla chiave primaria. Ciò significa che:

Negli esempi seguenti viene illustrato l’uso delle chiavi primarie.

-- 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']);

Tentativo di aggiungere una chiave primaria che non contiene una chiave shard:

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

Tentativo di aggiungere una chiave primaria che contiene una chiave shard:

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

Conversione di una tabella standard in tabella di riferimento.

-- 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');

Per ulteriori informazioni sulla creazione di tabelle sottoposte a sharding e di riferimento, consulta Creazione di tabelle di Aurora PostgreSQL Limitless Database.

Nelle tabelle sottoposte a sharding, la chiave univoca deve contenere la chiave shard, ovvero la chiave shard deve essere un sottoinsieme della chiave univoca. Questa condizione viene verificata durante la conversione del tipo di tabella in sottoposta a sharding. Nelle tabelle di riferimento non sono presenti restrizioni.

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT UNIQUE
);

I vincoli UNIQUE a livello di tabella sono supportati, come illustrato nell’esempio seguente.

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT
  , CONSTRAINT zipcode_and_email UNIQUE (zipcode, email)
);

L’esempio seguente mostra l’uso combinato di una chiave primaria e una chiave univoca. Entrambe le chiavi devono includere la chiave 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)
);

Puoi creare estensioni, come in PostgreSQL.

CREATE EXTENSION [ IF NOT EXISTS ] extension_name
    [ WITH ] [ SCHEMA schema_name ]
             [ VERSION version ]
             [ CASCADE ]

Per ulteriori informazioni, consulta CREATE EXTENSION nella documentazione di PostgreSQL.

Le seguenti istruzioni DDL sono supportate:

ALTER EXTENSION name UPDATE [ TO new_version ]

ALTER EXTENSION name SET SCHEMA new_schema

Per ulteriori informazioni, consulta ALTER EXTENSION nella documentazione di PostgreSQL.

Puoi rimuovere le estensioni, come in PostgreSQL.

DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

Per ulteriori informazioni, consulta DROP EXTENSION nella documentazione di PostgreSQL.

Non puoi aggiungere o rimuovere oggetti membri delle estensioni.

ALTER EXTENSION name ADD member_object

ALTER EXTENSION name DROP member_object

rds_aurora.limitless_pgstattuple(relation_name)

rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)

rds_aurora.limitless_pgstatindex(relation_name)

rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstatginindex(relation_name)

rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstathashindex(relation_name)

rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)

rds_aurora.limitless_pg_relpages(relation_name)

rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)

rds_aurora.limitless_pgstattuple_approx(relation_name)

rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)

Puoi creare funzioni, come in Aurora PostgreSQL, con l’eccezione di modificarne la volatilità durante la sostituzione.

Per ulteriori informazioni, consulta CREATE FUNCTION nella documentazione di PostgreSQL.

Puoi creare funzioni, come in Aurora PostgreSQL, con l’eccezione di modificarne la volatilità.

Per ulteriori informazioni, consulta ALTER FUNCTION nella documentazione di PostgreSQL.

Puoi rimuovere le funzioni, come in Aurora PostgreSQL.

DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
    [ CASCADE | RESTRICT ]

Per ulteriori informazioni, consulta DROP FUNCTION nella documentazione di PostgreSQL.

Quando distribuisci una funzione o una procedura, questa opera solo sui dati delimitati dall’intervallo di chiavi shard in tale shard. Se la funzione o la procedura tenta di accedere ai dati da un altro shard, i risultati restituiti dalla funzione o dalla procedura distribuita saranno diversi rispetto a una funzione non distribuita.

Ad esempio, crea una funzione contenente query che interessano più shard, ma poi chiama la procedura rds_aurora.limitless_distribute_function per distribuirla. Quando invochi questa funzione fornendo argomenti per una chiave shard, è probabile che i risultati della sua esecuzione siano limitati dai valori presenti in tale shard. Questi risultati sono diversi da quelli prodotti senza distribuire la funzione.

Considera la seguente funzione func con la tabella sottoposta a sharding customers con la chiave 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;
    $$;

Ora distribuiamo questa funzione:

SELECT rds_aurora.limitless_distribute_function('func(integer, integer)', ARRAY['c_id'], 'customers');

Di seguito è riportato un esempio di piani di 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)

L’esempio seguente mostra una procedura con parametri IN e OUT come argomenti.

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;

L’esempio seguente distribuisce la procedura utilizzando solo i parametri IN.

EXPLAIN(costs false, verbose true) SELECT * FROM get_data(1);

             QUERY PLAN
 -----------------------------------
  Foreign Scan
    Output: id
    Remote SQL:  SELECT customer_id
     FROM get_data(1) get_data(id)
  Single Shard Optimized
 (6 rows)

La funzione setval non è supportata. Per ulteriori informazioni, consulta Sequence Manipulation Functions nella documentazione di PostgreSQL.

Le seguenti opzioni non sono supportate.

CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
    [[ NO ] CYCLE]

Per ulteriori informazioni, consulta CREATE SEQUENCE nella documentazione di PostgreSQL.

Le seguenti opzioni non sono supportate.

ALTER SEQUENCE
    [[ NO ] CYCLE]

Per ulteriori informazioni, consulta ALTER SEQUENCE nella documentazione di PostgreSQL.

Il comando ALTER TABLE non è supportato per le sequenze.

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

postgres_limitless=> CREATE SEQUENCE s;
CREATE SEQUENCE

postgres_limitless=> ALTER SEQUENCE s RESTART 500;
ALTER SEQUENCE

postgres_limitless=> SELECT nextval('s');

 nextval
---------
     500
(1 row)

postgres_limitless=> SELECT currval('s');

 currval
---------
     500
(1 row)

postgres=# CREATE TABLE t(a bigint primary key, b bigint);
CREATE TABLE

postgres=# CREATE SEQUENCE s minvalue 0 START 0;
CREATE SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));
INSERT 0 1

postgres=# SELECT * FROM t;

 a | b
---+---
 0 | 0
 1 | 1
(2 rows)

postgres=# ALTER SEQUENCE s RESTART 10000;
ALTER SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# SELECT * FROM t;

   a   |   b
-------+-------
     0 |     0
     1 |     1
 10000 | 10000
(3 rows)

Questa vista mostra lo stato e la configurazione della sequenza distribuita. Le colonne minvalue, maxvalue, start, inc e cache hanno lo stesso significato della vista pg_sequences e mostrano le opzioni con cui è stata creata la sequenza. La colonna lastval mostra l’ultimo valore allocato o riservato in un oggetto di sequenza distribuita. Ciò non significa che il valore sia già stato utilizzato, poiché i router mantengono localmente i blocchi di sequenza.

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)

Questa vista mostra i metadati della sequenza distribuita e aggrega i metadati della sequenza dai nodi del cluster. Usa le seguenti colonne:

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)

Se la dimensione del blocco non è sufficientemente grande e il tasso di transazione è elevato, i worker in background potrebbero non avere tempo sufficiente per richiedere nuovi blocchi prima che i blocchi attivi siano esauriti. Questo può causare eventi di contesa e attesa come LIMITLESS:AuroraLimitlessSequenceReplace, LWLock:LockManager, Lockrelation e LWlock:bufferscontent.

Aumenta il valore del parametro rds_aurora.limitless_sequence_chunk_size.

In PostgreSQL, la memorizzazione nella cache delle sequenze avviene a livello di sessione. Ogni sessione alloca valori di sequenza successivi durante un accesso all’oggetto di sequenza e aumenta di conseguenza quelli dell’oggetto di sequenza di last_value. Quindi, gli usi successivi di nextval nella stessa sessione restituiscono semplicemente i valori preallocati senza interessare l’oggetto di sequenza.

Tutti i numeri allocati ma non utilizzati all’interno di una sessione vengono persi al termine di tale sessione, con conseguenti “buchi” nella sequenza. Ciò può consumare rapidamente sequence_chunk e causare eventi di contesa e attesa come LIMITLESS:AuroraLimitlessSequenceReplace, LWLock:LockManager, Lockrelation e LWlock:bufferscontent.

Riduci l’impostazione della cache della sequenza.