Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Erstellen von Tabellen in Aurora PostgreSQL Limitless Database Es gibt in Aurora PostgreSQL Limitless Database drei Arten von Tabellen, die Ihre Daten enthalten: + Standard: Sie sind der Standardtabellentyp in Aurora PostgreSQL Limitless Database. Sie erstellen Standardtabellen mit dem Befehl [CREATE TABLE](https://www.postgresql.org/docs/current/sql-createtable.html) und können DDL-Operationen (Data Description Language) und DML-Operationen (Data Manipulation Language) an ihnen ausführen. Standardtabellen sind keine verteilten Tabellen. Sie werden auf einem der vom System intern ausgewählten Shards gespeichert. + Sharded: Diese Tabellen sind auf mehrere Shards verteilt. Die Daten werden auf Grundlage der Werte der angegebenen Spalten in der Tabelle auf die Shards aufgeteilt. Dieser Satz von Spalten wird als Shard-Schlüssel bezeichnet. + Referenz: Diese Tabellen werden auf allen Shards repliziert. Sie werden für selten geänderte Referenzdaten wie Produktkataloge und Postleitzahlen verwendet. Auf Shards können Join-Abfragen zwischen Referenz- und Shard-Tabellen ausgeführt werden, wodurch unnötige Datenbewegungen zwischen Shards und Routern vermieden werden. Es gibt zwei Möglichkeiten, Limitless-Tabellen zu erstellen: + [Erstellen von Limitless-Tabellen mithilfe von Variablen](limitless-creating-config.md): Verwenden Sie diese Methode, wenn Sie neue Sharded- und Referenz-Tabellen erstellen möchten. + [Konvertieren von Standardtabellen in Limitless-Tabellen](limitless-converting-standard.md): Verwenden Sie diese Methode, wenn Sie bestehende Standardtabellen in Sharded-und Referenztabellen konvertieren möchten. Wir bieten auch [Beispielschemata](limitless-sample-schemas.md) für Aurora PostgreSQL Limitless Database. # Erstellen von Limitless-Tabellen mithilfe von Variablen Sie können mit Variablen Sharded- und Referenztabellen erstellen, indem Sie den Modus zur Tabellenerstellung festlegen. Die von Ihnen erstellten Tabellen verwenden dann diesen Modus, bis Sie einen anderen festlegen. Verwenden Sie die folgenden Variablen, um Sharded- und Referenztabellen zu erstellen: + `rds_aurora.limitless_create_table_mode`: Legen Sie diese Sitzungsvariable auf `sharded` oder `reference` fest. Der Standardwert dieser Variable lautet `standard`. + `rds_aurora.limitless_create_table_shard_key`: Legen Sie für diese Sitzungsvariable ein Array von Spaltennamen fest, die als Shard-Schlüssel verwendet werden sollen. Diese Variable wird ignoriert, wenn `rds_aurora.limitless_create_table_mode` nicht `sharded` ist. Formatieren Sie den Wert als `untyped array literal`, ähnlich wie beim Einfügen von Literalen in eine Array-Spalte. Weitere Informationen finden Sie unter [Arrays](https://www.postgresql.org/docs/current/arrays.html) in der PostgreSQL-Dokumentation. + `rds_aurora.limitless_create_table_collocate_with`: Legen Sie für diese Sitzungsvariable einen bestimmten Tabellennamen fest, um neu erstellte Tabellen dieser Tabelle zuzuordnen. Wenn zwei oder mehr Tabellen mit demselben Shard-Schlüssel „gesharded“ werden, können Sie diese Tabellen explizit einander zuordnen (zusammenfassen). Wenn zwei oder mehr Tabellen zusammengefasst werden, werden Zeilen aus diesen Tabellen mit denselben Shard-Schlüsselwerten auf demselben Shard platziert. Die Zusammenfassung hilft dabei, einige Operationen auf einen einzigen Shard zu beschränken, was zu einer besseren Leistung führt. **Anmerkung** Alle primären und eindeutigen Schlüssel müssen den Shard-Schlüssel enthalten. Das bedeutet, dass der Shard-Schlüssel eine Teilmenge des primären oder eindeutigen Schlüssels ist. Limitless-Tabellen haben einige Einschränkungen. Weitere Informationen finden Sie unter [DDL-Einschränkungen und andere Informationen für Aurora PostgreSQL Limitless Database](limitless-reference.DDL-limitations.md). **Topics** + [Beispiele für die Verwendung von Variablen zur Erstellung von Limitless-Tabellen](#limitless-tables-examples) + [Tabellenansichten für Aurora PostgreSQL Limitless Database](#limitless-table-views) ## Beispiele für die Verwendung von Variablen zur Erstellung von Limitless-Tabellen In den folgenden Beispielen wird gezeigt, wie Sie diese Variablen verwenden, um Sharded- und Referenztabellen zu erstellen. Erstellen Sie eine Sharded-Tabelle mit dem Namen `items` und dem Shard-Schlüssel `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; ``` Erstellen Sie eine Sharded-Tabelle mit dem Namen `items` und einem Shard-Schlüssel, der sich aus den Spalten `item_id` und `item_cat` zusammensetzt. ``` 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; ``` Erstellen Sie eine Sharded-Tabelle mit dem Namen `item_description` und einem Shard-Schlüssel, der sich aus den `item_id` und `item_cat` zusammensetzt, und ordnen Sie sie der Tabelle `items` aus dem vorherigen Beispiel zu. ``` 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; ``` Erstellen Sie eine Referenztabelle mit dem Namen `colors`. ``` BEGIN; SET LOCAL rds_aurora.limitless_create_table_mode='reference'; CREATE TABLE colors(color_id int primary key, color varchar); COMMIT; ``` Verwenden Sie die folgende Anweisung, um die Sitzungsvariable `rds_aurora.limitless_create_table_mode` auf `standard` zurückzusetzen: ``` RESET rds_aurora.limitless_create_table_mode; ``` Nachdem Sie diese Variable zurückgesetzt haben, werden Tabellen als Standardtabellen erstellt, was der Standardeinstellung entspricht. Weitere Informationen zu Standardtabellen finden Sie unter [Konvertieren von Standardtabellen in Limitless-Tabellen](limitless-converting-standard.md). ## Tabellenansichten für Aurora PostgreSQL Limitless Database Informationen zu Limitless-Database-Tabellen finden Sie anhand der folgenden Ansichten. **rds\$1aurora.limitless\$1tables** Die Ansicht `rds_aurora.limitless_tables` enthält Informationen über Limitless-Tabellen und deren Typen. ``` 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** Die Ansicht `rds_aurora.limitless_table_collocations` enthält Informationen über zusammengefasste Sharded-Tabellen. Zum Beispiel sind die Tabellen `orders` und `customers` zusammengefasst und haben die gleiche `collocation_id`. Die Tabellen `users` und `followers` sind zusammengefasst und haben die gleiche `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** Das Ansicht `rds_aurora.limitless_table_collocation_distributions` zeigt die Schlüsselverteilung für jede Kollokation. ``` 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) ``` # Konvertieren von Standardtabellen in Limitless-Tabellen Sie können Standardtabellen in Sharded- oder Referenztabellen konvertieren. Während der Konvertierung werden Daten aus der Standardtabelle in die verteilte Tabelle verschoben. Anschließend wird die Quell-Standardtabelle gelöscht. Daten werden mit dem Befehl `INSERT INTO SELECT FROM` verschoben. **Contents** + [Erstellen von Sharded-Tabellen](#limitless-creating-sharded) + [Erstellen von zusammengefassten Tabellen](#limitless-creating-sharded.colocated) + [Erstellen von Referenztabellen](#limitless-creating-reference) ## Erstellen von Sharded-Tabellen Sie erstellen Sharded-Tabellen, indem Sie das Verfahren `rds_aurora.limitless_alter_table_type_sharded` für Standardtabellen ausführen. Dieses Verfahren verwendet eine Standardtabelle und eine Liste von Spalten und verteilt dann die angegebene Tabelle, wobei die Spaltenliste als Shard-Schlüssel verwendet wird. Das Verfahren wird synchron ausgeführt und erwirbt eine `ACCESS EXCLUSIVE`-Sperre für die Tabelle. Nachdem das Verfahren erfolgreich abgeschlossen wurde, wird die Quell-Standardtabelle gelöscht, und eine Shard-Tabelle mit demselben Namen wird verfügbar. Das Verfahren `rds_aurora.limitless_alter_table_type_sharded` verwendet die folgende Syntax: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('schema.table', ARRAY['shard_key1', 'shard_key2', ... 'shard_keyn']); ``` Das Verfahren erfordert die folgenden Parameter: + `schema`: Das Datenbankschema, das die Tabelle enthält, die „gesharded“ werden soll. Wenn das Schema nicht angegeben ist, verwendet das Verfahren den `search_path`. + `table`: Die Tabelle, die „gesharded“ werden soll. + `shard_keyn`: Eine Reihe von Tabellenspalten, die als Shard-Schlüssel verwendet werden sollen. Shard-Schlüsselwerte sind Zeichenkettenliterale und unterscheiden daher zwischen Groß- und Kleinschreibung. Wenn ein Shard-Schlüssel ein einfaches Anführungszeichen (') enthält, verwenden Sie ein anderes einfaches Anführungszeichen, um es aufzuheben. Wenn beispielsweise eine Tabellenspalte `customer's id` genannt wird, verwenden Sie `customer''s id` als Shard-Schlüssel. Backslashes (\$1) und doppelte Anführungszeichen (") müssen nicht aufgehoben werden. **Anmerkung** Alle primären und eindeutigen Schlüssel müssen den Shard-Schlüssel enthalten. Das bedeutet, dass der Shard-Schlüssel eine Teilmenge des primären oder eindeutigen Schlüssels ist. In Shard-Tabellen unterstützt die Einschränkung `CHECK` keine Ausdrücke. Weitere Informationen finden Sie unter [Beschränkungen](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Constraints). **So erstellen Sie eine Sharded-Tabelle** Das folgende Beispiel zeigt, wie Sie die Sharded-Tabelle `customer` mit dem Shard-Schlüssel `customer_id` erstellen. 1. Erstellen Sie die Standardtabelle. ``` CREATE TABLE customer (customer_id INT PRIMARY KEY NOT NULL, zipcode INT, email VARCHAR); ``` 1. Konvertieren Sie die Standardtabelle in eine Sharded-Tabelle. ``` 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) ``` ## Erstellen von zusammengefassten Tabellen Wenn zwei oder mehr Tabellen mit demselben Shard-Schlüssel „gesharded“ werden, können Sie diese Tabellen explizit einander zuordnen (zusammenfassen). Wenn zwei oder mehr Tabellen zusammengefasst werden, werden Zeilen aus diesen Tabellen mit denselben Shard-Schlüsselwerten auf demselben Shard platziert. Die Zusammenfassung hilft dabei, einige Operationen auf einen einzigen Shard zu beschränken, was zu einer besseren Leistung führt. Sie verwenden das Verfahren `rds_aurora.limitless_alter_table_type_sharded` mit der folgenden Syntax: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('schema.collocated_table', ARRAY['shard_key1', 'shard_key2', ... 'shard_keyn'], 'schema.sharded_table'); ``` Das Verfahren erfordert die folgenden Parameter: + `schema`: Das Datenbankschema, das die zusammenzufassenden Tabellen enthält. Wenn das Schema nicht angegeben ist, verwendet das Verfahren den `search_path`. + `collocated_table`: Die Tabelle, die mit der anderen zusammengefasst werden soll. + `shard_keyn`: Eine Reihe von Tabellenspalten, die als Shard-Schlüssel verwendet werden sollen. Sie müssen denselben Shard-Schlüssel wie für die ursprüngliche Sharded-Tabelle verwenden, einschließlich derselben Spaltennamen und Spaltentypen. + `sharded_table`: Die Sharded-Tabelle, mit der Sie die `collocated_table` zusammenfassen. **So erstellen Sie eine zusammengefasste Tabelle** 1. Erstellen Sie die erste Sharding-Tabelle, indem Sie das Verfahren in [Erstellen von Sharded-Tabellen](#limitless-creating-sharded) befolgen. 1. Erstellen Sie die Standardtabelle für die zusammengefasste Tabelle. ``` CREATE TABLE mytable2 (customer_id INT PRIMARY KEY NOT NULL, column1 INT, column2 VARCHAR); ``` 1. Konvertieren Sie die Standardtabelle in eine zusammengefasste Tabelle. ``` 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) ``` ## Erstellen von Referenztabellen Sie erstellen Referenztabellen, indem Sie das Verfahren `rds_aurora.limitless_alter_table_type_reference` für Standardtabellen ausführen. Dieses Verfahren repliziert eine bestimmte Tabelle auf alle Shards in der DB-Shard-Gruppe und ändert den Tabellentyp in „Referenz“. Das Verfahren wird synchron ausgeführt und erwirbt eine `ACCESS EXCLUSIVE`-Sperre für die Tabelle. Nachdem das Verfahren erfolgreich abgeschlossen wurde, wird die Quell-Standardtabelle gelöscht, und eine Referenztabelle mit demselben Namen wird verfügbar. Das Verfahren `rds_aurora.limitless_alter_table_type_reference` verwendet die folgende Syntax: ``` postgres=> CALL rds_aurora.limitless_alter_table_type_reference('schema.table'); ``` Das gespeicherte Verfahren erfordert die folgenden Parameter: + `schema`: Das Datenbankschema, das die Tabelle enthält, die repliziert werden soll. Wenn das Schema nicht angegeben ist, verwendet das Verfahren den `search_path`. + `table`: Die Tabelle, die repliziert werden soll. **Anmerkung** Die Standardtabelle, aus der Sie die Referenztabelle erstellen, muss über einen Primärschlüssel verfügen. In Referenztabellen unterstützt die Einschränkung `CHECK` keine Ausdrücke. Die vorherige Funktion, `limitless_table_alter_type_reference`, ist veraltet. **So erstellen Sie eine Referenztabelle** Das folgende Beispiel zeigt, wie Sie die Referenztabelle `zipcodes` erstellen. 1. Erstellen Sie die Standardtabelle. ``` CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR); ``` 1. Konvertieren Sie die Standardtabelle in eine Referenztabelle. ``` 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) ``` Die Ausgabe zeigt die Sharded-Tabelle `customer` und die Referenztabelle `zipcodes`. # Beispielschemata für Aurora PostgreSQL Limitless Database Wir stellen Ihnen die folgenden Beispielschemata für Aurora PostgreSQL Limitless Database zur Verfügung: + [Beispielschema für Limitless E-Commerce](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) Sie können diese Schemata verwenden, um schnell eine Beispieldatenbank zu erstellen und Daten in Tabellen von Aurora PostgreSQL Limitless Database zu laden. Weitere Informationen finden Sie im [GitHub-Repository](https://github.com/aws-samples/sample-schemas-for-amazon-aurora-postgresql-limitless-database).