Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Riferimento ad Aurora PostgreSQL Limitless Database
Forniamo i seguenti argomenti di riferimento per Aurora PostgreSQL Limitless Database.
**Topics**
+ [Comandi SQL DDL (Data Definition Language) supportati e non supportati](limitless-reference.DDL-support.md)
+ [Limitazioni DDL e altre informazioni per Aurora PostgreSQL Limitless Database](limitless-reference.DDL-limitations.md)
+ [Comandi SQL supportati e non supportati per Data Manipulation Language (DML) e per l’elaborazione delle query](limitless-reference.DML-support.md)
+ [Limitazioni DML e altre informazioni per Aurora PostgreSQL Limitless Database](limitless-reference.DML-limitations.md)
+ [Variabili in Aurora PostgreSQL Limitless Database](limitless-reference.variables.md)
+ [Parametri del cluster di database in Aurora PostgreSQL Limitless Database](limitless-reference.DBCparams.md)
# Comandi SQL DDL (Data Definition Language) supportati e non supportati
La tabella seguente elenca i comandi DDL supportati e non supportati da Aurora PostgreSQL Limitless Database, con riferimenti a limitazioni o ulteriori informazioni.
| Comando | Supportato? | Limitazioni o ulteriori informazioni |
| --- | --- | --- |
| ALTER AGGREGATE | No | Non applicabile |
| ALTER COLLATION | Sì | Nessuno |
| ALTER CONVERSION | Sì | Nessuno |
| ALTER DATABASE | No | Non applicabile |
| ALTER DEFAULT PRIVILEGES | No | Non applicabile |
| ALTER DOMAIN | No | Non applicabile |
| ALTER EVENT TRIGGER | No | Non applicabile |
| ALTER EXTENSION | Sì | [Estensioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| ALTER FOREIGN DATA WRAPPER | No | Non applicabile |
| ALTER FOREIGN TABLE | No | Non applicabile |
| ALTER FUNCTION | Sì | [Funzioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| ALTER GROUP | Sì | Nessuno |
| ALTER INDEX | Sì | Nessuno |
| ALTER LANGUAGE | No | Non applicabile |
| ALTER LARGE OBJECT | No | Non applicabile |
| ALTER MATERIALIZED VIEW | No | Non applicabile |
| ALTER OPERATOR | Sì | Nessuno |
| ALTER OPERATOR CLASS | Sì | Nessuno |
| ALTER OPERATOR FAMILY | Sì | Nessuno |
| ALTER POLICY | No | Non applicabile |
| ALTER PROCEDURE | Sì | Nessuno |
| ALTER PUBLICATION | No | Non applicabile |
| ALTER ROLE | Sì | Nessuno |
| ALTER ROUTINE | No | Non applicabile |
| ALTER RULE | No | Non applicabile |
| ALTER SCHEMA | Sì | Nessuno |
| ALTER SEQUENCE | Sì | [Sequenze](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| ALTER SERVER | No | Non applicabile |
| ALTER STATISTICS | No | Non applicabile |
| ALTER SUBSCRIPTION | No | Non applicabile |
| ALTER SYSTEM | No | Non applicabile |
| ALTER TABLE | Sì | [ALTER TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.ALTER_TABLE) |
| ALTER TABLESPACE | No | Non applicabile |
| ALTER TEXT SEARCH CONFIGURATION | No | Non applicabile |
| ALTER TEXT SEARCH DICTIONARY | No | Non applicabile |
| ALTER TEXT SEARCH PARSER | No | Non applicabile |
| ALTER TEXT SEARCH TEMPLATE | No | Non applicabile |
| ALTER TRIGGER | No | Non applicabile |
| ALTER TYPE | Sì | Nessuno |
| ALTER USER | Sì | Nessuno |
| ALTER USER MAPPING | No | Non applicabile |
| ALTER VIEW | Sì | Nessuno |
| COMMENT | No | Non applicabile |
| CREATE ACCESS METHOD | No | Non applicabile |
| CREATE AGGREGATE | No | Non applicabile |
| CREATE CAST | Sì | Nessuno |
| CREATE COLLATION | Sì | Nessuno |
| CREATE CONVERSION | Sì | Nessuno |
| CREATE DATABASE | Sì | [CREATE DATABASE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_DATABASE) |
| CREATE DOMAIN | No | Non applicabile |
| CREATE EVENT TRIGGER | No | Non applicabile |
| CREATE EXTENSION | Sì | [Estensioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| CREATE FOREIGN DATA WRAPPER | No | Non applicabile |
| CREATE FOREIGN TABLE | No | Non applicabile |
| CREATE FUNCTION | Sì | [Funzioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| CREATE GROUP | Sì | Nessuno |
| CREATE INDEX | Sì | [CREATE INDEX](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_INDEX) |
| CREATE LANGUAGE | No | Non applicabile |
| CREATE MATERIALIZED VIEW | No | Non applicabile |
| CREATE OPERATOR | Sì | Nessuno |
| CREATE OPERATOR CLASS | Sì | Nessuno |
| CREATE OPERATOR FAMILY | Sì | Nessuno |
| CREATE POLICY | Sì | Nessuno |
| CREATE PROCEDURE | Sì | Nessuno |
| CREATE PUBLICATION | No | Non applicabile |
| CREATE ROLE | Sì | Nessuno |
| CREATE RULE | No | Non applicabile |
| CREATE SCHEMA | Sì | [CREATE SCHEMA](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_SCHEMA) |
| CREATE SEQUENCE | Sì | [Sequenze](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Sequences) |
| CREATE SERVER | No | Non applicabile |
| CREATE STATISTICS | No | Non applicabile |
| CREATE SUBSCRIPTION | No | Non applicabile |
| CREATE TABLE | Sì | [CREATE TABLE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE) |
| CREATE TABLE AS | Sì | [CREATE TABLE AS](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.CREATE_TABLE_AS) |
| CREATE TABLESPACE | No | Non applicabile |
| CREATE TEMPORARY TABLE | No | Non applicabile |
| CREATE TEMPORARY TABLE AS | No | Non applicabile |
| CREATE TEXT SEARCH CONFIGURATION | No | Non applicabile |
| CREATE TEXT SEARCH DICTIONARY | No | Non applicabile |
| CREATE TEXT SEARCH PARSER | No | Non applicabile |
| CREATE TEXT SEARCH TEMPLATE | No | Non applicabile |
| CREATE TRANSFORM | No | Non applicabile |
| CREATE TRIGGER | No | Non applicabile |
| CREATE TYPE | Sì | Nessuno |
| CREA UTENTE | Sì | Nessuno |
| CREATE USER MAPPING | No | Non applicabile |
| CREATE VIEW | Sì | Nessuno |
| DROP ACCESS METHOD | No | Non applicabile |
| DROP AGGREGATE | Sì | Nessuno |
| DROP CAST | Sì | Nessuno |
| DROP COLLATION | Sì | Nessuno |
| DROP CONVERSION | Sì | Nessuno |
| DROP DATABASE | Sì | [DROP DATABASE](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.DROP_DATABASE) |
| DROP DOMAIN | No | Non applicabile |
| DROP EVENT TRIGGER | No | Non applicabile |
| DROP EXTENSION | Sì | [Estensioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Extensions) |
| DROP FOREIGN DATA WRAPPER | No | Non applicabile |
| DROP FOREIGN TABLE | No | Non applicabile |
| DROP FUNCTION | Sì | [Funzioni](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Functions) |
| DROP GROUP | Sì | Nessuno |
| DROP INDEX | Sì | Nessuno |
| DROP LANGUAGE | No | Non applicabile |
| DROP MATERIALIZED VIEW | No | Non applicabile |
| DROP OPERATOR | Sì | Nessuno |
| DROP OPERATOR CLASS | Sì | Nessuno |
| DROP OPERATOR FAMILY | Sì | Nessuno |
| DROP OWNED | No | Non applicabile |
| DROP POLICY | No | Non applicabile |
| DROP PROCEDURE | Sì | Nessuno |
| DROP PUBLICATION | No | Non applicabile |
| DROP ROLE | Sì | Nessuno |
| DROP ROUTINE | No | Non applicabile |
| DROP RULE | No | Non applicabile |
| DROP SCHEMA | Sì | Nessuno |
| DROP SEQUENCE | Sì | Nessuno |
| DROP SERVER | No | Non applicabile |
| DROP STATISTICS | No | Non applicabile |
| DROP SUBSCRIPTION | No | Nessuno |
| DROP TABLE | Sì | Nessuno |
| DROP TABLESPACE | No | Non applicabile |
| DROP TEXT SEARCH CONFIGURATION | No | Non applicabile |
| DROP TEXT SEARCH DICTIONARY | No | Non applicabile |
| DROP TEXT SEARCH PARSER | No | Non applicabile |
| DROP TEXT SEARCH TEMPLATE | No | Non applicabile |
| DROP TRANSFORM | No | Non applicabile |
| DROP TRIGGER | No | Non applicabile |
| DROP TYPE | Sì | Nessuno |
| DROP USER | Sì | Nessuno |
| DROP USER MAPPING | No | Non applicabile |
| DROP VIEW | Sì | Nessuno |
| GRANT | Sì | Nessuno |
| REASSIGN OWNED | No | Non applicabile |
| REVOKE | Sì | Nessuno |
| SECURITY LABEL | No | Non applicabile |
| SELECT INTO | Sì | [SELECT INTO](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.SELECT_INTO) |
| SET | Sì | Nessuno |
| SET CONSTRAINTS | No | Non applicabile |
| SET ROLE | Sì | Nessuno |
| SET SESSION AUTHORIZATION | Sì | Nessuno |
| SET TRANSACTION | Sì | Nessuno |
| TRUNCATE | Sì | Nessuno |
# Limitazioni DDL e altre informazioni per Aurora PostgreSQL Limitless Database
I seguenti argomenti descrivono le limitazioni o forniscono ulteriori informazioni per i comandi SQL DDL in Aurora PostgreSQL Limitless Database.
**Topics**
+ [ALTER TABLE](#limitless-reference.DDL-limitations.ALTER_TABLE)
+ [CREATE DATABASE](#limitless-reference.DDL-limitations.CREATE_DATABASE)
+ [CREATE INDEX](#limitless-reference.DDL-limitations.CREATE_INDEX)
+ [CREATE SCHEMA](#limitless-reference.DDL-limitations.CREATE_SCHEMA)
+ [CREATE TABLE](#limitless-reference.DDL-limitations.CREATE_TABLE)
+ [CREATE TABLE AS](#limitless-reference.DDL-limitations.CREATE_TABLE_AS)
+ [DROP DATABASE](#limitless-reference.DDL-limitations.DROP_DATABASE)
+ [SELECT INTO](#limitless-reference.DDL-limitations.SELECT_INTO)
+ [Vincoli](#limitless-reference.DDL-limitations.Constraints)
+ [Valori predefiniti](#limitless-reference.DDL-limitations.DefaultValues)
+ [Estensioni](#limitless-reference.DDL-limitations.Extensions)
+ [Chiavi esterne](#limitless-reference.DDL-limitations.FKs)
+ [Funzioni](#limitless-reference.DDL-limitations.Functions)
+ [Sequenze](#limitless-reference.DDL-limitations.Sequences)
## ALTER TABLE
Il comando `ALTER TABLE` è generalmente supportato in Aurora PostgreSQL Limitless Database. Per ulteriori informazioni, consulta [ALTER TABLE](https://www.postgresql.org/docs/current/sql-altertable.html) nella documentazione di PostgreSQL.
### Limitazioni
`ALTER TABLE` presenta le seguenti limitazioni per le opzioni supportate.
**Rimozione di una colonna**
+ Nelle tabelle sottoposte a sharding, non puoi rimuovere le colonne che fanno parte della chiave shard.
+ Nelle tabelle di riferimento, non puoi rimuovere le colonne che fanno parte della chiave primaria.
**Modifica del tipo di dati di una colonna**
+ L’espressione `USING` non è supportata.
+ Nelle tabelle sottoposte a sharding, non puoi modificare il tipo delle colonne che fanno parte della chiave shard.
**Aggiunta o rimozione di un vincolo**
Per i dettagli sulle opzioni non supportate, consulta [Vincoli](#limitless-reference.DDL-limitations.Constraints).
**Modifica del valore predefinito di una colonna**
I valori predefiniti sono supportati. Per ulteriori informazioni, consulta [Valori predefiniti](#limitless-reference.DDL-limitations.DefaultValues).
### Opzioni non supportate
Alcune opzioni non sono supportate perché dipendono da funzionalità non disponibili, come i trigger.
Le seguenti opzioni a livello di tabella per `ALTER TABLE` non sono supportate:
+ `ALL IN TABLESPACE`
+ `ATTACH PARTITION`
+ `DETACH PARTITION`
+ Flag `ONLY`
+ `RENAME CONSTRAINT`
Le seguenti opzioni a livello di colonna per `ALTER TABLE` non sono supportate:
+ ADD GENERATED
+ DROP EXPRESSION [ IF EXISTS ]
+ DROP IDENTITY [ IF EXISTS ]
+ RESET
+ RESTART
+ SET
+ SET COMPRESSION
+ SET STATISTICS
## CREATE DATABASE
In Aurora PostgreSQL Limitless Database sono supportati solo Limitless Database.
Durante l’esecuzione di `CREATE DATABASE`, i database creati correttamente in uno o più nodi potrebbero non riuscire a essere creati negli altri nodi, poiché la creazione del database è un’operazione non transazionale. In questo caso, gli oggetti del database creati correttamente vengono rimossi automaticamente da tutti i nodi entro un periodo di tempo predeterminato per mantenere la coerenza nel gruppo shard database. Durante questo intervallo di tempo, un nuovo tentativo di creazione di un database con lo stesso nome potrebbe generare un errore che indica che il database esiste già.
Sono supportate le seguenti opzioni:
+ Regola di confronto:
```
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;
```
Le seguenti opzioni non sono supportate:
+ `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` è supportata per le tabelle sottoposte a sharding:
```
CREATE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX` è supportata per tutti i tipi di tabella:
```
CREATE UNIQUE INDEX index_name ON table_name(column_name);
```
`CREATE UNIQUE INDEX CONCURRENTLY` non è supportata:
```
CREATE UNIQUE INDEX CONCURRENTLY index_name ON table_name(column_name);
```
Per ulteriori informazioni, consulta [UNIQUE](#unique-constraint). Per informazioni generali sulla creazione di indici, consulta [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html) nella documentazione di PostgreSQL.
**Visualizzazione degli indici**
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)
```
## CREATE SCHEMA
`CREATE SCHEMA` con un elemento dello schema non è supportato:
```
CREATE SCHEMA my_schema CREATE TABLE (column_name INT);
```
Questa opzione genera un errore simile al seguente:
```
ERROR: CREATE SCHEMA with schema elements is not supported
```
## CREATE TABLE
Le relazioni nelle istruzioni `CREATE TABLE` non sono supportate, ad esempio:
```
CREATE TABLE orders (orderid int, customerId int, orderDate date) WITH (autovacuum_enabled = false);
```
Le colonne `IDENTITY` non sono supportate, ad esempio:
```
CREATE TABLE orders (orderid INT GENERATED ALWAYS AS IDENTITY);
```
Aurora PostgreSQL Limitless Database supporta fino a 54 caratteri per i nomi di tabelle sottoposte a sharding.
## CREATE TABLE AS
Per creare una tabella utilizzando `CREATE TABLE AS`, è necessario utilizzare la variabile `rds_aurora.limitless_create_table_mode`. Per le tabelle sottoposte a sharding, è necessario utilizzare anche la variabile `rds_aurora.limitless_create_table_shard_key`. Per ulteriori informazioni, consulta [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md).
```
-- Set the variables.
SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"a"}';
CREATE TABLE ctas_table AS SELECT 1 a;
-- "source" is the source table whose columns and data types are used to create the new "ctas_table2" table.
CREATE TABLE ctas_table2 AS SELECT a,b FROM source;
```
Non puoi utilizzare `CREATE TABLE AS` per creare tabelle di riferimento, poiché richiedono vincoli di chiave primaria. `CREATE TABLE AS` non propaga le chiavi primarie alle nuove tabelle.
Per ulteriori informazioni, consulta [CREATE DATABASE](https://www.postgresql.org/docs/current/sql-createtableas.html) nella documentazione di PostgreSQL.
## DROP DATABASE
Puoi eliminare i database creati.
Il comando `DROP DATABASE` viene eseguito in background in modo asincrono. Durante l’esecuzione, riceverai un errore se provi a creare un nuovo database con lo stesso nome.
## SELECT INTO
`SELECT INTO` è funzionalmente simile a [CREATE TABLE AS](#limitless-reference.DDL-limitations.CREATE_TABLE_AS). Devi utilizzare la variabile `rds_aurora.limitless_create_table_mode`. Per le tabelle sottoposte a sharding, è necessario utilizzare anche la variabile `rds_aurora.limitless_create_table_shard_key`. Per ulteriori informazioni, consulta [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md).
```
-- Set the variables.
SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"a"}';
-- "source" is the source table whose columns and data types are used to create the new "destination" table.
SELECT * INTO destination FROM source;
```
Attualmente, l’operazione `SELECT INTO` viene eseguita tramite il router, non direttamente tramite gli shard. Di conseguenza, le prestazioni possono essere lente.
Per ulteriori informazioni, consulta [SELECT INTO](https://www.postgresql.org/docs/current/sql-selectinto.html) nella documentazione di PostgreSQL.
## Vincoli
Le seguenti limitazioni si applicano ai vincoli in Aurora PostgreSQL Limitless Database.
**CHECK**
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)
);
```
**EXCLUDE**
I vincoli di esclusione non sono supportati in Aurora PostgreSQL Limitless Database.
**FOREIGN KEY**
Per ulteriori informazioni, consulta [Chiavi esterne](#limitless-reference.DDL-limitations.FKs).
**NOT NULL**
I vincoli `NOT NULL` non sono supportati senza restrizioni.
**PRIMARY KEY**
La chiave primaria implica vincoli univoci e pertanto si applicano le stesse restrizioni sui vincoli unici alla chiave primaria. Ciò significa che:
+ Se una tabella viene convertita in una tabella sottoposta a sharding, la chiave shard deve essere un sottoinsieme della chiave primaria. Vale a dire, la chiave primaria contiene tutte le colonne della chiave shard.
+ Se una tabella viene convertita in una tabella di riferimento, deve avere una chiave primaria.
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](limitless-creating.md).
**UNIQUE**
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)
);
```
Per ulteriori informazioni, consulta [Vincoli](https://www.postgresql.org/docs/current/ddl-constraints.html) nella documentazione di PostgreSQL.
## Valori predefiniti
Aurora PostgreSQL Limitless Database supporta espressioni nei valori predefiniti.
L’esempio seguente mostra l’uso dei valori predefiniti.
```
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)
```
Le espressioni sono supportate, come illustrato nell’esempio seguente.
```
CREATE TABLE t1 (a NUMERIC DEFAULT random());
```
Nell’esempio seguente viene aggiunta una nuova colonna che è `NOT NULL` e ha un valore predefinito.
```
ALTER TABLE t ADD COLUMN d BOOLEAN NOT NULL DEFAULT FALSE;
SELECT * FROM t;
a | b | c | d
---+-----+---+---
5 | NAN | | f
(1 row)
```
L’esempio seguente modifica una colonna esistente con un valore predefinito.
```
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)
```
L’esempio seguente rimuove un valore predefinito.
```
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)
```
Per ulteriori informazioni, consulta [Valori predefiniti](https://www.postgresql.org/docs/current/ddl-default.html) nella documentazione di PostgreSQL.
## Estensioni
Le seguenti estensioni PostgreSQL sono supportate in Aurora PostgreSQL Limitless Database:
+ `aurora_limitless_fdw`: questa estensione è preinstallata. e non può essere rimossa.
+ `aws_s3`: questa estensione funziona in Aurora PostgreSQL Limitless Database in modo simile ad Aurora PostgreSQL.
Puoi importare dati da un bucket Amazon S3 in un cluster di database Aurora PostgreSQL Limitless Database oppure esportare dati da un cluster di database Aurora PostgreSQL Limitless Database in un bucket Amazon S3. Per ulteriori informazioni, consulta [Importazione di dati da Amazon S3 in un cluster database Aurora PostgreSQL](USER_PostgreSQL.S3Import.md) e [Esportazione di dati da del cluster di database Aurora PostgreSQLRDS per PostgreSQL a Amazon S3](postgresql-s3-export.md).
+ `btree_gin`
+ `citext`
+ `ip4r`
+ `pg_buffercache`: questa estensione si comporta in modo diverso in Aurora PostgreSQL Limitless Database rispetto alla versione Community PostgreSQL. Per ulteriori informazioni, consulta [Differenze di pg\$1buffercache in Aurora PostgreSQL Limitless Database](#limitless-reference.DDL-limitations.Extensions.pg_buffercache).
+ `pg_stat_statements`
+ `pg_trgm`
+ `pgcrypto`
+ `pgstattuple`: questa estensione si comporta in modo diverso in Aurora PostgreSQL Limitless Database rispetto alla versione Community PostgreSQL. Per ulteriori informazioni, consulta [Differenze di pgstattuple in Aurora PostgreSQL Limitless Database](#limitless-reference.DDL-limitations.Extensions.pgstattuple).
+ `pgvector`
+ `plpgsql`: questa estensione è preinstallata, ma puoi rimuoverla.
+ `PostGIS`: le transazioni lunghe e le funzioni di gestione delle tabelle non sono supportate. La modifica della tabella di riferimento spaziale non è supportata.
+ `unaccent`
+ `uuid`
La maggior parte delle estensioni PostgreSQL non è attualmente supportata in Aurora PostgreSQL Limitless Database. Tuttavia, puoi comunque utilizzare l’impostazione della configurazione [shared\$1preload\$1libraries](https://www.postgresql.org/docs/current/runtime-config-client.html#RUNTIME-CONFIG-CLIENT-PRELOAD) (SPL) per caricare le estensioni nel cluster di database primario Aurora PostgreSQL. Le estensioni vengono caricate anche in Aurora PostgreSQL Limitless Database, ma potrebbero non funzionare correttamente.
Ad esempio, puoi caricare l’estensione `pg_hint_plan`, ma il suo caricamento non garantisce che vengano utilizzati i suggerimenti passati nei commenti delle query.
**Nota**
Non puoi modificare gli oggetti associati all’estensione [pg\$1stat\$1statements](https://www.postgresql.org/docs/current/pgstatstatements.html). Per informazioni sull’installazione di `pg_stat_statements`, consulta [limitless\$1stat\$1statements](limitless-monitoring-views.md#limitless_stat_statements).
Puoi utilizzare le funzioni `pg_available_extensions` e `pg_available_extension_versions` per trovare le estensioni supportate in Aurora PostgreSQL Limitless Database.
Le seguenti istruzioni DDL sono supportate per le estensioni:
**CREATE EXTENSION**
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](https://www.postgresql.org/docs/current/sql-createextension.html) nella documentazione di PostgreSQL.
**ALTER EXTENSION**
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](https://www.postgresql.org/docs/current/sql-alterextension.html) nella documentazione di PostgreSQL.
**DROP EXTENSION**
Puoi rimuovere le estensioni, come in PostgreSQL.
```
DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
```
Per ulteriori informazioni, consulta [DROP EXTENSION](https://www.postgresql.org/docs/current/sql-dropextension.html) nella documentazione di PostgreSQL.
Le seguenti istruzioni DDL non sono supportate per le estensioni:
**ALTER EXTENSION**
Non puoi aggiungere o rimuovere oggetti membri delle estensioni.
```
ALTER EXTENSION name ADD member_object
ALTER EXTENSION name DROP member_object
```
### Differenze di pg\$1buffercache in Aurora PostgreSQL Limitless Database
In Aurora PostgreSQL Limitless Database, quando installi l’estensione [pg\$1buffercache](https://www.postgresql.org/docs/current/pgbuffercache.html) e utilizzi la vista `pg_buffercache`, ricevi informazioni relative al buffer solo dal nodo a cui sei hai attualmente effettuato la connessione: il router. Allo stesso modo, l’uso della funzione `pg_buffercache_summary` o `pg_buffercache_usage_counts` fornisce informazioni solo dal nodo connesso.
Puoi disporre di numerosi nodi e potresti aver bisogno di accedere alle informazioni del buffer da qualsiasi nodo per diagnosticare i problemi in modo efficace. Pertanto, Aurora PostgreSQL Limitless Database fornisce le seguenti funzioni:
+ `rds_aurora.limitless_pg_buffercache(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_summary(subcluster_id)`
+ `rds_aurora.limitless_pg_buffercache_usage_counts(subcluster_id)`
Inserendo l’ID cluster secondario di qualsiasi nodo, che si tratti di un router o di uno shard, puoi accedere facilmente alle informazioni del buffer specifiche di quel nodo. Queste funzioni sono disponibili subito dopo l’installazione dell’estensione `pg_buffercache` nel Limitless Database.
**Nota**
Aurora PostgreSQL Limitless Database supporta queste funzioni per la versione 1.4 e successive dell’estensione `pg_buffercache`.
Le colonne mostrate nella vista `limitless_pg_buffercache` differiscono leggermente da quelle nella vista `pg_buffercache`:
+ `bufferid`: rimane invariata rispetto a `pg_buffercache`.
+ `relname`: invece di mostrare il numero di nodo del file come in `pg_buffercache`, `limitless_pg_buffercache` presenta il valore `relname` associato, se disponibile, nel database attuale o nei cataloghi del sistema condiviso, altrimenti `NULL`.
+ `parent_relname`: questa nuova colonna, non presente in `pg_buffercache`, mostra il valore `relname` principale se il valore nella colonna `relname` rappresenta una tabella partizionata (nel caso di tabelle sottoposte a sharding). Altrimenti, mostra `NULL`.
+ `spcname`: invece di mostrare l’identificatore dell’oggetto tablespace (OID) come in `pg_buffercache`, `limitless_pg_buffercache` mostra il nome del tablespace.
+ `datname`: invece di mostrare l’OID del database come in `pg_buffercache`, `limitless_pg_buffercache` mostrare il nome del database.
+ `relforknumber`: rimane invariata rispetto a `pg_buffercache`.
+ `relblocknumber`: rimane invariata rispetto a `pg_buffercache`.
+ `isdirty`: rimane invariata rispetto a `pg_buffercache`.
+ `usagecount`: rimane invariata rispetto a `pg_buffercache`.
+ `pinning_backends`: rimane invariata rispetto a `pg_buffercache`.
Le colonne nelle viste `limitless_pg_buffercache_summary` e `limitless_pg_buffercache_usage_counts` sono le stesse di quelle presenti nelle normali viste `pg_buffercache_summary` e `pg_buffercache_usage_counts`, rispettivamente.
Tramite queste funzioni, puoi accedere a informazioni dettagliate sulla cache del buffer in tutti i nodi dell’ambiente Aurora PostgreSQL Limitless Database, facilitando una diagnosi e una gestione più efficaci dei sistemi di database.
### Differenze di pgstattuple in Aurora PostgreSQL Limitless Database
In Aurora PostgreSQL, l’estensione [pgstattuple](https://www.postgresql.org/docs/current/pgstattuple.html) attualmente non supporta tabelle esterne, tabelle partizionate o indici partizionati. Tuttavia, in Aurora PostgreSQL Limitless Database, gli oggetti creati dall’utente sono spesso tra questi tipi non supportati. Sebbene esistano tabelle e indici normali (ad esempio, le tabelle di catalogo e i relativi indici), la maggior parte degli oggetti risiede su nodi esterni, diventando quindi oggetti esterni per il router.
Riconosciamo l’importanza di questa estensione per ottenere statistiche a livello di tuple, fondamentali per attività come la rimozione del bloat e la raccolta di informazioni diagnostiche. Pertanto, Aurora PostgreSQL Limitless Database fornisce supporto per l’estensione `pgstattuple` nei Limitless Database.
Aurora PostgreSQL Limitless Database include le seguenti funzioni nello schema `rds_aurora`:
**Funzioni statistiche a livello di tuple**
**`rds_aurora.limitless_pgstattuple(relation_name)`**
+ Scopo: estrarre statistiche a livello di tuple per le tabelle standard e i relativi indici
+ Input: `relation_name` (testo): il nome della relazione
+ Output: colonne coerenti con quelle restituite dalla funzione `pgstattuple` in Aurora PostgreSQL
**`rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)`**
+ Scopo: estrarre statistiche a livello di tuple per le tabelle di riferimento, le tabelle sottoposte a sharding, le tabelle di catalogo e i relativi indici
+ Input:
+ `relation_name` (testo): il nome della relazione
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre le statistiche
+ Output:
+ Per le tabelle di riferimento e di catalogo (inclusi i relativi indici), le colonne sono coerenti con Aurora PostgreSQL.
+ Per le tabelle sottoposte a sharding, le statistiche rappresentano solo la partizione della tabella sottoposta a sharding che risiede nel cluster secondario specificato.
**Funzioni di statistiche sugli indici**
**`rds_aurora.limitless_pgstatindex(relation_name)`**
+ Scopo: estrarre le statistiche per gli indici B-tree su tabelle standard
+ Input: `relation_name` (testo): il nome dell’indice B-tree
+ Output: vengono restituite tutte le colonne tranne `root_block_no`. Le colonne restituite sono coerenti con la funzione `pgstatindex` in Aurora PostgreSQL.
**`rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)`**
+ Scopo: estrarre le statistiche per gli indici B-tree su tabelle di riferimento, tabelle sottoposte a sharding e tabelle di catalogo.
+ Input:
+ `relation_name` (testo): il nome dell’indice B-tree
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre le statistiche
+ Output:
+ Per gli indici delle tabelle di riferimento e di catalogo, vengono restituite tutte le colonne (tranne `root_block_no`). Le colonne restituite sono coerenti con Aurora PostgreSQL.
+ Per le tabelle sottoposte a sharding, le statistiche rappresentano solo la partizione dell’indice della tabella sottoposta a sharding che risiede nel cluster secondario specificato. La colonna `tree_level` mostra la media di tutte le sezioni di tabella del cluster secondario richiesto.
**`rds_aurora.limitless_pgstatginindex(relation_name)`**
+ Scopo: estrarre le statistiche per gli indici invertiti generalizzati (GIN) su tabelle standard
+ Input: `relation_name` (testo): il nome del GIN
+ Output: colonne coerenti con quelle restituite dalla funzione `pgstatginindex` in Aurora PostgreSQL
**`rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)`**
+ Scopo: estrarre le statistiche per gli indici GIN su tabelle di riferimento, tabelle sottoposte a sharding e tabelle di catalogo.
+ Input:
+ `relation_name` (testo): il nome dell’indice
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre le statistiche
+ Output:
+ Per gli indici GIN di tabelle di riferimento e catalogo, le colonne sono coerenti con Aurora PostgreSQL.
+ Per le tabelle sottoposte a sharding, le statistiche rappresentano solo la partizione dell’indice della tabella sottoposta a sharding che risiede nel cluster secondario specificato.
**`rds_aurora.limitless_pgstathashindex(relation_name)`**
+ Scopo: estrarre le statistiche per gli indici hash su tabelle standard
+ Input: `relation_name` (testo): il nome del indice hash
+ Output: colonne coerenti con quelle restituite dalla funzione `pgstathashindex` in Aurora PostgreSQL
**`rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)`**
+ Scopo: estrarre le statistiche per gli indici hash su tabelle di riferimento, tabelle sottoposte a sharding e tabelle di catalogo.
+ Input:
+ `relation_name` (testo): il nome dell’indice
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre le statistiche
+ Output:
+ Per gli indici hash di tabelle di riferimento e catalogo, le colonne sono coerenti con Aurora PostgreSQL.
+ Per le tabelle sottoposte a sharding, le statistiche rappresentano solo la partizione dell’indice della tabella sottoposta a sharding che risiede nel cluster secondario specificato.
**Funzioni di conteggio delle pagine**
**`rds_aurora.limitless_pg_relpages(relation_name)`**
+ Scopo: estrarre il conteggio delle pagine per le tabelle standard e i relativi indici
+ Input: `relation_name` (testo): il nome della relazione
+ Output: conteggio di pagine della relazione specificata
**`rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)`**
+ Scopo: estrarre il conteggio delle pagine per le tabelle di riferimento, le tabelle sottoposte a sharding e le tabelle di catalogo (inclusi i relativi indici)
+ Input:
+ `relation_name` (testo): il nome della relazione
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre il conteggio delle pagine
+ Output: per le tabelle sottoposte a sharding, il conteggio delle pagine è la somma delle pagine di tutte le sezioni della tabella sul cluster secondario specificato.
**Funzioni di statistiche approssimate a livello di tuple**
**`rds_aurora.limitless_pgstattuple_approx(relation_name)`**
+ Scopo: estrarre statistiche approssimative a livello di tuple per le tabelle standard e i relativi indici
+ Input: `relation_name` (testo): il nome della relazione
+ Output: colonne coerenti con quelle restituite dalla funzione pgstattuple\$1approx in Aurora PostgreSQL
**`rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)`**
+ Scopo: estrarre statistiche approssimate a livello di tuple per le tabelle di riferimento, le tabelle sottoposte a sharding e le tabelle di catalogo (inclusi i relativi indici)
+ Input:
+ `relation_name` (testo): il nome della relazione
+ `subcluster_id` (testo): l’ID cluster secondario del nodo da cui estrarre le statistiche
+ Output:
+ Per le tabelle di riferimento e di catalogo (inclusi i relativi indici), le colonne sono coerenti con Aurora PostgreSQL.
+ Per le tabelle sottoposte a sharding, le statistiche rappresentano solo la partizione della tabella sottoposta a sharding che risiede nel cluster secondario specificato.
**Nota**
Attualmente, Aurora PostgreSQL Limitless Database non supporta l’estensione `pgstattuple` su viste materializzate, tabelle TOAST o tabelle temporanee.
In Aurora PostgreSQL Limitless Database, è necessario fornire l’input come testo, sebbene Aurora PostgreSQL supporti altri formati.
## Chiavi esterne
I vincoli di chiave esterna (`FOREIGN KEY`) sono supportati con alcune limitazioni:
+ `CREATE TABLE` con `FOREIGN KEY` è supportato solo per le tabelle standard. Per creare una tabella sottoposta a sharding o una tabella di riferimento con `FOREIGN KEY`, create innanzitutto la tabella senza un vincolo di chiave esterna. Successivamente, modificala utilizzando la seguente istruzione:
```
ALTER TABLE ADD CONSTRAINT;
```
+ La conversione di una tabella standard in una tabella sottoposta a sharding o di riferimento non è supportata se la tabella possiede un vincolo di chiave esterna. Rimuovi il vincolo, quindi aggiungilo dopo la conversione.
+ Le seguenti limitazioni si applicano ai tipi di tabella per i vincoli di chiave esterna:
+ Una tabella standard può avere un vincolo di chiave esterna rispetto a un’altra tabella standard.
+ Una tabella sottoposta a sharding può avere un vincolo di chiave esterna se le tabelle principale e secondaria sono co-localizzate e la chiave esterna è un superset della chiave shard.
+ Una tabella sottoposta a sharding può avere un vincolo di chiave esterna rispetto a una tabella di riferimento.
+ Una tabella di riferimento può avere un vincolo di chiave esterna rispetto a un’altra tabella di riferimento.
**Topics**
+ [Opzioni di chiave esterna](#limitless-reference.DDL-limitations.FKs.options)
+ [Esempi](#limitless-reference.DDL-limitations.FKs.examples)
### Opzioni di chiave esterna
Le chiavi esterne sono supportate in Aurora PostgreSQL Limitless Database per alcune opzioni DDL. La tabella seguente elenca le opzioni supportate e non supportate tra le tabelle di Aurora PostgreSQL Limitless Database:
| Opzione DDL | Da riferimento a riferimento | Da sottoposta a sharding a sottoposta a sharding (co-localizzate) | Da sottoposta a sharding a riferimento | Da standard a standard |
| --- | --- | --- | --- | --- |
| `DEFERRABLE` | Sì | Sì | Sì | Sì |
| `INITIALLY DEFERRED` | Sì | Sì | Sì | Sì |
| `INITIALLY IMMEDIATE` | Sì | Sì | Sì | Sì |
| `MATCH FULL` | Sì | Sì | Sì | Sì |
| `MATCH PARTIAL` | No | No | No | No |
| `MATCH SIMPLE` | Sì | Sì | Sì | Sì |
| `NOT DEFERRABLE` | Sì | Sì | Sì | Sì |
| `NOT VALID` | Sì | No | No | Sì |
| `ON DELETE CASCADE` | Sì | Sì | Sì | Sì |
| `ON DELETE NO ACTION` | Sì | Sì | Sì | Sì |
| `ON DELETE RESTRICT` | Sì | Sì | Sì | Sì |
| `ON DELETE SET DEFAULT` | No | No | No | No |
| `ON DELETE SET NULL` | Sì | No | No | Sì |
| `ON UPDATE CASCADE` | No | No | No | Sì |
| `ON UPDATE NO ACTION` | Sì | Sì | Sì | Sì |
| `ON UPDATE RESTRICT` | Sì | Sì | Sì | Sì |
| `ON UPDATE SET DEFAULT` | No | No | No | No |
| `ON UPDATE SET NULL` | Sì | No | No | Sì |
### Esempi
+ Da standard a standard:
```
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)
```
+ Da sottoposta a sharding a sottoposta a sharding (co-localizzate):
```
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);
```
+ Da sottoposta a sharding a riferimento:
```
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);
```
+ Da riferimento a riferimento:
```
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);
```
## Funzioni
Le funzioni sono supportate in Aurora PostgreSQL Limitless Database.
I seguenti DDL sono supportati per le funzioni:
**CREATE FUNCTION**
Puoi creare funzioni, come in Aurora PostgreSQL, con l’eccezione di modificarne la volatilità durante la sostituzione.
Per ulteriori informazioni, consulta [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html) nella documentazione di PostgreSQL.
**ALTER FUNCTION**
Puoi creare funzioni, come in Aurora PostgreSQL, con l’eccezione di modificarne la volatilità.
Per ulteriori informazioni, consulta [ALTER FUNCTION](https://www.postgresql.org/docs/current/sql-alterfunction.html) nella documentazione di PostgreSQL.
**DROP FUNCTION**
Puoi rimuovere le funzioni, come in Aurora PostgreSQL.
```
DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
[ CASCADE | RESTRICT ]
```
Per ulteriori informazioni, consulta [DROP FUNCTION](https://www.postgresql.org/docs/current/sql-dropfunction.html) nella documentazione di PostgreSQL.
**Topics**
+ [Distribuzione delle funzioni](#limitless-function-distribution)
+ [Volatilità della funzione](#limitless-function-volatility)
### Distribuzione delle funzioni
Quando tutte le istruzioni di una funzione sono indirizzate a un singolo shard, è conveniente eseguire l’intera funzione direttamente sullo shard di destinazione. In questo modo il risultato viene propagato al router, invece di eseguire la funzione direttamente sul router stesso. La capacità di pushdown di funzioni e stored procedure è utile per i clienti che desiderano eseguire la funzione o la stored procedure più vicino all’origine dati, ovvero allo shard.
Per distribuire una funzione, è necessario innanzitutto creare la funzione, quindi chiamare la procedura `rds_aurora.limitless_distribute_function` per distribuirla. Questa funzione usa la seguente sintassi:
```
SELECT rds_aurora.limitless_distribute_function('function_prototype', ARRAY['shard_key'], 'collocating_table');
```
La funzione accetta i seguenti parametri:
+ `function_prototype`: la funzione da distribuire. Riporta solo gli argomenti in input, non quelli in output.
Se uno qualsiasi degli argomenti è definito come parametro `OUT`, non includerne il tipo negli argomenti di `function_prototype`.
+ `ARRAY['shard_key']`: l’elenco degli argomenti della funzione identificati come chiave shard per la funzione.
+ `collocating_table`: la tabella condivisa che contiene l’intervallo di dati sullo shard di destinazione.
Per identificare lo shard su cui eseguire questa funzione, il sistema prende l’argomento `ARRAY['shard_key']`, ne esegue l’hash e individua lo shard da `collocating_table` che ospita l’intervallo contenente questo valore hash.
**Restrizioni**
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.
**Esempi**
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)
```
### Volatilità della funzione
Puoi determinare se una funzione è immutabile, stabile o volatile controllando il valore `provolatile` nella vista [pg\$1proc](https://www.postgresql.org/docs/current/catalog-pg-proc.html). Il valore `provolatile` indica se il risultato della funzione dipende solo dai suoi argomenti di input o è influenzato da fattori esterni.
Il valore è uno dei seguenti:
+ `i`: funzioni immutabili, che restituiscono sempre lo stesso risultato per gli stessi input.
+ `s`: funzioni stabili, i cui risultati (per input fissi) non cambiano durante una scansione.
+ `v`: funzioni volatili, i cui risultati potrebbero cambiare in qualsiasi momento. Usa `v` anche per funzioni con effetti collaterali, in modo che le chiamate non possano essere ottimizzate ed eliminate.
Gli esempi seguenti mostrano le funzioni volatili.
```
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)
```
La modifica della volatilità di una funzione esistente non è supportata in Aurora PostgreSQL Limitless Database. Questo vale sia per i comandi `ALTER FUNCTION` che per i comandi `CREATE OR REPLACE FUNCTION`, come illustrato negli esempi seguenti.
```
-- 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;
```
Consigliamo vivamente di assegnare le volatilità corrette alle funzioni. Ad esempio, se la funzione utilizza `SELECT` da più tabelle o fa riferimento a oggetti del database, non impostarla come `IMMUTABLE`. Se il contenuto della tabella cambia, l’immutabilità viene compromessa.
Aurora PostgreSQL consente `SELECT` all’interno di funzioni immutabili, ma i risultati potrebbero essere errati. Aurora PostgreSQL Limitless Database può restituire sia errori sia risultati errati. Per ulteriori informazioni, consulta [Function volatility categories](https://www.postgresql.org/docs/current/xfunc-volatility.html) nella documentazione di PostgreSQL.
## Sequenze
Le sequenze nominate sono oggetti di database che generano numeri univoci in ordine crescente o decrescente. `CREATE SEQUENCE` crea un nuovo generatore di numeri di sequenza. I valori di sequenza sono garantiti come univoci.
Quando crei una sequenza denominata in Aurora PostgreSQL Limitless Database, viene creato un oggetto di sequenza distribuita. Successivamente, Aurora PostgreSQL Limitless Database distribuisce blocchi di valori di sequenza non sovrapposti su tutti i Distributed Transaction Router (router). I blocchi sono rappresentati come oggetti di sequenza locale sui router; pertanto, le operazioni di sequenza come `nextval` e `currval` vengono eseguite localmente. I router operano in modo indipendente e richiedono nuovi blocchi dalla sequenza distribuita, quando necessario.
Per ulteriori informazioni sulle sequenze, consulta [CREATE SEQUENCE](https://www.postgresql.org/docs/current/sql-createsequence.html) nella documentazione di PostgreSQL.
**Topics**
+ [Richiesta di un nuovo blocco](#limitless-reference.DDL-limitations.Sequences.request-chunk)
+ [Limitazioni](#limitless-reference.DDL-limitations.Sequences.limitations)
+ [Opzioni non supportate](#limitless-reference.DDL-limitations.Sequences.unsupported)
+ [Esempi](#limitless-reference.DDL-limitations.Sequences.examples)
+ [Viste delle sequenze](#limitless-reference.DDL-limitations.Sequences.views)
+ [Risoluzione dei problemi delle sequenze](#limitless-reference.DDL-limitations.Sequences.troubleshooting)
### Richiesta di un nuovo blocco
Puoi configurare le dimensioni dei blocchi allocati sui router utilizzando il parametro `rds_aurora.limitless_sequence_chunk_size`. Il valore predefinito è `250000`. Ogni router possiede inizialmente due blocchi: attivi e riservati. I blocchi attivi vengono utilizzati per configurare gli oggetti di sequenza locale (impostando `minvalue` e`maxvalue`) e i blocchi riservati vengono archiviati in una tabella interna del catalogo. Quando un blocco attivo raggiunge il valore minimo o massimo, viene sostituito dal blocco riservato. A tal fine, `ALTER SEQUENCE` viene utilizzato internamente, dunque `AccessExclusiveLock` viene acquisito.
I worker in background vengono eseguiti ogni 10 secondi sui nodi del router per scansionare le sequenze alla ricerca di blocchi riservati utilizzati. Se viene trovato un blocco utilizzato, il worker richiede un nuovo blocco dalla sequenza distribuita. Assicurati di impostare una dimensione dei blocchi sufficientemente grande affinché i worker in background abbiano tempo sufficiente per richiederne di nuovi. Le richieste remote non avvengono mai nel contesto delle sessioni utente, quindi non puoi richiedere direttamente una nuova sequenza.
### Limitazioni
Le limitazioni seguenti si applicano alle sequenze in Aurora PostgreSQL Limitless Database:
+ Il catalogo `pg_sequence`, la funzione `pg_sequences` e l’istruzione `SELECT * FROM sequence_name` mostrano solo lo stato della sequenza locale, non quello distribuito.
+ I valori della sequenza sono garantiti come univoci e monotoni all’interno di una sessione. Tuttavia, possono risultare errati rispetto alle istruzioni `nextval` eseguite in altre sessioni, se tali sessioni sono connesse ad altri router.
+ Assicurati che la dimensione della sequenza (numero di valori disponibili) sia sufficientemente grande da poter essere distribuita su tutti i router. Usa il parametro `rds_aurora.limitless_sequence_chunk_size` per configurare `chunk_size`. Ogni router ha due blocchi.
+ L’opzione `CACHE`è supportata, ma la cache deve essere inferiore a `chunk_size`.
### Opzioni non supportate
Le seguenti opzioni non sono supportate per le sequenze in Aurora PostgreSQL Limitless Database.
**Funzioni di manipolazione di sequenze**
La funzione `setval` non è supportata. Per ulteriori informazioni, consulta [Sequence Manipulation Functions](https://www.postgresql.org/docs/current/functions-sequence.html) nella documentazione di PostgreSQL.
**CREATE SEQUENCE**
Le seguenti opzioni non sono supportate.
```
CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
[[ NO ] CYCLE]
```
Per ulteriori informazioni, consulta [CREATE SEQUENCE](https://www.postgresql.org/docs/current/sql-createsequence.html) nella documentazione di PostgreSQL.
**ALTER SEQUENCE**
Le seguenti opzioni non sono supportate.
```
ALTER SEQUENCE
[[ NO ] CYCLE]
```
Per ulteriori informazioni, consulta [ALTER SEQUENCE](https://www.postgresql.org/docs/current/sql-altersequence.html) nella documentazione di PostgreSQL.
**ALTER TABLE**
Il comando `ALTER TABLE` non è supportato per le sequenze.
### Esempi
**CREATE/DROP SEQUENCE**
```
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
```
**ALTER 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)
```
**Funzioni di manipolazione di sequenze**
```
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)
```
### Viste delle sequenze
Aurora PostgreSQL Limitless Database offre le seguenti viste per le sequenze.
**rds\$1aurora.limitless\$1distributed\$1sequence**
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\$1sequences](https://www.postgresql.org/docs/current/view-pg-sequences.html) 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)
```
**rds\$1aurora.limitless\$1sequence\$1metadata**
Questa vista mostra i metadati della sequenza distribuita e aggrega i metadati della sequenza dai nodi del cluster. Usa le seguenti colonne:
+ `subcluster_id`: l’ID del nodo del cluster che possiede un blocco.
+ Blocco attivo: un blocco di una sequenza attualmente in uso (`active_minvalue`, `active_maxvalue`).
+ Blocco riservato: il blocco locale che verrà utilizzato successivamente (`reserved_minvalue`, `reserved_maxvalue`).
+ `local_last_value`: l’ultimo valore osservato da una sequenza locale.
+ `chunk_size`: la dimensione di un blocco, come configurato alla creazione.
```
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)
```
### Risoluzione dei problemi delle sequenze
Possono verificarsi i seguenti problemi con le sequenze:
**Dimensione del blocco non sufficientemente grande**
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`.
**Cache della sequenza impostata troppo alta**
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\$1chunk e causare eventi di contesa e attesa come `LIMITLESS:AuroraLimitlessSequenceReplace`, `LWLock:LockManager`, `Lockrelation` e `LWlock:bufferscontent`.
Riduci l’impostazione della cache della sequenza.
La figura seguente mostra gli eventi di attesa causati da problemi di sequenza.
![\[Eventi di attesa causati da problemi di sequenza.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/limitless_sequence_waits.png)
# Comandi SQL supportati e non supportati per Data Manipulation Language (DML) e per l’elaborazione delle query
La tabella seguente elenca i comandi DML supportati e non supportati da Aurora PostgreSQL Limitless Database, con riferimenti a limitazioni o ulteriori informazioni.
| Comando | Supportato? | Limitazioni o ulteriori informazioni |
| --- | --- | --- |
| ABORT | Sì | Nessuno |
| ANALYZE | Sì | [ANALYZE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.ANALYZE) |
| BEGIN | Sì | Nessuno |
| CALL | Sì | Nessuno |
| CHECKPOINT | Sì | Nessuno |
| CLOSE | Sì | Nessuno |
| CLUSTER | Sì | [CLUSTER](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.CLUSTER) |
| COMMIT | Sì | Nessuno |
| COMMIT PREPARED | No | Non applicabile |
| COPY | Sì | Nessuno |
| DEALLOCATE | Sì | Nessuno |
| DECLARE | Sì | Nessuno |
| DELETE | Sì | Nessuno |
| DISCARD | Sì | Nessuno |
| DO | Sì | Nessuno |
| END | Sì | Nessuno |
| EXECUTE | Sì | Nessuno |
| EXPLAIN | Sì | [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN) |
| FETCH | Sì | Nessuno |
| IMPORT FOREIGN SCHEMA | No | Non applicabile |
| INSERT | Sì | [INSERT](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.INSERT) |
| LISTEN | No | Non applicabile |
| LOCK | Sì | Nessuno |
| MERGE | No | Non applicabile |
| MOVE | Sì | Nessuno |
| NOTIFY | No | Non applicabile |
| APERTO | Sì | Nessuno |
| PREPARE | Sì | Nessuno |
| PREPARE TRANSACTION | No | Non applicabile |
| REFRESH MATERIALIZED VIEW | No | Non applicabile |
| REINDEX | No | Non applicabile |
| RELEASE SAVEPOINT | Sì | Nessuno |
| ROLLBACK | Sì | Nessuno |
| ROLLBACK PREPARED | No | Non applicabile |
| ROLLBACK TO SAVEPOINT | Sì | Nessuno |
| SAVEPOINT | Sì | Nessuno |
| SELECT | Sì | Nessuno |
| SELECT INTO | Sì | Nessuno |
| MOSTRA | Sì | Nessuno |
| START TRANSACTION | Sì | Nessuno |
| UNLISTEN | No | Nessuno |
| UPDATE | Sì | [UPDATE](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.UPDATE) |
| UPDATE … WHERE CURRENT OF | No | Non applicabile |
| VACUUM | Sì | [VACUUM](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.VACUUM) |
| VALUES | Sì | Nessuno |
# Limitazioni DML e altre informazioni per Aurora PostgreSQL Limitless Database
I seguenti argomenti descrivono le limitazioni o forniscono ulteriori informazioni per i comandi DML e di elaborazione delle query SQL in Aurora PostgreSQL Limitless Database.
**Topics**
+ [ANALYZE](#limitless-reference.DML-limitations.ANALYZE)
+ [CLUSTER](#limitless-reference.DML-limitations.CLUSTER)
+ [EXPLAIN](#limitless-reference.DML-limitations.EXPLAIN)
+ [INSERT](#limitless-reference.DML-limitations.INSERT)
+ [UPDATE](#limitless-reference.DML-limitations.UPDATE)
+ [VACUUM](#limitless-reference.DML-limitations.VACUUM)
## ANALYZE
Il comando `ANALYZE` raccoglie statistiche sul contenuto delle tabelle nel database. Successivamente, il pianificatore di query utilizza queste statistiche per determinare i piani di esecuzione più efficienti per le query. Per ulteriori informazioni, consulta [ANALYZE](https://www.postgresql.org/docs/current/sql-analyze.html) nella documentazione di PostgreSQL.
In Aurora PostgreSQL Limitless Database, il comando `ANALYZE` raccoglie le statistiche delle tabelle su tutti i router e gli shard durante l’esecuzione.
Per impedire il calcolo delle statistiche su ogni router durante le esecuzioni di `ANALYZE`, le statistiche delle tabelle vengono calcolate su uno dei router e quindi copiate sui router peer.
## CLUSTER
Il comando `CLUSTER` riordina fisicamente una tabella in base a un indice. L’indice deve essere già stato definito nella tabella. In Aurora PostgreSQL Limitless Database, il clustering è locale alla parte dell’indice presente su ogni shard.
Per ulteriori informazioni, consulta [CLUSTER](https://www.postgresql.org/docs/current/sql-cluster.html) nella documentazione di PostgreSQL.
## EXPLAIN
Si utilizza il seguente parametro per configurare l’output del comando `EXPLAIN`:
+ `rds_aurora.limitless_explain_options`: cosa includere nell’output `EXPLAIN`. Il valore predefinito è `single_shard_optimization`: viene mostrato se i piani sono ottimizzati per shard singolo, ma i piani shard non sono inclusi.
In questo esempio, l’output `EXPLAIN` non mostra i piani ricavati dagli shard.
```
postgres_limitless=> EXPLAIN SELECT * FROM employees where id =25;
QUERY PLAN
------------------------------------------------------
Foreign Scan (cost=100.00..101.00 rows=100 width=0)
Single Shard Optimized
(2 rows)
```
Ora impostiamo l’opzione `rds_aurora.limitless_explain_options` per includere `shard_plans` e`single_shard_optimization`. Possiamo visualizzare i piani di esecuzione delle istruzioni sia sui router che sugli shard. Inoltre, disabilitiamo il parametro `enable_seqscan` per far sì che la scansione dell’indice venga utilizzata sul livello shard.
```
postgres_limitless=> SET rds_aurora.limitless_explain_options = shard_plans, single_shard_optimization;
SET
postgres_limitless=> SET enable_seqscan = OFF;
SET
postgres_limitless=> EXPLAIN SELECT * FROM employees WHERE id = 25;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
Foreign Scan (cost=100.00..101.00 rows=100 width=0)
Remote Plans from Shard postgres_s4:
Index Scan using employees_ts00287_id_idx on employees_ts00287 employees_fs00003 (cost=0.14..8.16 rows=1 width=15)
Index Cond: (id = 25)
Single Shard Optimized
(5 rows)
```
Per ulteriori informazioni sul comando `EXPLAIN`, consulta [EXPLAIN](https://www.postgresql.org/docs/current/sql-explain.html) nella documentazione di PostgreSQL.
## INSERT
La maggior parte dei comandi `INSERT` è supportata in Aurora PostgreSQL Limitless Database.
PostgreSQL non ha un comando `UPSERT` esplicito, ma supporta le istruzioni `INSERT ... ON CONFLICT`.
`INSERT ... ON CONFLICT` non è supportato se l’azione di conflitto ha una sottoquery o una funzione mutabile:
```
-- RANDOM is a mutable function.
INSERT INTO sharded_table VALUES (1, 100) ON CONFLICT (id) DO UPDATE SET other_id = RANDOM();
ERROR: Aurora Limitless Tables doesn't support pushdown-unsafe functions with DO UPDATE clauses.
```
Per ulteriori informazioni sul comando `INSERT`, consulta [INSERT](https://www.postgresql.org/docs/current/sql-insert.html) nella documentazione di PostgreSQL.
## UPDATE
L’aggiornamento della chiave shard non è supportato. Ad esempio, si dispone di una tabella sottoposta a sharding denominata `customers`, con una chiave shard `customer_id`. Le seguenti istruzioni DML causano errori:
```
postgres_limitless=> UPDATE customers SET customer_id = 11 WHERE customer_id =1;
ERROR: Shard key column update is not supported
postgres_limitless=> UPDATE customers SET customer_id = 11 WHERE customer_name='abc';
ERROR: Shard key column update is not supported
```
Per aggiornare una chiave shard, è necessario prima `DELETE` la riga con la chiave shard key, quindi `INSERT` una nuova riga con il valore della chiave shard aggiornato.
Per ulteriori informazioni sul comando `UPDATE`, consulta [Updating data](https://www.postgresql.org/docs/current/dml-update.html) nella documentazione di PostgreSQL.
## VACUUM
È possibile eseguire l’operazione di vacuum sia sulle tabelle sottoposte a sharding che su quelle di riferimento. Le seguenti funzioni `VACUUM` sono completamente supportate in Aurora PostgreSQL Limitless Database.
+ VACUUM
+ [ANALYZE](#limitless-reference.DML-limitations.ANALYZE)
+ DISABLE\$1PAGE\$1SKIPPING
+ FREEZE
+ FULL
+ INDEX\$1CLEANUP
+ PARALLEL
+ PROCESS\$1TOAST
+ TRUNCATE
+ VERBOSE
`VACUUM` su Aurora PostgreSQL Limitless Database presenta le seguenti limitazioni:
+ L’estensione [pg\$1visibility\$1map](https://www.postgresql.org/docs/current/pgvisibility.html) non è supportata.
+ Il controllo degli indici non utilizzati con la vista [pg\$1stat\$1all\$1indexes](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ALL-INDEXES-VIEW) non è supportato.
+ Le viste consolidate per [pg\$1stat\$1user\$1indexes](https://www.postgresql.org/docs/current/monitoring-stats.html), [pg\$1class](https://www.postgresql.org/docs/current/catalog-pg-class.html) e [pg\$1stats](https://www.postgresql.org/docs/current/view-pg-stats.html) non sono implementate.
Per ulteriori informazioni sul comando `VACUUM`, consulta [VACUUM](https://www.postgresql.org/docs/current/sql-vacuum.html) nella documentazione di PostgreSQL. Per ulteriori informazioni su come funziona l’operazione di vacuum in Aurora PostgreSQL Limitless Database, consulta [Recupero dello spazio di archiviazione tramite il processo di vacuum](limitless-vacuum.md).
# Variabili in Aurora PostgreSQL Limitless Database
È possibile utilizzare le seguenti variabili per configurare Aurora PostgreSQL Limitless Database.
**rds\$1aurora.limitless\$1active\$1shard\$1key**
Imposta una singola chiave shard durante l’esecuzione di query sul database, facendo sì che tutte le query `SELECT` e DML vengano aggiunte con la chiave shard come predicato costante. Per ulteriori informazioni, consulta [Impostazione di una chiave di shard attiva](limitless-query.single-shard.md#limitless-query.single-shard.active).
**rds\$1aurora.limitless\$1create\$1table\$1collocate\$1with**
Imposta questa variabile su un nome di tabella specifico per collocare le tabelle appena create con quella tabella. Per ulteriori informazioni, consulta [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md).
**rds\$1aurora.limitless\$1create\$1table\$1mode**
Imposta la modalità di creazione della tabella. Per ulteriori informazioni, consulta [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md).
**rds\$1aurora.limitless\$1create\$1table\$1shard\$1key**
Imposta questa variabile su una matrice di nomi di colonna da utilizzare come chiavi shard. Per ulteriori informazioni, consulta [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md).
**rds\$1aurora.limitless\$1explain\$1options**
Cosa includere nell’output `EXPLAIN`. Per ulteriori informazioni, consulta [EXPLAIN](limitless-reference.DML-limitations.md#limitless-reference.DML-limitations.EXPLAIN).
# Parametri del cluster di database in Aurora PostgreSQL Limitless Database
È possibile utilizzare i seguenti parametri del cluster di database per configurare Aurora PostgreSQL Limitless Database.
**rds\$1aurora.limitless\$1adaptive\$1fetch\$1size**
Migliora il prefetching in batch. Se impostato su `true`, questo parametro consente una dimensione di recupero autoregolante (adattativa) per il prefetching. Se impostato su `false`, la dimensione di recupero è costante.
**rds\$1aurora.limitless\$1auto\$1scale\$1options**
Imposta le opzioni disponibili per aggiungere router o dividere gli shard in un gruppo di shard del database. Il valore può essere `add_router`, `split_shard` o entrambi.
Per ulteriori informazioni, consultare [Aggiunta di un router a un gruppo di shard del database](limitless-add-router.md) e [Suddivisione di uno shard in un gruppo di shard di database](limitless-shard-split.md).
**rds\$1aurora.limitless\$1distributed\$1deadlock\$1timeout**
Il periodo di tempo di attesa su un lock prima di verificare se esiste una condizione di deadlock distribuito, in millisecondi. Il valore predefinito è `1000` (1 secondo).
Per ulteriori informazioni, consulta [Deadlock distribuiti in Aurora PostgreSQL Limitless Database](limitless-query.deadlocks.md).
**rds\$1aurora.limitless\$1enable\$1auto\$1scale**
Consente l’aggiunta di router e la suddivisione degli shard in un gruppo di shard del database.
Per ulteriori informazioni, consultare [Aggiunta di un router a un gruppo di shard del database](limitless-add-router.md) e [Suddivisione di uno shard in un gruppo di shard di database](limitless-shard-split.md).
**rds\$1aurora.limitless\$1finalize\$1split\$1shard\$1mode**
Determina come vengono finalizzate le suddivisioni degli shard avviate dal sistema. Per ulteriori informazioni, consulta [Suddivisione di uno shard in un gruppo di shard di database](limitless-shard-split.md).
**rds\$1aurora.limitless\$1maximum\$1adaptive\$1fetch\$1size**
Imposta il limite superiore per la dimensione di recupero adattivo. L’intervallo è `1`–`INT_MAX`. Il valore predefinito è `1000`.