Funktionen des DynamoDB-Moduls Funktionen des Amazon RDS-Moduls

Built-in Module

Module sind Teil der APPSYNC_JS Laufzeit und bieten Hilfsprogramme, die beim Schreiben von JavaScript Resolvern und Funktionen helfen. Beispiele und Beispiele finden Sie im Repository https://github.com/aws-samples/aws-appsync-resolver-samples GitHub aws-appsync-resolver-samples.

Funktionen des DynamoDB-Moduls

Die Funktionen des DynamoDB-Moduls bieten ein verbessertes Erlebnis 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 importiert mit: @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 dazu finden Sie unter GetInput.

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

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

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

Generiert einDynamoDBScanRequest, um eine https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan 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 https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync 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 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';

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, Stadt 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

Um während eines Updates neu hinzugefügte Freundes-IDs (newFriendIds) an eine bestehende Freundesliste (friendsIds) anzuhängen:


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 bei der Aktualisierung von DynamoDB verringert.

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

So stellen Sie einer vorhandenen Freundesliste (newFriendIds) während eines Updates neu hinzugefügte Freundes-IDs (friendsIds) voran:


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 und nicht nur die Schlüssel in der Nutzlast aktualisieren möchten.

Beispiel

Um eine Adresse (Straße, Stadt 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) wurde dieses Beispiel verwendet, updateListItem um die ID-Werte des zweiten Elements (index:1, new ID:102) und des dritten Elements (index:2, new ID:112) in einer Liste (friendsIds) zu aktualisieren.


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

Geben Sie eine Erklärung ein

consistentRead?: boolean (optional)

Ein optionaler boolescher Wert, um anzugeben, ob Sie einen stark konsistenten Lesevorgang mit DynamoDB 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; 
}

Geben Sie eine Erklärung ein

_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 anhand des Status des Objekts, das sich bereits in DynamoDB befindet, steuert, ob die Anforderung erfolgreich sein soll oder nicht, bevor der Vorgang ausgeführt wird.
customPartitionKey?: string (optional)

Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der ds_pk UND-Datensätze, die von der ds_sk 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 istcustomPartitionKey, 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 eine 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

Verwenden 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 eine 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 anhand des Status des Objekts, das sich bereits in DynamoDB befindet, steuert, ob die Anforderung erfolgreich sein soll oder nicht, bevor der Vorgang ausgeführt wird.

Beispiel

Das folgende Beispiel ist ein DeleteItem Ausdruck, der eine Bedingung enthält, die den Vorgang nur dann erfolgreich macht, wenn der Besitzer des Dokuments mit dem Benutzer übereinstimmt, der die Anforderung 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_pk UND-Datensätze, die ds_sk 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.
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 für einen Benutzer hatid, dann 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 istcustomPartitionKey, 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; 
}

Typ Declaration

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 unter 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 Declaration

basePartitionKey?: string (optional)

Der Partitionsschlüssel der Basistabelle, der bei der Durchführung eines Sync-Vorgangs verwendet werden soll. Dieses Feld ermöglicht die Ausführung eines Sync-Vorgangs, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet.
deltaIndexName?: string (optional)

Der für den Sync-Vorgang verwendete Index. Dieser Index ist erforderlich, um einen Sync-Vorgang für die gesamte Delta-Speichertabelle zu aktivieren, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. Der Sync-Vorgang wird auf dem GSI ausgeführt (erstellt am gsi_ds_pk undgsi_ds_sk).
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, an dem der letzte erfolgreiche Sync-Vorgang 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 Sync-Vorgangs 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 sollen. 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 eine 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 anhand des Status des Objekts, das sich bereits in DynamoDB befindet, steuert, ob die Anforderung erfolgreich sein soll oder nicht, bevor der Vorgang ausgeführt wird.
customPartitionKey?: string (optional)

Wenn diese Option aktiviert ist, ändert der customPartitionKey Wert das Format der ds_pk UND-Datensätze, die von der ds_sk Delta-Sync-Tabelle 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 istcustomPartitionKey, 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 Amazon RDS-Moduls

Die Funktionen des Amazon RDS-Moduls bieten ein verbessertes Erlebnis bei der Interaktion mit Datenbanken, die mit der Amazon RDS Data API konfiguriert wurden. Das Modul wird importiert mit@aws-appsync/utils/rds:


import * as rds from '@aws-appsync/utils/rds';

Funktionen können auch einzeln importiert werden. Im folgenden Import wird beispielsweise Folgendes verwendetsql:


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 Tool erstellt eine SELECT Anweisung zur Abfrage Ihrer relationalen Datenbank.

Grundlegende Verwendung

In der 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 Ihrer Tabellenkennung 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, lautet die Standardeinstellung: *


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

Sortieren nach

Sie können Ihre Ergebnisse nach der orderBy Immobilie sortieren. Stellen Sie eine Reihe von Objekten bereit, 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 für besondere Bedingungen 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 Anweisungen 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	Description	Mögliche Werttypen
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
Enthält nicht	Nicht wie	Zeichenfolge
Beginnt mit	Beginnt mit einem Präfix	Zeichenfolge
zwischen	Zwischen zwei Werten	Zahl, Zeichenfolge
Attribut ist vorhanden	Das Attribut ist nicht Null	Zahl, Zeichenfolge, boolescher Wert
size	prüft die Länge des Elements	Zeichenfolge

Das insert Tool bietet eine einfache Möglichkeit, mit der INSERT Operation einzeilige Elemente 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 werden 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 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, vorhandene 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 of 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 eine Prüfung hinzufügen, um sicherzustellen, dass nur die Zeile aktualisiert 3 wird, deren Primärschlüssel id gleich ist. In ähnlicher Weise können Sie für Postgres die geänderten Daten verwendeninserts, returning um die geänderten Daten zurückzugeben.

Das remove Tool ermöglicht es Ihnen, vorhandene Zeilen zu löschen. Sie können das Bedingungsobjekt für alle Zeilen verwenden, die die Bedingung erfüllen. Beachten Sie, dass delete dies ein reserviertes Schlüsselwort in ist 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, der in Ihrer Anweisung verwendet werden soll. Sie können die bereitgestellten Typhinweise verwenden, um den Typ Ihrer Parameter anzugeben. AWS AppSync unterstützt dieselben Typhinweise wie die Daten-API. Sie können Ihre Parameter mithilfe der typeHint Funktionen aus dem AWS AppSync rds Modul 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 beim Umgang und Vergleich 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 Tipphinweise

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 String-Parameterwert wird als Objekt des TIME Typs an die Datenbank gesendet. Das akzeptierte Format ist HH:MM:SS[.FFF].
typeHint.TIMESTAMP- Der entsprechende String-Parameterwert 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 String-Parameterwert wird als Objekt des UUID Typs an die Datenbank gesendet.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Built-in Dienstprogramme

Dienstprogramme für Runtime