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 eine
DynamoDBScanRequest
, 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 dieupdateListItem
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
undds_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 despopulateIndexFields
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 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 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:
id
name
, 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 derds_sk
undds_pk
-Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionsverwaltung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung despopulateIndexFields
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 wird
customPartitionKey
, neue Einträge für jeden Datensatz in der Delta-Sync-Tabelle erstellt, insbesondere in den Spaltengsi_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ück
ProjectionExpression
. Dieser Rückgabewert entspricht der AngabeProjectionExpression
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 ist1000
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 derds_pk
AND-Datensätze, die von derds_sk
Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung despopulateIndexFields
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 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<T>
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 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
*
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. 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 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 DATE
TIME
, 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 desDATE
Typs an die Datenbank gesendet. Das akzeptierte Format istYYYY-MM-DD
. -
typeHint.DECIMAL
- Der entsprechende Parameter wird als Objekt desDECIMAL
Typs an die Datenbank gesendet. -
typeHint.JSON
- Der entsprechende Parameter wird als Objekt desJSON
Typs an die Datenbank gesendet. -
typeHint.TIME
- Der entsprechende Zeichenkettenparameterwert wird als Objekt desTIME
Typs an die Datenbank gesendet. Das akzeptierte Format istHH:MM:SS[.FFF]
. -
typeHint.TIMESTAMP
- Der entsprechende Zeichenkettenparameterwert wird als Objekt desTIMESTAMP
Typs an die Datenbank gesendet. Das akzeptierte Format istYYYY-MM-DD HH:MM:SS[.FFF]
. -
typeHint.UUID
- Der entsprechende Zeichenkettenparameterwert wird als Objekt desUUID
Typs an die Datenbank gesendet.