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. # Integrierten Module Module sind Teil der `APPSYNC_JS` Runtime und stellen Hilfsprogramme zur Verfügung, mit denen JavaScript Resolver und Funktionen geschrieben werden können. Beispiele und Beispiele finden Sie im [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub Repository. ## Funktionen des DynamoDB-Moduls DynamoDB-Modulfunktionen bieten eine verbesserte Erfahrung bei der Interaktion mit DynamoDB-Datenquellen. Sie können mithilfe der Funktionen Anfragen an Ihre DynamoDB-Datenquellen stellen, ohne eine Typzuordnung hinzuzufügen. Module werden wie folgt importiert: `@aws-appsync/utils/dynamodb` ``` // Modules are imported using @aws-appsync/utils/dynamodb import * as ddb from '@aws-appsync/utils/dynamodb'; ``` ### Funktionen #### Funktionsliste **` get(payload: GetInput): DynamoDBGetItemRequest`** Informationen [Eingaben](#built-in-ddb-modules-inputs) zu finden Sie unter GetInput. Generiert ein `DynamoDBGetItemRequest` Objekt, um eine [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)Anfrage an DynamoDB zu stellen. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Generiert ein `DynamoDBPutItemRequest` Objekt, um eine [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)Anfrage an DynamoDB zu stellen. ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.put({ key: { id: util.autoId() }, item: ctx.args }); } ``` **`remove(payload): DynamoDBDeleteItemRequest`** Generiert ein `DynamoDBDeleteItemRequest` Objekt, um eine [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)Anfrage an DynamoDB zu stellen. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return ddb.remove({ key: { id: ctx.args.id } }); } ``` **`scan(payload): DynamoDBScanRequest`** Generiert eine`DynamoDBScanRequest`, um eine [Scan-Anfrage](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) an DynamoDB zu stellen. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken } = ctx.args; return ddb.scan({ limit, nextToken }); } ``` **`sync(payload): DynamoDBSyncRequest`** Generiert ein `DynamoDBSyncRequest` Objekt, um eine [Sync-Anfrage](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync) zu stellen. Die Anfrage empfängt nur die Daten, die seit der letzten Abfrage geändert wurden (Delta-Updates). Anfragen können nur an versionierte DynamoDB-Datenquellen gestellt werden. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken, lastSync } = ctx.args; return ddb.sync({ limit, nextToken, lastSync }); } ``` **`update(payload): DynamoDBUpdateItemRequest`** Generiert ein `DynamoDBUpdateItemRequest` Objekt, um eine [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)Anfrage an DynamoDB zu stellen. ### Operationen Mithilfe von Operationshelfern können Sie bei Aktualisierungen bestimmte Aktionen für Teile Ihrer Daten ausführen. Importieren Sie zunächst `operations` aus`@aws-appsync/utils/dynamodb`: ``` // Modules are imported using operations import {operations} from '@aws-appsync/utils/dynamodb'; ``` #### Liste der Operationen **`add(payload)`** Eine Hilfsfunktion, die beim Aktualisieren von DynamoDB ein neues Attributelement hinzufügt. **Beispiel** So fügen Sie einem vorhandenen DynamoDB-Element mithilfe des ID-Werts eine Adresse (Straße, Ort und Postleitzahl) hinzu: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { address: operations.add({ street1: '123 Main St', city: 'New York', zip: '10001', }), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`append (payload)`** Eine Hilfsfunktion, die eine Nutzlast an die bestehende Liste in DynamoDB anhängt. **Beispiel** So fügen Sie während eines Updates einen neu hinzugefügten Freund IDs (`newFriendIds`) an eine bestehende Freundesliste (`friendsIds`) an: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.append(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`decrement (by?)`** Eine Hilfsfunktion, die den vorhandenen Attributwert im Element verringert, wenn DynamoDB aktualisiert wird. **Beispiel** Um den Zähler eines Freundes () `friendsCount` um 10 zu verringern: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.decrement(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`increment (by?)`** Eine Hilfsfunktion, die den vorhandenen Attributwert im Element erhöht, wenn DynamoDB aktualisiert wird. **Beispiel** Um den Zähler eines Freundes () `friendsCount` um 10 zu erhöhen: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.increment(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`prepend (payload)`** Eine Hilfsfunktion, die der vorhandenen Liste in DynamoDB vorangestellt wird. **Beispiel** Um einen neu hinzugefügten Freund IDs (`newFriendIds`) während eines Updates einer bestehenden Freundesliste (`friendsIds`) voranzustellen: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.prepend(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`replace (payload)`** Eine Hilfsfunktion, die ein vorhandenes Attribut ersetzt, wenn ein Element in DynamoDB aktualisiert wird. Dies ist nützlich, wenn Sie das gesamte Objekt oder Unterobjekt im Attribut aktualisieren möchten und nicht nur die Schlüssel in der Nutzlast. **Beispiel** Um eine Adresse (Straße, Ort und Postleitzahl) in einem Objekt zu ersetzen: `info` ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { info: { address: operations.replace({ street1: '123 Main St', city: 'New York', zip: '10001', }), }, }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`updateListItem (payload, index)`** Eine Hilfsfunktion, die ein Element in einer Liste ersetzt. **Beispiel** Im Rahmen von update (`newFriendIds`) wurden in diesem Beispiel die `updateListItem` ID-Werte des zweiten Elements (index:`1`, neue ID:`102`) und des dritten Elements (index:`2`, neue ID:`112`) in einer Liste (`friendsIds`) aktualisiert. ``` import { update, operations as ops } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [ ops.updateListItem('102', 1), ops.updateListItem('112', 2) ]; const updateObj = { friendsIds: newFriendIds }; return update({ key: { id: 1 }, update: updateObj }); } ``` ### Eingaben #### Liste der Eingaben **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Deklaration eingeben** + `consistentRead?: boolean` (optional) Ein optionaler boolescher Wert, um anzugeben, ob Sie mit DynamoDB einen stark konsistenten Lesevorgang durchführen möchten. + `key: DynamoDBKey` (Erforderlich) Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben. **`Type PutInput`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Typ Deklaration** + `_version?: number` (optional) + `condition?: DynamoDBFilterObject | null` (optional) Wenn Sie ein Objekt in eine DynamoDB-Tabelle einfügen, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird. + `customPartitionKey?: string` (optional) Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Sync-Tabelle verwendet werden, wenn die Versionierung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. + `item: Partial` (Erforderlich) Die restlichen Attribute des Elements sollen in DynamoDB platziert werden. + `key: DynamoDBKey` (Erforderlich) Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, für das der Put ausgeführt wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben. + `populateIndexFields?: boolean` (optional) Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten und. `gsi_ds_pk` `gsi_ds_sk` Weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Geben Sie Erklärung ein** + `query: DynamoDBKeyCondition>` (Erforderlich) Gibt eine Schlüsselbedingung an, die die abzufragenden Elemente beschreibt. Für einen bestimmten Index sollte die Bedingung für einen Partitionsschlüssel eine Gleichheit und der Sortierschlüssel ein Vergleich oder ein `beginsWith` (wenn es sich um eine Zeichenfolge handelt) sein. Für Partitions- und Sortierschlüssel werden nur Zahlen- und Zeichenfolgentypen unterstützt. **Beispiel** Nehmen Sie den folgenden `User` Typ: ``` type User = { id: string; name: string; age: number; isVerified: boolean; friendsIds: string[] } ``` Die Abfrage kann nur die folgenden Felder enthalten: `id``name`, und`age`: ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Geben Sie Erklärung ein** + `_version?: number` (optional) + `condition?: DynamoDBFilterObject` (optional) Wenn Sie ein Objekt in DynamoDB entfernen, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird. **Beispiel** Das folgende Beispiel ist ein `DeleteItem` Ausdruck, der eine Bedingung enthält, die es ermöglicht, dass der Vorgang nur dann erfolgreich ist, wenn der Eigentümer des Dokuments mit dem Benutzer übereinstimmt, der die Anfrage gestellt hat. ``` type Task = { id: string; title: string; description: string; owner: string; isComplete: boolean; } const condition: DynamoDBFilterObject = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (optional) Wenn diese Option aktiviert ist, ändert der `customPartitionKey` Wert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionsverwaltung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. + `key: DynamoDBKey` (Erforderlich) Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, das entfernt wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben. **Beispiel** Wenn a `User` nur den Hash-Schlüssel mit einem Benutzer hat`id`, würde der Schlüssel wie folgt aussehen: ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { id: 1, } ``` Wenn der Tabellenbenutzer einen Hash-Schlüssel (`id`) und einen Sortierschlüssel (`name`) hat, dann würde der Schlüssel so aussehen: ``` type User = { id: number name: string age: number isVerified: boolean friendsIds: string[] } const key: DynamoDBKey = { id: 1, name: 'XXXXXXXXXX', } ``` + `populateIndexFields?: boolean` (optional) Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Sync-Tabelle erstellt, insbesondere in den Spalten `gsi_ds_pk` und`gsi_ds_sk`. **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | null; index?: string | null; limit?: number | null; nextToken?: string | null; scanIndexForward?: boolean | null; segment?: number; select?: DynamoDBSelectAttributes; totalSegments?: number; } ``` **Deklaration eingeben** + `consistentRead?: boolean | null` (optional) Ein optionaler boolescher Wert zur Angabe konsistenter Lesevorgänge bei der Abfrage von DynamoDB. Der Standardwert ist `false`. + `filter?: DynamoDBFilterObject | null` (optional) Ein optionaler Filter, der auf die Ergebnisse angewendet wird, nachdem sie aus der Tabelle abgerufen wurden. + `index?: string | null` (optional) Ein optionaler Name des zu scannenden Indexes. + `limit?: number | null` (optional) Eine optionale maximale Anzahl von Ergebnissen, die zurückgegeben werden sollen. + `nextToken?: string | null` (optional) Ein optionales Paginierungstoken, um eine vorherige Abfrage fortzusetzen. Dieses wäre von einer vorherigen Abfrage erhalten worden. + `scanIndexForward?: boolean | null` (optional) Ein optionaler boolescher Wert, der angibt, ob die Abfrage in aufsteigender oder absteigender Reihenfolge ausgeführt wird. Standardmäßig ist dieser Wert auf `true` festgelegt. + `segment?: number` (optional) + `select?: DynamoDBSelectAttributes` (optional) Von DynamoDB zurückzugebende Attribute. Standardmäßig gibt der AWS AppSync DynamoDB-Resolver nur Attribute zurück, die in den Index projiziert werden. Die unterstützten Werte sind: + `ALL_ATTRIBUTES` Gibt alle Elementattribute aus der angegebenen Tabelle oder dem angegebenen Index zurück. Wenn Sie einen lokalen sekundären Index abfragen, ruft DynamoDB für jedes übereinstimmende Element im Index das gesamte Element aus der übergeordneten Tabelle ab. Wenn der Index konfiguriert ist, um alle Elementattribute zu projizieren, können Sie alle Daten aus dem lokalen sekundären Index erhalten und das Abrufen ist nicht erforderlich. + `ALL_PROJECTED_ATTRIBUTES` Gibt alle Attribute zurück, die in den Index projiziert wurden. Wenn der Index konfiguriert ist, um alle Attribute zu projizieren, entspricht dieser Rückgabewert der Angabe von `ALL_ATTRIBUTES`. + `SPECIFIC_ATTRIBUTES` Gibt nur die in aufgeführten Attribute zurück`ProjectionExpression`. Dieser Rückgabewert entspricht der Angabe `ProjectionExpression` ohne Angabe eines Werts für`AttributesToGet`. + `totalSegments?: number` (optional) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Typ Deklaration** + `basePartitionKey?: string` (optional) Der Partitionsschlüssel der Basistabelle, der bei der Ausführung eines Sync-Vorgangs verwendet werden soll. Dieses Feld ermöglicht die Ausführung eines Synchronisierungsvorgangs, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. + `deltaIndexName?: string` (optional) Der Index, der für den Sync-Vorgang verwendet wird. Dieser Index ist erforderlich, um einen Sync-Vorgang für die gesamte Delta-Store-Tabelle zu aktivieren, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. Der Synchronisierungsvorgang wird auf der GSI (erstellt am `gsi_ds_pk` und`gsi_ds_sk`) ausgeführt. + `filter?: DynamoDBFilterObject | null` (optional) Ein optionaler Filter, der auf die Ergebnisse angewendet wird, nachdem sie aus der Tabelle abgerufen wurden. + `lastSync?: number` (optional) Der Moment in Epochen-Millisekunden, zu dem der letzte erfolgreiche Synchronisierungsvorgang gestartet wurde. Wenn angegeben, werden nur Elemente zurückgegeben, die sich nach `lastSync` geändert haben. Dieses Feld sollte erst gefüllt werden, nachdem alle Seiten eines ersten Synchronisierungsvorgangs abgerufen wurden. Wenn es weggelassen wird, werden Ergebnisse aus der Basistabelle zurückgegeben. Andernfalls werden Ergebnisse aus der Delta-Tabelle zurückgegeben. + `limit?: number | null` (optional) Eine optionale maximale Anzahl von Elementen, die gleichzeitig ausgewertet werden können. Wenn nicht angegeben, wird das Standardlimit auf `100` Elemente festgelegt. Der maximale Wert für dieses Feld ist `1000` Elemente. + `nextToken?: string | null` (optional) **`Type DynamoDBUpdateInput`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Geben Sie Erklärung ein** + `_version?: number` (optional) + `condition?: DynamoDBFilterObject` (optional) Wenn Sie ein Objekt in DynamoDB aktualisieren, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird. + `customPartitionKey?: string` (optional) Wenn diese Option aktiviert ist, ändert der `customPartitionKey` Wert das Format der `ds_pk` AND-Datensätze, die von der `ds_sk` Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert. + `key: DynamoDBKey` (Erforderlich) Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, das aktualisiert wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben. + `populateIndexFields?: boolean` (optional) Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten und. `gsi_ds_pk` `gsi_ds_sk` + `update: DynamoDBUpdateObject` Ein Objekt, das die zu aktualisierenden Attribute zusammen mit den neuen Werten für sie angibt. Das Aktualisierungsobjekt kann mit`add`,,`remove`,`replace`,`increment`,`decrement`, `append``prepend`, verwendet werden`updateListItem`. ## Funktionen des Amazon RDS-Moduls Die Funktionen des Amazon RDS-Moduls bieten eine verbesserte Benutzererfahrung bei der Interaktion mit Datenbanken, die mit der Amazon RDS-Daten-API konfiguriert sind. Das Modul wird importiert mit`@aws-appsync/utils/rds`: ``` import * as rds from '@aws-appsync/utils/rds'; ``` Funktionen können auch einzeln importiert werden. Zum Beispiel verwendet der folgende Import`sql`: ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Funktionen Sie können die Hilfsprogramme des AWS AppSync RDS-Moduls verwenden, um mit Ihrer Datenbank zu interagieren. #### Select Das `select` Hilfsprogramm erstellt eine `SELECT` Anweisung zur Abfrage Ihrer relationalen Datenbank. **Grundlegende Verwendung** In ihrer Grundform können Sie die Tabelle angeben, die Sie abfragen möchten: ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // "SELECT * FROM "persons" return createPgStatement(select({table: 'persons'})); } ``` Beachten Sie, dass Sie das Schema auch in Ihrem Tabellen-Identifier angeben können: ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // SELECT * FROM "private"."persons" return createPgStatement(select({table: 'private.persons'})); } ``` **Spalten angeben** Sie können Spalten mit der `columns` Eigenschaft angeben. Wenn dieser Wert nicht auf einen Wert gesetzt ist, wird standardmäßig wie folgt vorgegeben`*`: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'name'] })); } ``` Sie können auch die Tabelle einer Spalte angeben: ``` export function request(ctx) { // Generates statement: // SELECT "id", "persons"."name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'persons.name'] })); } ``` **Grenzwerte und Offsets** Sie können `limit` und auf `offset` die Abfrage anwenden: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // LIMIT :limit // OFFSET :offset return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], limit: 10, offset: 40 })); } ``` **Sortiert nach** Sie können Ihre Ergebnisse nach der `orderBy` Eigenschaft sortieren. Geben Sie eine Reihe von Objekten an, die die Spalte und eine optionale `dir` Eigenschaft angeben: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" FROM "persons" // ORDER BY "name", "id" DESC return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}] })); } ``` **Filter** Sie können Filter erstellen, indem Sie das Objekt mit der speziellen Bedingung verwenden: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}} })); } ``` Sie können Filter auch kombinieren: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME and "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}, id: {gt: 10}} })); } ``` Sie können auch `OR` Aussagen erstellen: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME OR "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { or: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Sie können eine Bedingung auch negieren mit`not`: ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE NOT ("name" = :NAME AND "id" > :ID) return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { not: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Sie können auch die folgenden Operatoren verwenden, um Werte zu vergleichen: | | | Operator | Description | Mögliche Wertetypen | | --- |--- |--- | | eq | Gleich | Zahl, Zeichenfolge, boolescher Wert | | Eins | Ungleich | Zahl, Zeichenfolge, boolescher Wert | | le | Kleiner als oder gleich | Zahl, Zeichenfolge | | lt | Kleiner als | Zahl, Zeichenfolge | | ge | Größer als oder gleich | Zahl, Zeichenfolge | | gt | Größer als | Zahl, Zeichenfolge | | enthält | Wie | Zeichenfolge | | Nicht enthält | Nicht wie | Zeichenfolge | | Beginnt mit | Beginnt mit einem Präfix | Zeichenfolge | | zwischen | Zwischen zwei Werten | Zahl, Zeichenfolge | | Das Attribut ist vorhanden | Das Attribut ist nicht Null | Zahl, Zeichenfolge, boolescher Wert | | size | prüft die Länge des Elements | Zeichenfolge | #### Einfügen Das `insert` Hilfsprogramm bietet eine einfache Möglichkeit, mit dem `INSERT` Vorgang einzelne Zeilenelemente in Ihre Datenbank einzufügen. **Einfügungen einzelner Elemente** Um ein Element einzufügen, geben Sie die Tabelle an und übergeben Sie dann Ihr Werteobjekt. Die Objektschlüssel sind Ihren Tabellenspalten zugeordnet. Spaltennamen werden automatisch maskiert, und Werte werden mithilfe der Variablenzuordnung an die Datenbank gesendet: ``` import { insert, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) return createMySQLStatement(insertStatement) } ``` **MySQL-Anwendungsfall** Sie können ein `insert` gefolgt von einem kombinieren`select`, um Ihre eingefügte Zeile abzurufen: ``` import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); const selectStatement = select({ table: 'persons', columns: '*', where: { id: { eq: values.id } }, limit: 1, }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) // and // SELECT * // FROM `persons` // WHERE `id` = :ID return createMySQLStatement(insertStatement, selectStatement) } ``` **Anwendungsfall Postgres** Mit Postgres können Sie Daten aus der Zeile abrufen [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html), die Sie eingefügt haben. Es akzeptiert `*` oder ein Array von Spaltennamen: ``` import { insert, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values, returning: '*' }); // Generates statement: // INSERT INTO "persons"("name") // VALUES(:NAME) // RETURNING * return createPgStatement(insertStatement) } ``` #### Aktualisierung Das `update` Tool ermöglicht es Ihnen, bestehende Zeilen zu aktualisieren. Sie können das Bedingungsobjekt verwenden, um Änderungen an den angegebenen Spalten in allen Zeilen vorzunehmen, die die Bedingung erfüllen. Nehmen wir zum Beispiel an, wir haben ein Schema, das es uns ermöglicht, diese Mutation vorzunehmen. Wir wollen das `name` von `Person` mit dem `id` Wert von aktualisieren, `3` aber nur, wenn wir sie (`known_since`) seit dem Jahr kennen`2000`: ``` mutation Update { updatePerson( input: {id: 3, name: "Jon"}, condition: {known_since: {ge: "2000"}} ) { id name } } ``` Unser Update Resolver sieht so aus: ``` import { update, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id, ...values }, condition } = ctx.args; const where = { ...condition, id: { eq: id }, }; const updateStatement = update({ table: 'persons', values, where, returning: ['id', 'name'], }); // Generates statement: // UPDATE "persons" // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` Wir können unserer Bedingung ein Häkchen hinzufügen, um sicherzustellen, dass nur die Zeile aktualisiert `3` wird, deren Primärschlüssel `id` gleich ist. In ähnlicher Weise können Sie Postgres verwenden`inserts`, `returning` um die geänderten Daten zurückzugeben. #### Remove Mit dem `remove` Hilfsprogramm können Sie vorhandene Zeilen löschen. Sie können das Bedingungsobjekt für alle Zeilen verwenden, die die Bedingung erfüllen. Beachten Sie, dass `delete` es sich um ein reserviertes Schlüsselwort in handelt JavaScript. `remove`sollte stattdessen verwendet werden: ``` import { remove, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id }, condition } = ctx.args; const where = { ...condition, id: { eq: id } }; const deleteStatement = remove({ table: 'persons', where, returning: ['id', 'name'], }); // Generates statement: // DELETE "persons" // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` ### Umwandlung In einigen Fällen benötigen Sie möglicherweise genauere Angaben zum richtigen Objekttyp, den Sie in Ihrer Anweisung verwenden möchten. Sie können die bereitgestellten Typhinweise verwenden, um den Typ Ihrer Parameter anzugeben. AWS AppSync unterstützt [dieselben Typhinweise](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) wie die Daten-API. Sie können Ihre Parameter mithilfe der `typeHint` Funktionen des AWS AppSync `rds` Moduls umwandeln. Das folgende Beispiel ermöglicht es Ihnen, ein Array als Wert zu senden, der als JSON-Objekt umgewandelt wird. Wir verwenden den `->` Operator, um das Element `index` `2` im JSON-Array abzurufen: ``` import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const arr = ctx.args.list_of_ids const statement = sql`select ${typeHint.JSON(arr)}->2 as value` return createPgStatement(statement) } export function response(ctx) { return toJsonObject(ctx.result)[0][0].value } ``` Casting ist auch nützlich bei der Handhabung und beim Vergleichen von `DATE``TIME`, und`TIMESTAMP`: ``` import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const when = ctx.args.when const statement = select({ table: 'persons', where: { createdAt : { gt: typeHint.DATETIME(when) } } }) return createPgStatement(statement) } ``` Hier ist ein weiteres Beispiel, das zeigt, wie Sie das aktuelle Datum und die aktuelle Uhrzeit senden können: ``` import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss') return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`) } ``` **Verfügbare Typhinweise** + `typeHint.DATE`- Der entsprechende Parameter wird als Objekt des `DATE` Typs an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD`. + `typeHint.DECIMAL`- Der entsprechende Parameter wird als Objekt des `DECIMAL` Typs an die Datenbank gesendet. + `typeHint.JSON`- Der entsprechende Parameter wird als Objekt des `JSON` Typs an die Datenbank gesendet. + `typeHint.TIME`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `TIME` Typs an die Datenbank gesendet. Das akzeptierte Format ist `HH:MM:SS[.FFF]`. + `typeHint.TIMESTAMP`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `TIMESTAMP` Typs an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD HH:MM:SS[.FFF]`. + `typeHint.UUID`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `UUID` Typs an die Datenbank gesendet.