AWS AppSync JavaScript riferimento alla funzione resolver per Amazon RDS - AWS AppSync GraphQL
SQLmodello taggatoCreazione di dichiarazioniRecupero dei datiFunzioni di utilitàCasting

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

AWS AppSync JavaScript riferimento alla funzione resolver per Amazon RDS

La AWS AppSync RDS funzione e il resolver consentono agli sviluppatori di inviare SQL esegue query su un database del cluster Amazon Aurora utilizzando RDS i API dati e recupera il risultato di queste query. Puoi scrivere SQL istruzioni che vengono inviate ai dati API utilizzando il modello sql -tagged AWS AppSync del rds rds modulo o utilizzando le funzioni di remove supporto del modulo select insertupdate,. AWS AppSync utilizza l'ExecuteStatementazione del RDS Data Service per eseguire SQL istruzioni sul database.

Argomenti

SQLmodello taggato

AWS AppSync consente sql di creare un'istruzione statica in grado di ricevere valori dinamici in fase di esecuzione utilizzando espressioni modello. AWS AppSync crea una mappa variabile dai valori delle espressioni per creare una SqlParameterizedquery che viene inviata ad Amazon Aurora Serverless Data. API Con questo metodo, non è possibile che i valori dinamici passati in fase di esecuzione modifichino l'istruzione originale, il che potrebbe causare un'esecuzione involontaria. Tutti i valori dinamici vengono passati come parametri, non possono modificare l'istruzione originale e non vengono eseguiti dal database. Ciò rende la tua query meno vulnerabile a SQL attacchi di iniezione.

Nota

In tutti i casi, durante la scrittura SQL per quanto riguarda le dichiarazioni, è necessario seguire le linee guida di sicurezza per gestire correttamente i dati ricevuti come input.

Nota

Il modello sql taggato supporta solo il passaggio di valori variabili. Non è possibile utilizzare un'espressione per specificare dinamicamente i nomi delle colonne o delle tabelle. Tuttavia, è possibile utilizzare funzioni di utilità per creare istruzioni dinamiche.

Nell'esempio seguente, creiamo una query che filtra in base al valore dell'colargomento impostato dinamicamente nella query GraphQL in fase di esecuzione. Il valore può essere aggiunto all'istruzione solo utilizzando l'espressione del tag:

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

Passando tutti i valori dinamici attraverso la mappa variabile, ci affidiamo al motore di database per gestire e ripulire i valori in modo sicuro.

Creazione di dichiarazioni

Funzioni e resolver possono interagire con i database My SQL e Postgre. SQL Usa createMySQLStatement e rispettivamente per creare istruzioni. createPgStatement Ad esempio, createMySQLStatement può creare una SQL query My. Queste funzioni accettano fino a due istruzioni, utili quando una richiesta deve recuperare immediatamente i risultati. Con MySQL, puoi fare:

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

createPgStatemente createMySQLStatement non sfugge né cita le istruzioni create con il modello sql taggato.

Recupero dei dati

Il risultato dell'SQListruzione eseguita è disponibile nel gestore delle risposte nell'context.resultoggetto. Il risultato è una JSON stringa con gli elementi di risposta dell'ExecuteStatementazione. Quando viene analizzato, il risultato ha la forma seguente:

type SQLStatementResults = {
    sqlStatementResults: {
        records: any[];
        columnMetadata: any[];
        numberOfRecordsUpdated: number;
        generatedFields?: any[]
    }[]
}

È possibile utilizzare l'toJsonObjectutilità per trasformare il risultato in un elenco di JSON oggetti che rappresentano le righe restituite. Per esempio:

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

Nota che toJsonObject restituisce una serie di risultati di istruzioni. Se hai fornito un'istruzione, la lunghezza dell'array è1. Se hai fornito due istruzioni, la lunghezza dell'array è2. Ogni risultato dell'array contiene 0 o più righe. toJsonObjectrestituisce null se il valore del risultato non è valido o inatteso.

Funzioni di utilità

È possibile utilizzare gli helper di utilità del AWS AppSync RDS modulo per interagire con il database.

L'selectutilità crea un'SELECTistruzione per interrogare il database relazionale.

Uso di base

Nella sua forma base, puoi specificare la tabella su cui vuoi interrogare:

import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement: 
    // "SELECT * FROM "persons"
    return createPgStatement(select({table: 'persons'}));
}

Nota che puoi anche specificare lo schema nell'identificatore della tabella:

import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement:
    // SELECT * FROM "private"."persons"
    return createPgStatement(select({table: 'private.persons'}));
}

Specificare le colonne

È possibile specificare le colonne con la columns proprietà. Se non è impostato su un valore, il valore predefinito è: *

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name']
    }));
}

Puoi anche specificare la tabella di una colonna:

