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. # Funktionen für Aurora PostgreSQL Limitless Database In der folgenden Tabelle sehen Sie die neuen Funktionen für Aurora PostgreSQL Limitless Database. **Anmerkung** Die in dieser Tabelle aufgeführten Funktionen befinden sich im Schema `rds_aurora`. Wenn Sie eine Limitless-Database-Funktion verwenden, stellen Sie sicher, dass Sie den vollqualifizierten Objektnamen angeben: `rds_aurora`.`object_name`. | Funktion für Aurora PostgreSQL Limitless Database | Entsprechende Funktion für Aurora PostgreSQL | | --- | --- | | [limitless\$1backend\$1dsid](#limitless_backend_dsid) | pg\$1backend\$1pid | | [limitless\$1cancel\$1session](#limitless_cancel_session) | pg\$1cancel\$1backend | | [limitless\$1stat\$1clear\$1snapshot](#limitless_stat_clear_snapshot) | pg\$1stat\$1clear\$1snapshot | | [limitless\$1stat\$1database\$1size](#limitless_stat_database_size) | pg\$1database\$1size | | [limitless\$1stat\$1get\$1snapshot\$1timestamp](#limitless_stat_get_snapshot_timestamp) | pg\$1stat\$1get\$1snapshot\$1timestamp | | [limitless\$1stat\$1prepared\$1xacts](#limitless_stat_prepared_xacts) | pg\$1prepared\$1xacts | | [limitless\$1stat\$1relation\$1sizes](#limitless_stat_relation_sizes) | pg\$1indexes\$1size, pg\$1relation\$1size, pg\$1table\$1size, pg\$1total\$1relation\$1size | | [limitless\$1stat\$1reset](#limitless_stat_reset) | pg\$1stat\$1reset | | [limitless\$1stat\$1statements\$1reset](#limitless_stat_statements_reset) | pg\$1stat\$1statements\$1reset | | [limitless\$1stat\$1system\$1waits](#limitless_stat_system_waits) | aurora\$1stat\$1system\$1waits | | [limitless\$1terminate\$1session](#limitless_terminate_session) | pg\$1terminate\$1backend | | [limitless\$1wait\$1report](#limitless_wait_report) | aurora\$1wait\$1report | Die folgenden Beispiele enthalten Einzelheiten zu den Funktionen für Aurora PostgreSQL Limitless Database. Weitere Informationen zu PostgreSQL-Funktionen finden Sie unter [Funktionen und Operatoren](https://www.postgresql.org/docs/15/functions.html) in der PostgreSQL-Dokumentation. **limitless\$1backend\$1dsid** Die Funktion `limitless_backend_dsid` gibt die ID der verteilten Sitzung zurück. Eine verteilte Sitzung wird auf einem Router in einer DB-Shard-Gruppe ausgeführt und umfasst Backend-Prozesse auf einem oder mehreren Shards in der DB-Shard-Gruppe. Das folgende Beispiel zeigt, wie die Funktion `limitless_backend_dsid` verwendet werden kann. ``` SELECT rds_aurora.limitless_backend_dsid(); limitless_backend_dsid ------------------------ 8CACD7B04D0FC2A5 (1 row) ``` **limitless\$1cancel\$1session** Die Funktion `limitless_cancel_session` arbeitet ähnlich wie `pg_cancel_backend`, versucht aber, alle Backend-Prozesse im Zusammenhang mit der angegebenen ID einer verteilten Sitzung abzubrechen, indem sie ein `SIGINT` (Unterbrechungssignal) sendet. Es wird der folgende Eingabeparameter verwendet: + `distributed_session_id` (Text): Die ID der verteilten Sitzung, die abgebrochen werden soll. Es werden folgende Ausgabeparameter verwendet: + `subcluster_id` (Text): Die ID des Subclusters, zu dem dieser Prozess gehört. + `pid` (Text): Die ID des Backend-Prozesses. + `success` (Boolean): Ob der Abbruch erfolgreich war. Das folgende Beispiel zeigt, wie die Funktion `limitless_cancel_session` verwendet werden kann. ``` SELECT * FROM rds_aurora.limitless_cancel_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1stat\$1clear\$1snapshot** Die Funktion `limitless_stat_clear_snapshot` verwirft den aktuellen Statistik-Snapshot oder die zwischengespeicherten Informationen auf allen Knoten. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_clear_snapshot` verwendet werden kann. ``` SELECT rds_aurora.limitless_stat_clear_snapshot(); ``` **limitless\$1stat\$1database\$1size** Die Funktion `limitless_stat_database_size` gibt die Größen einer Datenbank in der DB-Shard-Gruppe zurück. Es wird der folgende Eingabeparameter verwendet: + `dbname` (Name): Die Datenbank, für die die Größen abgerufen werden sollen. Es werden folgende Ausgabeparameter verwendet: + `subcluster_id` (Text): Die ID des Subclusters, zu dem dieser Prozess gehört. + `subcluster_type` (Text): Der Typ des Subclusters, zu dem dieser Prozess gehört: `router` oder `shard`. + `db_size`: Die Größe der Datenbank in diesem Subcluster in Byte. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_database_size` verwendet werden kann. ``` SELECT * FROM rds_aurora.limitless_stat_database_size('postgres_limitless'); subcluster_id | subcluster_type | db_size ---------------+-----------------+---------- 1 | router | 8895919 2 | router | 8904111 3 | shard | 21929391 4 | shard | 21913007 5 | shard | 21831087 (5 rows) ``` **limitless\$1stat\$1get\$1snapshot\$1timestamp** Die Funktion `limitless_stat_get_snapshot_timestamp` gibt den Zeitstempel des aktuellen Statistik-Snapshots zurück, oder `NULL`, wenn kein Statistik-Snapshot erstellt wurde. Ein Snapshot wird erstellt, wenn in einer Transaktion zum ersten Mal auf kumulative Statistiken zugegriffen wird, sofern `stats_fetch_consistency` auf `snapshot` gesetzt ist. Gibt eine konsolidierte Ansicht der Snapshot-Zeitstempel von allen Knoten zurück. Die Spalten `subcluster_id` und `subcluster_type` zeigen, von welchem Knoten die Daten stammen. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_get_snapshot_timestamp` verwendet werden kann. ``` SELECT * FROM rds_aurora.limitless_stat_get_snapshot_timestamp(); subcluster_id | subcluster_type | snapshot_timestamp ---------------+-----------------+-------------------- 1 | router | 2 | router | 3 | shard | 4 | shard | 5 | shard | (5 rows) ``` **limitless\$1stat\$1prepared\$1xacts** Die Funktion `limitless_stat_prepared_xacts` gibt Informationen über Transaktionen auf allen Knoten zurück, die derzeit für ein zweiphasiges Commit vorbereitet sind. Weitere Informationen finden Sie unter [pg\$1prepared\$1xacts](https://www.postgresql.org/docs/current/view-pg-prepared-xacts.html) in der PostgreSQL-Dokumentation. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_prepared_xacts` verwendet werden kann. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_prepared_xacts; subcluster_id | subcluster_type | transaction_id | gid | prepared | owner_id | database_id ---------------+-----------------+----------------+------------------------------+-------------------------------+------------+-------------------- 8 | shard | 5815978 | 7_4599899_postgres_limitless | 2024-09-03 15:51:17.659603+00 | auroraperf | postgres_limitless 12 | shard | 4599138 | 7_4599899_postgres_limitless | 2024-09-03 15:51:17.659637+00 | auroraperf | postgres_limitless (2 rows) ``` **limitless\$1stat\$1relation\$1sizes** Die Funktion `limitless_stat_relation_sizes` gibt die verschiedenen Größen einer Tabelle in der DB-Shard-Gruppe zurück. Es werden folgende Eingabeparameter verwendet: + `relnspname` (Name): Der Name des Schemas, das die Tabelle enthält. + `relname` (Name): Der Name der Tabelle. Es werden folgende Ausgabeparameter verwendet: + `subcluster_id` (Text): Die ID des Subclusters, zu dem dieser Prozess gehört. + `subcluster_type` (Text): Der Typ des Subclusters, zu dem dieser Prozess gehört: `router` oder `shard`. + `main_size`: Die Größe der Haupt-Datenzweige in diesem Knoten in Byte. + `fsm_size`: Die Größe der Free-Space-Map für die Tabelle in diesem Knoten in Byte. + `vm_size`: Die Größe der Sichtbarkeits-Map für die Tabelle in diesem Knoten in Byte. + `init_size`: Die Größe der Initialisierung der Tabelle in diesem Knoten in Byte. + `toast_size`: Die Größe der Toast-Tabelle in Byte, die der Tabelle in diesem Zweig zugeordnet ist. + `index_size`: Die Größe aller Indizes für die Tabelle in diesem Knoten in Byte. + `total_size`: Die Größe aller Tabellensegmente in diesem Knoten in Byte. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_relation_sizes` verwendet werden kann (einige Spalten wurden weggelassen). ``` SELECT * FROM rds_aurora.limitless_stat_relation_sizes('public','customers'); subcluster_id | subcluster_type | main_size | fsm_size | vm_size | toast_size | table_size | total_size ---------------+-----------------+-----------+----------+---------+------------+------------+------------ 1 | router | 0 | 0 | 0 | 0 | 0 | 0 2 | router | 0 | 0 | 0 | 0 | 0 | 0 3 | shard | 4169728 | 4177920 | 1392640 | 1392640 | 11132928 | 11132928 4 | shard | 4169728 | 4177920 | 1392640 | 1392640 | 11132928 | 11132928 5 | shard | 3981312 | 4227072 | 1409024 | 1409024 | 11026432 | 11026432 (5 rows) ``` **limitless\$1stat\$1reset** Die Funktion `limitless_stat_reset` setzt alle Statistikzähler für die aktuelle Datenbank auf Null (0) zurück. Wenn `track_functions` aktiviert ist, zeigt die Spalte `stats_reset` in `limitless_stat_database` an, wann die Statistiken für die Datenbank zuletzt zurückgesetzt wurden. `limitless_stat_reset` kann standardmäßig nur von einem Superuser ausgeführt werden. Anderen Benutzern kann mithilfe des Privilegs `EXECUTE` eine entsprechende Berechtigung erteilt werden. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_reset` verwendet werden kann. ``` SELECT tup_inserted, tup_deleted FROM pg_stat_database WHERE datname = 'postgres_limitless'; tup_inserted | tup_deleted --------------+------------- 896 | 0 (1 row) SELECT rds_aurora.limitless_stat_reset(); limitless_stat_reset --------------------- (1 row) SELECT tup_inserted, tup_deleted FROM pg_stat_database WHERE datname = 'postgres_limitless'; tup_inserted | tup_deleted -------------+------------- 0 | 0 (1 row) ``` **limitless\$1stat\$1statements\$1reset** Die Funktion `limitless_stat_statements_reset` verwirft Statistiken, die inzwischen von `limitless_stat_statements` erfasst wurden, für die festgelegten Parameter `username`, `dbname`, `distributed_query_id` und `queryid`. Wenn einer der Parameter nicht angegeben ist, wird für jeden Parameter der Standardwert `""` oder `0` (ungültig) verwendet, und die Statistiken, die mit anderen Parametern übereinstimmen, werden zurückgesetzt. Wenn kein Parameter angegeben ist oder alle angegebenen Parameter `""` oder `0` (ungültig) lauten, verwirft die Funktion alle Statistiken. Wenn alle Statistiken in der Ansicht `limitless_stat_statements` verworfen werden, setzt die Funktion auch die Statistiken in der Ansicht `limitless_stat_statements_info` zurück. Es werden folgende Eingabeparameter verwendet: + `username` (Name): Der Benutzer, der die Anweisung abgefragt hat. + `dbname` (Name): Die Datenbank, in der die Abfrage ausgeführt wurde. + `distributed_query_id` (bigint): Die Abfrage-ID der übergeordneten Abfrage vom Koordinatorknoten. Diese Spalte lautet `NULL`, wenn es sich um die übergeordnete Abfrage handelt. Der Koordinatorknoten gibt die ID der verteilten Abfrage an die teilnehmenden Knoten weiter. Für die Teilnehmerknoten sind die Werte für die ID der verteilten Abfrage und die ID der Abfrage also unterschiedlich. + `queryid` (bigint): Die Abfrage-ID der Anweisung. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_statements_reset` verwendet wird, um alle von `limitless_stat_statements` erfassten Statistiken zurückzusetzen. ``` SELECT rds_aurora.limitless_stat_statements_reset(); ``` **limitless\$1stat\$1system\$1waits** Die Funktion `limitless_stat_system_waits` gibt eine konsolidierte Ansicht der Warteereignisdaten aus `aurora_stat_system_waits` von allen Knoten zurück, die systemweite Warteaktivitäten in einer Instance meldet. Die Spalten `subcluster_id` und `subcluster_type` zeigen, von welchem Knoten die Daten stammen. Das folgende Beispiel zeigt, wie die Funktion `limitless_stat_system_waits` verwendet werden kann. ``` postgres_limitless=> SELECT * FROM rds_aurora.limitless_stat_system_waits() lssw, pg_catalog.aurora_stat_wait_event() aswe WHERE lssw.event_id=aswe.event_id and aswe.event_name='LimitlessTaskScheduler'; subcluster_id | subcluster_type | type_id | event_id | waits | wait_time | event_name ---------------+-----------------+---------+-----------+--------+--------------+------------------------ 1 | router | 12 | 201326607 | 677068 | 616942216307 | LimitlessTaskScheduler 2 | router | 12 | 201326607 | 678586 | 616939897111 | LimitlessTaskScheduler 3 | shard | 12 | 201326607 | 756640 | 616965545172 | LimitlessTaskScheduler 4 | shard | 12 | 201326607 | 755184 | 616958057620 | LimitlessTaskScheduler 5 | shard | 12 | 201326607 | 757522 | 616963183539 | LimitlessTaskScheduler (5 rows) ``` **limitless\$1terminate\$1session** Die Funktion `limitless_terminate_session` arbeitet ähnlich wie `pg_terminate_backend`, versucht aber, alle Backend-Prozesse im Zusammenhang mit der angegebenen ID einer verteilten Sitzung zu beenden, indem sie ein `SIGTERM` (Beendigungssignal) sendet. Es wird der folgende Eingabeparameter verwendet: + `distributed_session_id` (Text): Die ID der verteilten Sitzung, die beendet werden soll. Es werden folgende Ausgabeparameter verwendet: + `subcluster_id` (Text): Die ID des Subclusters, zu dem dieser Prozess gehört. + `pid` (Text): Die ID des Backend-Prozesses. + `success` (Boolean): Ob der Prozess erfolgreich beendet wurde. Das folgende Beispiel zeigt, wie die Funktion `limitless_terminate_session` verwendet werden kann. ``` SELECT * FROM rds_aurora.limitless_terminate_session('940CD5C81E3C796B'); subcluster_id | pid | success ---------------+-------+--------- 1 | 26920 | t (1 row) ``` **limitless\$1wait\$1report** Die Funktion `limitless_wait_report` gibt die Aktivität „Warteereignis“ über einen bestimmten Zeitraum von allen Knoten zurück. Die Spalten `subcluster_id` und `subcluster_type` zeigen, von welchem Knoten die Daten stammen. Es werden folgende Ausgabeparameter verwendet: + `subcluster_id` (Text): Die ID des Subclusters, zu dem dieser Prozess gehört. + `subcluster_type` (Text): Der Typ des Subclusters, zu dem dieser Prozess gehört: `router` oder `shard`. Die restlichen Spalten sind dieselben wie in `aurora_wait_report`. Das folgende Beispiel zeigt, wie die Funktion `limitless_wait_report` verwendet werden kann. ``` postgres_limitless=> select * from rds_aurora.limitless_wait_report(); subcluster_id | subcluster_type | type_name | event_name | waits | wait_time | ms_per_wait | waits_per_xact | ms_per_xact ---------------+-----------------+-----------+------------+-------+-----------+-------------+--------------- +------------- 1 | router | Client | ClientRead | 57 | 741550.14 | 13009.652 | 0.19 | 2505.237 5 | shard | Client | ClientRead | 54 | 738897.68 | 13683.290 | 0.18 | 2496.276 4 | shard | Client | ClientRead | 54 | 738859.53 | 13682.584 | 0.18 | 2496.147 2 | router | Client | ClientRead | 53 | 719223.64 | 13570.257 | 0.18 | 2429.810 3 | shard | Client | ClientRead | 54 | 461720.40 | 8550.378 | 0.18 | 1559.86 ```