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à. # Creazione di tabelle di Aurora PostgreSQL Limitless Database In Aurora PostgreSQL Limitless Database, esistono tre tipi di tabelle che contengono i dati: + Standard: è il tipo di tabella predefinito in Aurora PostgreSQL Limitless Database. Puoi creare tabelle standard utilizzando il comando [CREATE TABLE](https://www.postgresql.org/docs/current/sql-createtable.html) ed eseguire su di esse operazioni DDL (Data Definition Language) e DML (Data Manipulation Language). Le tabelle standard non sono tabelle distribuite. Vengono archiviate su uno degli shard selezionato internamente dal sistema. + Sottoposte a sharding: queste tabelle sono distribuite su più shard. I dati vengono suddivisi tra gli shard in base ai valori di specifiche colonne della tabella. Questo set di colonne è chiamato chiave di shard. + Riferimento: queste tabelle vengono replicate su tutti gli shard. Vengono utilizzate per dati di riferimento modificati raramente, come cataloghi di prodotti e codici postali. Le query join tra tabelle di riferimento e tabelle sottoposte a sharding possono essere eseguite direttamente sugli shard, eliminando movimenti di dati non necessari tra shard e router. Esistono due modi per creare tabelle Limitless: + [Creazione di tabelle Limitless utilizzando variabili](limitless-creating-config.md): utilizza questo metodo quando vuoi creare nuove tabelle sottoposte a sharding e di riferimento. + [Conversione di tabelle standard in tabelle Limitless](limitless-converting-standard.md): utilizza questo metodo per convertire tabelle standard esistenti in tabelle sottoposte a sharding e di riferimento. Sono inoltre disponibili [schemi di esempio](limitless-sample-schemas.md) per Aurora PostgreSQL Limitless Database. # Creazione di tabelle Limitless utilizzando variabili Puoi utilizzare variabili per creare tabelle sottoposte a sharding e tabelle di riferimento impostando la modalità di creazione delle tabelle. Le tabelle che creerai utilizzeranno questa modalità finché non imposterai una modalità diversa. Utilizza le seguenti variabili per creare tabelle sottoposte a sharding e tabelle di riferimento: + `rds_aurora.limitless_create_table_mode`: imposta questa variabile di sessione su `sharded` o `reference`. Il valore predefinito di questa variabile è `standard`. + `rds_aurora.limitless_create_table_shard_key`: imposta questa variabile di sessione su un array di nomi di colonna da utilizzare come chiavi di shard. Questa variabile viene ignorata quando `rds_aurora.limitless_create_table_mode` non è `sharded`. Formatta il valore come `untyped array literal`, simile a quando inserisci letterali in una colonna di array. Per ulteriori informazioni, consulta [Arrays](https://www.postgresql.org/docs/current/arrays.html) nella documentazione di PostgreSQL. + `rds_aurora.limitless_create_table_collocate_with`: imposta questa variabile di sessione su un nome di tabella specifico per co-localizzare le tabelle appena create con quella tabella. Se due o più tabelle sono sottoposte a sharding utilizzando la stessa chiave di shard, è possibile allinearle esplicitamente (co-localizzarle). Quando due o più tabelle sono co-localizzate, le righe con gli stessi valori di chiave di shard vengono posizionate nello stesso shard. La co-localizzazione aiuta a limitare alcune operazioni a un singolo shard, migliorando le prestazioni. **Nota** Tutte le chiavi primarie e uniche devono includere la chiave di shard. Ciò significa che la chiave di shard è un sottoinsieme della chiave primaria o unica. Le tabelle Limitless presentano alcune limitazioni. Per ulteriori informazioni, consulta [Limitazioni DDL e altre informazioni per Aurora PostgreSQL Limitless Database](limitless-reference.DDL-limitations.md). **Topics** + [Esempi di utilizzo di variabili per creare tabelle Limitless](#limitless-tables-examples) + [Visualizzazioni della tabella di Aurora PostgreSQL Limitless Database](#limitless-table-views) ## Esempi di utilizzo di variabili per creare tabelle Limitless Gli esempi seguenti mostrano come utilizzare queste variabili per creare tabelle sottoposte a sharding e tabelle di riferimento. Crea una tabella sottoposta a sharding denominata `items`, con la chiave di shard `id`. ``` BEGIN; SET LOCAL rds_aurora.limitless_create_table_mode='sharded'; SET LOCAL rds_aurora.limitless_create_table_shard_key='{"id"}'; CREATE TABLE items(id int, val int, item text); COMMIT; ``` Crea una tabella sottoposta a sharding denominata `items`, con una chiave di shard composta dalle colonne `item_id` e `item_cat`. ``` BEGIN; SET LOCAL rds_aurora.limitless_create_table_mode='sharded'; SET LOCAL rds_aurora.limitless_create_table_shard_key='{"item_id", "item_cat"}'; CREATE TABLE items(item_id int, item_cat varchar, val int, item text); COMMIT; ``` Crea una tabella sottoposta a sharding denominata `item_description`, con una chiave di shard composta dalle colonne `item_id` e `item_cat` e co-localizzala con la tabella `items` dell’esempio precedente. ``` BEGIN; SET LOCAL rds_aurora.limitless_create_table_mode='sharded'; SET LOCAL rds_aurora.limitless_create_table_shard_key='{"item_id", "item_cat"}'; SET LOCAL rds_aurora.limitless_create_table_collocate_with='items'; CREATE TABLE item_description(item_id int, item_cat varchar, color_id int); COMMIT; ``` Crea una tabella di riferimento denominata `colors`. ``` BEGIN; SET LOCAL rds_aurora.limitless_create_table_mode='reference'; CREATE TABLE colors(color_id int primary key, color varchar); COMMIT; ``` Per reimpostare la variabile di sessione `rds_aurora.limitless_create_table_mode` su`standard`, utilizza la seguente istruzione: ``` RESET rds_aurora.limitless_create_table_mode; ``` Dopo aver reimpostato questa variabile, le tabelle vengono create come tabelle standard, che è il valore predefinito. Per ulteriori informazioni sulle tabelle standard, consulta [Conversione di tabelle standard in tabelle Limitless](limitless-converting-standard.md). ## Visualizzazioni della tabella di Aurora PostgreSQL Limitless Database Puoi trovare informazioni sulle tabelle di Limitless Database utilizzando le seguenti visualizzazioni. **rds\$1aurora.limitless\$1tables** La visualizzazione `rds_aurora.limitless_tables` contiene informazioni sulle tabelle Limitless e sui loro tipi. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_tables; table_gid | local_oid | schema_name | table_name | table_status | table_type | distribution_key -----------+-----------+-------------+-------------+--------------+-------------+------------------ 5 | 18635 | public | standard | active | standard | 6 | 18641 | public | ref | active | reference | 7 | 18797 | public | orders | active | sharded | HASH (order_id) 2 | 18579 | public | customer | active | sharded | HASH (cust_id) (4 rows) ``` **rds\$1aurora.limitless\$1table\$1collocations** La visualizzazione `rds_aurora.limitless_table_collocations` contiene informazioni sulle tabelle sottoposte a sharding co-localizzate. Ad esempio, le tabelle `orders` e `customers` sono co-localizzate e presentano lo stesso `collocation_id`. Le tabelle `users` e `followers` sono co-localizzate e presentano lo stesso `collocation_id`. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_table_collocations ORDER BY collocation_id; collocation_id | schema_name | table_name ----------------+-------------+------------ 16002 | public | orders 16002 | public | customers 16005 | public | users 16005 | public | followers (4 rows) ``` **rds\$1aurora.limitless\$1table\$1collocation\$1distributions** `rds_aurora.limitless_table_collocation_distributions` mostra la distribuzione delle chiavi per ogni co-localizzazione. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_table_collocation_distributions ORDER BY collocation_id, lower_bound; collocation_id | subcluster_id | lower_bound | upper_bound ----------------+---------------+----------------------+---------------------- 16002 | 6 | -9223372036854775808 | -4611686018427387904 16002 | 5 | -4611686018427387904 | 0 16002 | 4 | 0 | 4611686018427387904 16002 | 3 | 4611686018427387904 | 9223372036854775807 16005 | 6 | -9223372036854775808 | -4611686018427387904 16005 | 5 | -4611686018427387904 | 0 16005 | 4 | 0 | 4611686018427387904 16005 | 3 | 4611686018427387904 | 9223372036854775807 (8 rows) ``` # Conversione di tabelle standard in tabelle Limitless Puoi convertire tabelle standard in tabelle sottoposte a sharding o di riferimento. Durante la conversione, i dati vengono spostati dalla tabella standard alla tabella distribuita, quindi la tabella standard di origine viene eliminata. I dati vengono spostati utilizzando il comando `INSERT INTO SELECT FROM`. **Contents** + [Creazione di tabelle sottoposte a sharding](#limitless-creating-sharded) + [Creazione di tabelle co-localizzate](#limitless-creating-sharded.colocated) + [Creazione di tabelle di riferimento](#limitless-creating-reference) ## Creazione di tabelle sottoposte a sharding Crea tabelle sottoposte a sharding eseguendo la procedura `rds_aurora.limitless_alter_table_type_sharded` su tabelle standard. Questa procedura riceve una tabella standard e un elenco di colonne, quindi distribuisce la tabella indicata utilizzando l’elenco di colonne come chiave di shard. La procedura viene eseguita in modalità sincrona e acquisisce un blocco `ACCESS EXCLUSIVE` sulla tabella. Al termine corretto della procedura, la tabella standard di origine viene eliminata e una tabella sottoposta a sharding con lo stesso nome diventa disponibile. La procedura `rds_aurora.limitless_alter_table_type_sharded` utilizza la seguente sintassi: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('schema.table', ARRAY['shard_key1', 'shard_key2', ... 'shard_keyn']); ``` La procedura richiede i seguenti parametri. + `schema`: lo schema del database che contiene la tabella da sottoporre a sharding. Se lo schema non è specificato, la procedura utilizza `search_path`. + `table`: la tabella da sottoporre a sharding. + `shard_keyn`: un array di colonne della tabella da utilizzare come chiave di shard. I valori della chiave di shard sono stringhe letterali e quindi rispettano la distinzione tra maiuscole e minuscole. Se una chiave di shard contiene una virgoletta singola ('), usare un’altra virgoletta singola per eseguire la procedura di escape. Ad esempio, se una colonna della tabella è denominata `customer's id`, utilizza `customer''s id` come chiave di shard. Non è necessario eseguire la procedura di escape per le barre rovesciate (\$1) e le virgolette doppie ("). **Nota** Tutte le chiavi primarie e uniche devono includere la chiave di shard. Ciò significa che la chiave di shard è un sottoinsieme della chiave primaria o unica. Nelle tabelle sottoposte a sharding, il vincolo `CHECK` non supporta le espressioni. Per ulteriori informazioni, consulta [Vincoli](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Constraints). **Per creare una tabella sottoposta a sharding** L’esempio seguente mostra come creare la tabella sottoposta a sharding `customer` con la chiave di shard `customer_id`. 1. Crea la tabella standard. ``` CREATE TABLE customer (customer_id INT PRIMARY KEY NOT NULL, zipcode INT, email VARCHAR); ``` 1. Convertire la tabella standard in tabella sottoposta a sharding. ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('public.customer', ARRAY['customer_id']); postgres=> \d List of relations Schema | Name | Type | Owner --------+--------------+-------------------+-------------------- public | customer | partitioned table | postgres_limitless public | customer_fs1 | foreign table | postgres_limitless public | customer_fs2 | foreign table | postgres_limitless public | customer_fs3 | foreign table | postgres_limitless public | customer_fs4 | foreign table | postgres_limitless public | customer_fs5 | foreign table | postgres_limitless (6 rows) ``` ## Creazione di tabelle co-localizzate Se due o più tabelle sono sottoposte a sharding utilizzando la stessa chiave di shard, è possibile allinearle esplicitamente (co-localizzarle). Quando due o più tabelle sono co-localizzate, le righe con gli stessi valori di chiave di shard vengono posizionate nello stesso shard. La co-localizzazione aiuta a limitare alcune operazioni a un singolo shard, migliorando le prestazioni. Utilizza la procedura `rds_aurora.limitless_alter_table_type_sharded` con la seguente sintassi: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('schema.collocated_table', ARRAY['shard_key1', 'shard_key2', ... 'shard_keyn'], 'schema.sharded_table'); ``` La procedura richiede i seguenti parametri. + `schema`: lo schema del database che contiene le tabelle da co-localizzare. Se lo schema non è specificato, la procedura utilizza `search_path`. + `collocated_table`: la tabella da co-localizzare. + `shard_keyn`: un array di colonne della tabella da utilizzare come chiave di shard. Devi usare la stessa chiave di shard della tabella sottoposta a sharding originale, incluse le stesse colonne e tipi di dati. + `sharded_table`: la tabella sottoposta a sharding con cui stai co-localizzando `collocated_table`. **Per creare una tabella co-localizzata** 1. Crea la prima tabella sottoposta a sharding seguendo la procedura in [Creazione di tabelle sottoposte a sharding](#limitless-creating-sharded). 1. Crea la tabella standard per la tabella co-localizzata. ``` CREATE TABLE mytable2 (customer_id INT PRIMARY KEY NOT NULL, column1 INT, column2 VARCHAR); ``` 1. Converti la tabella standard in una tabella co-localizzata. ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('public.mytable2', ARRAY['customer_id'], 'public.customer'); postgres=> \d List of relations Schema | Name | Type | Owner --------+--------------+-------------------+-------------------- public | customer | partitioned table | postgres_limitless public | customer_fs1 | foreign table | postgres_limitless public | customer_fs2 | foreign table | postgres_limitless public | customer_fs3 | foreign table | postgres_limitless public | customer_fs4 | foreign table | postgres_limitless public | customer_fs5 | foreign table | postgres_limitless public | mytable2 | partitioned table | postgres_limitless public | mytable2_fs1 | foreign table | postgres_limitless public | mytable2_fs2 | foreign table | postgres_limitless public | mytable2_fs3 | foreign table | postgres_limitless public | mytable2_fs4 | foreign table | postgres_limitless public | mytable2_fs5 | foreign table | postgres_limitless (12 rows) ``` ## Creazione di tabelle di riferimento Crea tabelle di riferimento eseguendo la procedura `rds_aurora.limitless_alter_table_type_reference` su tabelle standard. Questa procedura replica una determinata tabella su tutti gli shard del gruppo di shard del database e ne cambia il tipo in tabella di riferimento. La procedura viene eseguita in modalità sincrona e acquisisce un blocco `ACCESS EXCLUSIVE` sulla tabella. Al termine corretto della procedura, la tabella standard di origine viene eliminata e una tabella di riferimento con lo stesso nome diventa disponibile. La procedura `rds_aurora.limitless_alter_table_type_reference` utilizza la seguente sintassi: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_reference('schema.table'); ``` La procedura archiviata richiede i seguenti parametri: + `schema`: lo schema del database che contiene le tabelle da replicare. Se lo schema non è specificato, la procedura utilizza `search_path`. + `table`: la tabella da replicare. **Nota** La tabella standard da cui crei la tabella di riferimento deve avere una chiave primaria. Nelle tabelle di riferimento, il vincolo `CHECK` non supporta le espressioni. La funzione precedente, `limitless_table_alter_type_reference`, è obsoleta. **Per creare una tabella di riferimento** L’esempio seguente mostra come creare la tabella di riferimento `zipcodes`. 1. Crea la tabella standard. ``` CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR); ``` 1. Converti la tabella standard in una tabella di riferimento. ``` CALL rds_aurora.limitless_alter_table_type_reference('public.zipcodes'); postgres=> \d List of relations Schema | Name | Type | Owner --------+--------------+-------------------+-------------------- public | customer | partitioned table | postgres_limitless public | customer_fs1 | foreign table | postgres_limitless public | customer_fs2 | foreign table | postgres_limitless public | customer_fs3 | foreign table | postgres_limitless public | customer_fs4 | foreign table | postgres_limitless public | customer_fs5 | foreign table | postgres_limitless public | zipcodes | foreign table | postgres_limitless (7 rows) ``` L’output mostra la tabella sottoposta a sharding `customer` e la tabella di riferimento `zipcodes`. # Schemi di esempio di Aurora PostgreSQL Limitless Database. Forniamo i seguenti schemi di esempio per Aurora PostgreSQL Limitless Database: + [Limitless E-Commerce sample schema](https://github.com/aws-samples/sample-schemas-for-amazon-aurora-postgresql-limitless-database/tree/main/limitless_ec_sample_schema) + [Limitless pgbench](https://github.com/aws-samples/sample-schemas-for-amazon-aurora-postgresql-limitless-database/tree/main/limitless_pgbench) È possibile utilizzare questi schemi per creare rapidamente un database di esempio e caricare i dati nelle tabelle di Aurora PostgreSQL Limitless Database. Per ulteriori informazioni, consulta il [repository GitHub](https://github.com/aws-samples/sample-schemas-for-amazon-aurora-postgresql-limitless-database).