Limitazioni DDL e altre informazioni per Aurora PostgreSQL Limitless Database

Per informazioni dettagliate su ciò che non è supportato, consulta. Vincoli

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

Non tutti gli indici sono visibili sui router quando si utilizzano comandi simili. \d table_name Utilizzate invece la pg_catalog.pg_indexes vista per ottenere gli indici, come illustrato 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 semplici vincoli che coinvolgono operatori di confronto con valori letterali. Le espressioni e i vincoli più complessi che richiedono la convalida 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"
);

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

È possibile utilizzare la sintassi dei vincoli a livello di tabella con il vincolo, come illustrato nell'esempio seguenteCHECK.

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.

NOT NULLi vincoli sono supportati senza restrizioni.

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

Gli esempi seguenti illustrano 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']);

Sto cercando di aggiungere una chiave primaria che non contenga 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

Cercando di aggiungere una chiave primaria che contenga 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

Trasforma una tabella standard in una 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 frammentate e di riferimento, vedereCreazione di tabelle del database Aurora SQL Postgre Limitless.

Nelle tabelle suddivise, la chiave univoca deve contenere la chiave shard, ovvero la chiave shard deve essere un sottoinsieme della chiave univoca. Questo viene controllato quando si cambia il tipo di tabella in sharded. Nelle tabelle di riferimento non ci sono restrizioni.

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

I UNIQUE vincoli 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 congiunto di una chiave primaria e di 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)
);

È possibile 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.

Sono supportati: DDLs

ALTER EXTENSION name UPDATE [ TO new_version ]

ALTER EXTENSION name SET SCHEMA new_schema

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

Puoi eliminare 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 eliminare oggetti membri dalle 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)

È possibile creare funzioni, come in Aurora PostgreSQL, con l'eccezione di modificarne la volatilità sostituendole.

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

È possibile modificare le funzioni, come in Aurora PostgreSQL, ad eccezione della modifica della loro volatilità.

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

È possibile eliminare le funzioni, come in Aurora PostgreSQL.

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

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

Quando distribuite una funzione o una procedura, questa tratta solo i dati delimitati dall'intervallo di chiavi dello shard in quel frammento. Nei casi in cui 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 quelli non distribuiti.

Ad esempio, create una funzione contenente interrogazioni che toccheranno più shard, ma poi chiamate la rds_aurora.limitless_distribute_function procedura per distribuirla. Quando si richiama 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.

Consideriamo la seguente funzione func in cui abbiamo la tabella condivisa customers con il tasto 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 sono riportati alcuni esempi di piani di interrogazione.

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 OUT parametri IN e parametri 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 IN parametri.

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 non è supportata. setval Per ulteriori informazioni, consulta Funzioni di manipolazione delle sequenze nella documentazione di PostgreSQL.

Le seguenti opzioni non sono supportate.

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

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

Le seguenti opzioni non sono supportate.

ALTER SEQUENCE
    [[ NO ] CYCLE]

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

Il ALTER TABLE comando 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 distribuiti. Le cache colonne minvaluemaxvalue,start,inc, e hanno lo stesso significato della vista pg_sequences e mostrano le opzioni con cui è stata creata la sequenza. La lastval colonna mostra l'ultimo valore allocato o riservato in un oggetto di sequenza distribuito. 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 di sequenza distribuiti e aggrega i metadati di sequenza dai nodi del cluster. Utilizza 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 lavoratori in background potrebbero non avere abbastanza tempo per richiedere nuovi blocchi prima che i blocchi attivi siano esauriti. Ciò può portare a situazioni di contesa e attesa come,, e. LIMITLESS:AuroraLimitlessSequenceReplace LWLock:LockManager Lockrelation LWlock:bufferscontent

Incrementa 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 assegna valori di sequenza successivi durante un accesso all'oggetto sequenza e aumenta di conseguenza quelli dell'oggetto sequenza. last_value Quindi, gli usi nextval successivi di quella sessione restituiscono semplicemente i valori preallocati senza toccare l'oggetto della sequenza.

Tutti i numeri assegnati 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 portare a eventi di contesa e attesa come,, e. LIMITLESS:AuroraLimitlessSequenceReplace LWLock:LockManager Lockrelation LWlock:bufferscontent

Riduci l'impostazione della cache della sequenza.