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à. # 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`.