AWS AppSync JavaScript référence de la fonction de résolution pour Amazon RDS

L'selectutilitaire crée une SELECT instruction pour interroger votre base de données relationnelle.

Utilisation de base

Dans sa forme de base, vous pouvez spécifier la table que vous souhaitez interroger :

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

export function request(ctx) {

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

Notez que vous pouvez également spécifier le schéma dans l'identifiant de votre table :

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

export function request(ctx) {

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

Spécification des colonnes

Vous pouvez spécifier des colonnes à l'aide de columns cette propriété. Si aucune valeur n'est définie, la valeur par défaut est la suivante : *

export function request(ctx) {

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

Vous pouvez également spécifier le tableau d'une colonne :

export function request(ctx) {

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

Limites et décalages

Vous pouvez postuler limit et répondre offset à la requête :

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

Commander par

Vous pouvez trier vos résultats avec la orderBy propriété. Fournissez un tableau d'objets spécifiant la colonne et une dir propriété facultative :

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

Filtres

Vous pouvez créer des filtres à l'aide de l'objet de condition spéciale :

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

Vous pouvez également combiner des filtres :

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

Vous pouvez également créer des OR relevés :

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

Vous pouvez également annuler une condition avec 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 } }
        ]}
    }));
}

Vous pouvez également utiliser les opérateurs suivants pour comparer les valeurs :

L'insertutilitaire fournit un moyen simple d'insérer des éléments d'une seule ligne dans votre base de données à l'aide de cette INSERT opération.

Insertions d'articles uniques

Pour insérer un élément, spécifiez le tableau, puis transmettez votre objet de valeurs. Les clés des objets sont mappées aux colonnes de votre tableau. Les noms de colonnes sont automatiquement échappés et les valeurs sont envoyées à la base de données à l'aide de la variable map :

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

Cas d'utilisation de MySQL

Vous pouvez combiner un insert suivi d'un select pour récupérer la ligne que vous avez insérée :

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

Cas d'utilisation de Postgres

Avec Postgres, vous pouvez utiliser returning pour obtenir des données à partir de la ligne que vous avez insérée. Il accepte * ou un tableau de noms de colonnes :

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'updateutilitaire vous permet de mettre à jour les lignes existantes. Vous pouvez utiliser l'objet de condition pour appliquer des modifications aux colonnes spécifiées dans toutes les lignes qui satisfont à la condition. Par exemple, supposons que nous ayons un schéma qui nous permet d'effectuer cette mutation. Nous voulons mettre à jour le name of Person avec la id valeur de3, mais uniquement si nous les connaissons (known_since) depuis l'année 2000 :

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

Notre résolveur de mises à jour ressemble à ceci :

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

Nous pouvons ajouter une vérification à notre condition pour nous assurer que seule la ligne dont la clé primaire est id égale à 3 est mise à jour. De même, pour Postgresinserts, vous pouvez utiliser returning pour renvoyer les données modifiées.

L'removeutilitaire vous permet de supprimer des lignes existantes. Vous pouvez utiliser l'objet de condition sur toutes les lignes qui satisfont à la condition. Notez qu'il delete s'agit d'un mot clé réservé dans JavaScript. removedoit être utilisé à la place :

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