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. # AWS AppSync JavaScript Resolver-Funktionsreferenz für Amazon RDS Die AWS AppSync RDS-Funktion und der RDS-Resolver ermöglichen es Entwicklern, mithilfe der RDS-Daten-API SQL Abfragen an eine Amazon Aurora Aurora-Cluster-Datenbank zu senden und das Ergebnis dieser Abfragen zurückzuerhalten. Sie können SQL Anweisungen schreiben, die an die `sql` Daten-API gesendet werden, indem AWS AppSync Sie die mit dem `rds` Modul markierte Vorlage oder die Hilfsfunktionen`select`, `insert``update`, und `remove` Hilfsfunktionen des `rds` Moduls verwenden. AWS AppSync verwendet die [https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html)Aktion des RDS-Datendienstes, um SQL-Anweisungen für die Datenbank auszuführen. **Topics** + [Mit SQL markierte Vorlage](#sql-tagged-templates) + [Aussagen erstellen](#creating-statements) + [Abrufen von Daten](#retrieving-data) + [Hilfsfunktionen](#utility-functions) + [SQL auswählen](#utility-functions-select) + [SQL einfügen](#utility-functions-insert) + [SQL-Aktualisierung](#utility-functions-update) + [SQL Löschen](#utility-functions-delete) + [Umwandlung](#casting) ## Mit SQL markierte Vorlage AWS AppSync Die `sql` mit Tags versehene Vorlage ermöglicht es Ihnen, mithilfe von Vorlagenausdrücken eine statische Anweisung zu erstellen, die zur Laufzeit dynamische Werte empfangen kann. AWS AppSync erstellt eine Variablenzuordnung aus den Ausdruckswerten, um eine [https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html)Abfrage zu erstellen, die an die Amazon Aurora Serverless Data API gesendet wird. Mit dieser Methode ist es nicht möglich, dass dynamische Werte, die zur Laufzeit übergeben werden, die ursprüngliche Anweisung ändern, was zu einer unbeabsichtigten Ausführung führen könnte. Alle dynamischen Werte werden als Parameter übergeben, können die ursprüngliche Anweisung nicht ändern und werden nicht von der Datenbank ausgeführt. Dadurch ist Ihre Abfrage weniger anfällig für SQL Injektionsangriffe. **Anmerkung** In jedem Fall sollten Sie beim Schreiben von SQL Aussagen die Sicherheitsrichtlinien befolgen, um die Daten, die Sie als Eingabe erhalten, ordnungsgemäß zu behandeln. **Anmerkung** Die `sql` mit Tags versehene Vorlage unterstützt nur die Übergabe von Variablenwerten. Sie können keinen Ausdruck verwenden, um die Spalten- oder Tabellennamen dynamisch anzugeben. Sie können jedoch Hilfsfunktionen verwenden, um dynamische Anweisungen zu erstellen. Im folgenden Beispiel erstellen wir eine Abfrage, die basierend auf dem Wert des `col` Arguments filtert, das zur Laufzeit dynamisch in der GraphQL-Abfrage festgelegt wird. Der Wert kann der Anweisung nur mithilfe des Tag-Ausdrucks hinzugefügt werden: ``` import { sql, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const query = sql` SELECT * FROM table WHERE column = ${ctx.args.col}` ; return createMySQLStatement(query); } ``` Indem wir alle dynamischen Werte über die Variablenzuordnung übergeben, verlassen wir uns darauf, dass die Datenbank-Engine Werte sicher verarbeitet und bereinigt. ## Aussagen erstellen Funktionen und Resolver können mit MySQL- und PostgreSQL-Datenbanken interagieren. Verwenden Sie `createPgStatement` jeweils `createMySQLStatement` und, um Anweisungen zu erstellen. `createMySQLStatement`Kann beispielsweise eine MySQL-Abfrage erstellen. Diese Funktionen akzeptieren bis zu zwei Anweisungen. Dies ist nützlich, wenn eine Anfrage sofort Ergebnisse abrufen soll. Mit MySQL könnten Sie Folgendes tun: ``` import { sql, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { id, text } = ctx.args; const s1 = sql`insert into Post(id, text) values(${id}, ${text})`; const s2 = sql`select * from Post where id = ${id}`; return createMySQLStatement(s1, s2); } ``` **Anmerkung** `createPgStatement`und `createMySQLStatement` maskiert oder zitiert keine Aussagen, die mit der `sql` markierten Vorlage erstellt wurden. ## Abrufen von Daten Das Ergebnis Ihrer ausgeführten SQL-Anweisung ist in Ihrem Antworthandler im `context.result` Objekt verfügbar. Das Ergebnis ist eine JSON-Zeichenfolge mit den [Antwortelementen](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html#API_ExecuteStatement_ResponseElements) aus der `ExecuteStatement` Aktion. Bei der Analyse hat das Ergebnis die folgende Form: ``` type SQLStatementResults = { sqlStatementResults: { records: any[]; columnMetadata: any[]; numberOfRecordsUpdated: number; generatedFields?: any[] }[] } ``` Sie können das `toJsonObject` Hilfsprogramm verwenden, um das Ergebnis in eine Liste von JSON-Objekten umzuwandeln, die die zurückgegebenen Zeilen darstellen. Beispiel: ``` import { toJsonObject } from '@aws-appsync/utils/rds'; export function response(ctx) { const { error, result } = ctx; if (error) { return util.appendError( error.message, error.type, result ) } return toJsonObject(result)[1][0] } ``` Beachten Sie, dass ein `toJsonObject` Array von Anweisungsergebnissen zurückgegeben wird. Wenn Sie eine Anweisung angegeben haben, ist die Länge des Arrays`1`. Wenn Sie zwei Anweisungen angegeben haben, ist die Array-Länge`2`. Jedes Ergebnis im Array enthält `0` oder mehr Zeilen. `toJsonObject`gibt zurück`null`, wenn der Ergebniswert ungültig oder unerwartet ist. ## Hilfsfunktionen Sie können die Hilfsprogramme des AWS AppSync RDS-Moduls verwenden, um mit Ihrer Datenbank zu interagieren. ### SQL auswählen 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 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 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 | ### SQL einfügen Das `insert` Hilfsprogramm bietet eine einfache Möglichkeit, mit dem `INSERT` Vorgang 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 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) } ``` ### SQL-Aktualisierung Das `update` Hilfsprogramm 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. ### SQL Löschen Das `remove` Hilfsprogramm ermöglicht es Ihnen, bestehende Zeilen zu 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.