Conversion de tables standard en tables illimitées - Amazon Aurora
Création de tableaux fragmentésCréation de tables colocaliséesCréation de tables de référence

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 illimitées

Vous pouvez convertir des tableaux standard en tableaux fragmentés ou en tableaux de référence. Au cours de la conversion, les données sont déplacées de la table standard vers la table distribuée, puis la table standard source est supprimée. Les données sont déplacées à l'aide de la INSERT INTO SELECT FROM commande.

Création de tableaux fragmentés

Vous créez des tables partitionnées en exécutant la rds_aurora.limitless_alter_table_type_sharded procédure sur des tables standard. Cette procédure prend une table standard et une liste de colonnes, puis distribue la table donnée en utilisant la liste de colonnes comme clé de partition. La procédure s'exécute de manière synchrone et acquiert un ACCESS EXCLUSIVE verrou sur la table.

Une fois la procédure terminée avec succès, la table standard source est supprimée et une table fragmentée portant le même nom est disponible.

La rds_aurora.limitless_alter_table_type_sharded procédure 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 spécifié, la procédure utilise lesearch_path.

  • table— Le tableau à découper.

  • shard_keyn— Un tableau de colonnes de table à utiliser comme clé de partition.

    Les valeurs des clés de partition sont des chaînes littérales et distinguent donc les majuscules et minuscules. Si une clé de partition contient un seul guillemet ('), utilisez un autre guillemet unique pour y échapper. Par exemple, si une colonne de table est nomméecustomer's id, customer''s id utilisez-la comme clé de partition. Il n'est pas nécessaire d'éviter les barres obliques inverses (\) et les guillemets («).

Note

Toutes les clés primaires et uniques doivent inclure la clé shard. Cela signifie que la clé de partition est un sous-ensemble de la clé primaire ou unique.

Dans les tableaux fragmentés, la CHECK contrainte ne prend pas en charge les expressions.

Pour de plus amples informations, veuillez consulter Constraints.

Pour créer un tableau fragmenté

L'exemple suivant montre comment créer le tableau fragmenté customer à l'aide de la clé de partition. customer_id

  1. Créez le tableau standard.

    CREATE TABLE customer (customer_id INT PRIMARY KEY NOT NULL, zipcode INT, email VARCHAR);

  2. Convertissez le tableau standard en tableau fragmenté.

    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 fragmentées à l'aide de la même clé de partition, vous pouvez explicitement les aligner (colocaliser) ces tables. Lorsque deux tables ou plus sont colocalisées, les lignes de ces tables avec les mêmes valeurs de clé de partition sont placées sur la même partition. La collocation permet de limiter certaines opérations à une seule partition, ce qui améliore les performances.

Vous utilisez la rds_aurora.limitless_alter_table_type_sharded procédure avec 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 spécifié, la procédure utilise lesearch_path.

  • collocated_table— La table à colocaliser.

  • shard_keyn— Un tableau de colonnes de table à utiliser comme clé de partition.

    Vous devez utiliser la même clé de partition que pour le tableau fragmenté d'origine, y compris les mêmes noms et types de colonnes.

  • sharded_table— Le tableau fragmenté avec lequel vous colocalisez le. collocated_table

Pour créer une table colocalisée

  1. Créez le premier tableau fragmenté en suivant la procédure décrite dansCréation de tableaux fragmentés.

  2. Créez le tableau standard pour le tableau colocalisé.

    CREATE TABLE mytable2 (customer_id INT PRIMARY KEY NOT NULL, column1 INT, column2 VARCHAR);

  3. Convertissez le tableau standard en un tableau colocalisé.

    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 rds_aurora.limitless_alter_table_type_reference procédure 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 acquiert un ACCESS EXCLUSIVE verrou sur la table.

Une fois la procédure terminée avec succès, la table standard source est supprimée et une table de référence portant le même nom est disponible.

La rds_aurora.limitless_alter_table_type_reference procédure 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 spécifié, la procédure utilise lesearch_path.

  • table— Table à répliquer.

Note

La table standard à partir de laquelle vous créez la table de référence doit comporter une clé primaire.

Dans les tables de référence, la CHECK contrainte ne prend pas en charge les expressions.

La fonction précédente,limitless_table_alter_type_reference, est obsolète.

Pour créer une table de référence

L'exemple suivant montre comment créer la table zipcodes de référence.

  1. Créez le tableau standard.

    CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR);

  2. Convertissez le tableau standard en tableau 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 le tableau customer fragmenté et le tableau de zipcodes référence.