Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Conversion de tables standard en tables sans limite Vous pouvez convertir des tables standard en tables partitionnées ou en tables de référence. Pendant la conversion, les données sont déplacées de la table standard vers la table distribuée, après quoi la table source est supprimée. Les données sont déplacées à l’aide de la commande `INSERT INTO SELECT FROM`. **Contents** + [Création de tables partitionnées](#limitless-creating-sharded) + [Création de tables colocalisées](#limitless-creating-sharded.colocated) + [Création de tables de référence](#limitless-creating-reference) ## Création de tables partitionnées Vous créez des tables partitionnées en exécutant la procédure `rds_aurora.limitless_alter_table_type_sharded` sur des tables standard. La procédure utilise une table standard et une liste de colonnes, qu’elle utilise comme clé de partition pour distribuer la table. La procédure s’exécute de manière synchrone et applique un verrouillage `ACCESS EXCLUSIVE` sur la table. Une fois la procédure terminée, la table standard source est supprimée et une table partitionnée portant le même nom est disponible. La procédure `rds_aurora.limitless_alter_table_type_sharded` utilise la syntaxe suivante : ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('{{schema}}.{{table}}', ARRAY['{{shard_key1}}', '{{shard_key2}}', ... '{{shard_keyn}}']); ``` La procédure nécessite les paramètres suivants : + `schema` : le schéma de base de données qui contient la table à partitionner. Si le schéma n’est pas indiqué, la procédure utilise le `search_path`. + `table` : la table à partitionner. + `shard_keyn` : un tableau de colonnes de la table à utiliser comme clé de partition. Les valeurs des clés de partition étant des littéraux de chaîne, elles sont sensibles à la casse. Si une clé de partition contient un guillemet simple (’), utilisez un autre guillemet simple pour l’échapper. Par exemple, si une colonne de table est nommée `customer's id`, utilisez `customer''s id` comme clé de partition. Il n’est pas nécessaire d’échapper les barres obliques inverses (\\) ni les guillemets doubles ("). **Note** Toutes les clés primaires et uniques doivent inclure la clé de partition. Autrement dit, la clé de partition est un sous-ensemble de la clé primaire ou unique. Dans les tables partitionnées, la contrainte `CHECK` ne prend pas en charge les expressions. Pour plus d’informations, consultez [Constaintes](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Constraints). **Pour créer une table partitionnée** L’exemple suivant montre comment créer la table partitionnée `customer` à l’aide de la clé de partition `customer_id`. 1. Créez la table standard. ``` CREATE TABLE customer (customer_id INT PRIMARY KEY NOT NULL, zipcode INT, email VARCHAR); ``` 1. Convertissez la table standard en table partitionnée. ``` 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) ``` ## Création de tables colocalisées Si deux tables ou plus sont partitionnées à l’aide de la même clé de partition, vous pouvez explicitement les aligner (colocaliser). Lorsque plusieurs tables sont colocalisées, les lignes présentant les mêmes valeurs de clé de partition sont stockées dans la même partition. La collocation permet de limiter certaines opérations à une seule partition, en vue d’améliorer les performances. La procédure `rds_aurora.limitless_alter_table_type_sharded` s’utilise la syntaxe suivante : ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('{{schema}}.{{collocated_table}}', ARRAY['{{shard_key1}}', '{{shard_key2}}', ... '{{shard_keyn}}'], '{{schema}}.{{sharded_table}}'); ``` La procédure nécessite les paramètres suivants : + `schema` : le schéma de base de données qui contient les tables à colocaliser. Si le schéma n’est pas indiqué, la procédure utilise le `search_path`. + `collocated_table` : la table à colocaliser. + `shard_keyn` : un tableau de colonnes de la table à utiliser comme clé de partition. La clé de partition doit être identique à celle de la table partitionnée d’origine, avec les mêmes noms et types de colonnes. + `sharded_table` : la table partitionnée avec laquelle vous colocalisez la `collocated_table`. **Pour créer une table colocalisée** 1. Créez la première table partitionnée en suivant la procédure décrite dans [Création de tables partitionnées](#limitless-creating-sharded). 1. Créez la table standard pour la table colocalisée. ``` CREATE TABLE mytable2 (customer_id INT PRIMARY KEY NOT NULL, column1 INT, column2 VARCHAR); ``` 1. Convertissez la table standard en table colocalisée. ``` 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) ``` ## Création de tables de référence Vous créez des tables de référence en exécutant la procédure `rds_aurora.limitless_alter_table_type_reference` sur des tables standard. Cette procédure réplique une table donnée sur toutes les partitions du groupe de partitions de base de données et modifie le type de table en référence. La procédure s’exécute de manière synchrone et applique un verrouillage `ACCESS EXCLUSIVE` sur la table. Une fois la procédure terminée, la table standard source est supprimée et une table de référence portant le même nom est disponible. La procédure `rds_aurora.limitless_alter_table_type_reference` utilise la syntaxe suivante : ``` postgres=> CALL rds_aurora.limitless_alter_table_type_reference('{{schema}}.{{table}}'); ``` La procédure stockée nécessite les paramètres suivants : + `schema` : le schéma de base de données qui contient la table à répliquer. Si le schéma n’est pas indiqué, la procédure utilise le `search_path`. + `table` : la table à répliquer. **Note** La table standard à partir de laquelle vous créez la table de référence doit disposer d’une clé primaire. Dans les tables de référence, la contrainte `CHECK` ne prend pas en charge les expressions. La fonction précédente, `limitless_table_alter_type_reference`, est obsolète. **Pour créer une référence de référence** L’exemple suivant illustre la création d’une table de référence `zipcodes`. 1. Créez la table standard. ``` CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR); ``` 1. Convertissez la table standard en table de référence. ``` 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) ``` La sortie montre la table partitionnée `customer` et la table de référence `zipcodes`.