export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "persons"."name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'persons.name']
    }));
}

Limiti e offset

È possibile applicare limit e offset alla query:

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

Ordina per

Puoi ordinare i risultati in base alla orderBy proprietà. Fornisci una matrice di oggetti che specificano la colonna e una dir proprietà opzionale:

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

Filtri

Puoi creare filtri utilizzando l'oggetto di condizione speciale:

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

Puoi anche combinare filtri:

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

Puoi anche creare OR dichiarazioni:

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

Puoi anche annullare una condizione connot:

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

È inoltre possibile utilizzare i seguenti operatori per confrontare i valori:

Operatore Descrizione Tipi di valori possibili
eq Uguale numero, stringa, booleano
uno Non uguale numero, stringa, booleano
le Minore di o uguale a numero, stringa
lt Minore di numero, stringa
età Maggiore di o uguale a numero, stringa
gt Maggiore di numero, stringa
contiene Piace string
notContains Non come string
beginsWith Inizia con il prefisso string
tra Tra due valori numero, stringa
attributeExists L'attributo non è nullo numero, stringa, booleano
formato controlla la lunghezza dell'elemento string

L'insertutilità fornisce un modo semplice per inserire elementi a riga singola nel database con l'operazione. INSERT

Inserimenti di singoli elementi

Per inserire un elemento, specifica la tabella e poi inserisci i valori dell'oggetto. Le chiavi degli oggetti vengono mappate alle colonne della tabella. I nomi delle colonne vengono espulsi automaticamente e i valori vengono inviati al database utilizzando la mappa variabile:

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

Il mio caso SQL d'uso

Puoi combinare un insert seguito da select a per recuperare la riga inserita:

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

Caso d'uso Postgres

Con Postgres, è possibile utilizzare returningper ottenere dati dalla riga inserita. Accetta * o una matrice di nomi di colonne:

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

L'updateutilità consente di aggiornare le righe esistenti. È possibile utilizzare l'oggetto condizione per applicare modifiche alle colonne specificate in tutte le righe che soddisfano la condizione. Ad esempio, supponiamo di avere uno schema che ci consente di effettuare questa mutazione. Vogliamo aggiornare the name of Person con il id valore di3, ma solo se li conosciamo (known_since) dall'anno2000:

mutation Update {
    updatePerson(
        input: {id: 3, name: "Jon"},
        condition: {known_since: {ge: "2000"}}
    ) {
    id
    name
  }
}

Il nostro risolutore di aggiornamenti ha il seguente aspetto:

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

Possiamo aggiungere un segno di spunta alla nostra condizione per assicurarci che venga aggiornata solo la riga con la chiave primaria id uguale a3. Allo stesso modo, per Postgresinserts, è possibile utilizzare returning per restituire i dati modificati.

L'removeutilità consente di eliminare le righe esistenti. È possibile utilizzare l'oggetto condizione su tutte le righe che soddisfano la condizione. Nota che delete è una parola chiave riservata in JavaScript. removedovrebbe essere usato invece:

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

Casting

In alcuni casi, potresti volere una maggiore specificità sul tipo di oggetto corretto da utilizzare nella tua dichiarazione. È possibile utilizzare i suggerimenti di tipo forniti per specificare il tipo di parametri. AWS AppSync supporta lo stesso tipo di suggerimenti dei dati. API Puoi trasmettere i tuoi parametri utilizzando le typeHint funzioni del AWS AppSync rds modulo.

L'esempio seguente consente di inviare un array come valore che viene trasmesso come JSON oggetto. Utilizziamo l'->operatore per recuperare l'elemento index 2 in corrispondenza della matrice: JSON

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
}

Il casting è utile anche per la gestione e DATE il confronto TIME eTIMESTAMP:

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

Ecco un altro esempio che mostra come inviare la data e l'ora correnti:

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

Suggerimenti di tipo disponibili

  • typeHint.DATE- Il parametro corrispondente viene inviato come oggetto del DATE tipo al database. Il formato accettato è YYYY-MM-DD.

  • typeHint.DECIMAL- Il parametro corrispondente viene inviato come oggetto del DECIMAL tipo al database.

  • typeHint.JSON- Il parametro corrispondente viene inviato come oggetto del JSON tipo al database.

  • typeHint.TIME- Il valore del parametro stringa corrispondente viene inviato come oggetto del TIME tipo al database. Il formato accettato è HH:MM:SS[.FFF].

  • typeHint.TIMESTAMP- Il valore del parametro stringa corrispondente viene inviato come oggetto del TIMESTAMP tipo al database. Il formato accettato è YYYY-MM-DD HH:MM:SS[.FFF].

  • typeHint.UUID- Il valore del parametro stringa corrispondente viene inviato come oggetto del UUID tipo al database.