Integrierten Module - AWS AppSync

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.

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

get<T>(payload: GetInput): DynamoDBGetItemRequest
Tipp

Informationen Eingaben zu finden Sie unter GetInput.

Generiert ein DynamoDBGetItemRequest Objekt, um eine GetItemAnfrage an DynamoDB zu stellen.

import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); }
put<T>(payload): DynamoDBPutItemRequest

Generiert ein DynamoDBPutItemRequest Objekt, um eine PutItemAnfrage 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<T>(payload): DynamoDBDeleteItemRequest

Generiert ein DynamoDBDeleteItemRequest Objekt, um eine DeleteItemAnfrage 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<T>(payload): DynamoDBScanRequest

Generiert eineDynamoDBScanRequest, um eine Scan-Anfrage 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<T>(payload): DynamoDBSyncRequest

Generiert ein DynamoDBSyncRequest Objekt, um eine Sync-Anfrage 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<T>(payload): DynamoDBUpdateItemRequest

Generiert ein DynamoDBUpdateItemRequest Objekt, um eine UpdateItemAnfrage 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';
add<T>(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 <T>(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 <T>(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 <T>(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 <T>(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

Type GetInput<T>
GetInput<T>: { consistentRead?: boolean; key: DynamoDBKey<T>; }

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<T> (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<T>
PutInput<T>: { _version?: number; condition?: DynamoDBFilterObject<T> | null; customPartitionKey?: string; item: Partial<T>; key: DynamoDBKey<T>; populateIndexFields?: boolean; }

Typ Deklaration

  • _version?: number (optional)

  • condition?: DynamoDBFilterObject<T> | 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<T> (Erforderlich)

    Die restlichen Attribute des Elements, das in DynamoDB platziert werden soll.

  • key: DynamoDBKey<T> (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 wirdcustomPartitionKey, 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 im AWS AppSync Entwicklerhandbuch.

Type QueryInput<T>
QueryInput<T>: ScanInput<T> & { query: DynamoDBKeyCondition<Required<T>>; }

Geben Sie Erklärung ein

  • query: DynamoDBKeyCondition<Required<T>> (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: idname, undage:

    const query: QueryInput<User> = { name: { eq: 'John' }, age: { gt: 20 }, }
Type RemoveInput<T>
RemoveInput<T>: { _version?: number; condition?: DynamoDBFilterObject<T>; customPartitionKey?: string; key: DynamoDBKey<T>; populateIndexFields?: boolean; }

Geben Sie Erklärung ein

  • _version?: number (optional)

  • condition?: DynamoDBFilterObject<T> (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<Task> = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove<Task>({ 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<T> (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 hatid, würde der Schlüssel wie folgt aussehen:

    type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey<User> = { 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<User> = { id: 1, name: 'XXXXXXXXXX', }
  • populateIndexFields?: boolean (optional)

    Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wirdcustomPartitionKey, neue Einträge für jeden Datensatz in der Delta-Sync-Tabelle erstellt, insbesondere in den Spalten gsi_ds_pk undgsi_ds_sk.

Type ScanInput<T>
ScanInput<T>: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject<T> | 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<T> | 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)

    Attribute, die von DynamoDB zurückgegeben werden sollen. 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ückProjectionExpression. Dieser Rückgabewert entspricht der Angabe ProjectionExpression ohne Angabe eines Werts fürAttributesToGet.

  • totalSegments?: number (optional)

Type DynamoDBSyncInput<T>
DynamoDBSyncInput<T>: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject<T> | 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 für den Synchronisierungsvorgang verwendete Index. 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 dem GSI (erstellt am gsi_ds_pk undgsi_ds_sk) ausgeführt.

  • filter?: DynamoDBFilterObject<T> | 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<T>
DynamoDBUpdateInput<T>: { _version?: number; condition?: DynamoDBFilterObject<T>; customPartitionKey?: string; key: DynamoDBKey<T>; populateIndexFields?: boolean; update: DynamoDBUpdateObject<T>; }

Geben Sie Erklärung ein

  • _version?: number (optional)

  • condition?: DynamoDBFilterObject<T> (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<T> (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 wirdcustomPartitionKey, 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<T>

    Ein Objekt, das die zu aktualisierenden Attribute zusammen mit den neuen Werten für sie angibt. Das Aktualisierungsobjekt kann mitadd,,remove,replace,increment,decrement, appendprepend, verwendet werdenupdateListItem.

Funktionen des RDS Amazon-Moduls

Die Funktionen des RDS Amazon-Moduls bieten eine verbesserte Erfahrung bei der Interaktion mit Datenbanken, die mit Amazon RDS Data konfiguriert sindAPI. 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 Importsql:

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.

Das select Hilfsprogramm erstellt eine SELECT Anweisung, um Ihre relationale Datenbank abzufragen.

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 dies nicht auf einen Wert gesetzt ist, ist es standardmäßig: *

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 mitnot:

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 Beschreibung 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
notContains Nicht wie Zeichenfolge
beginsWith Beginnt mit einem Präfix Zeichenfolge
zwischen Zwischen zwei Werten Zahl, Zeichenfolge
attributeExists Das Attribut ist nicht Null Zahl, Zeichenfolge, boolescher Wert
size prüft die Länge des Elements Zeichenfolge

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) }

Mein SQL Anwendungsfall

Sie können ein insert gefolgt von einem kombinierenselect, 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 returning, 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) }

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 kennen2000:

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 verwendeninserts, returning um die geänderten Daten zurückzugeben.

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. removesollte 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 wie die DatenAPI. 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 DATETIME, undTIMESTAMP:

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.