SQLtemplate yang ditandai Membuat pernyataan Mengambil data Fungsi utilitas Casting

AWS AppSync JavaScript referensi fungsi resolver untuk Amazon RDS

AWS AppSync RDSFungsi dan resolver memungkinkan pengembang untuk mengirim SQL kueri ke database cluster Amazon Aurora menggunakan RDS API Data dan mendapatkan kembali hasil kueri ini. Anda bisa menulis SQL pernyataan yang dikirim ke Data API dengan menggunakan AWS AppSyncrds modul sql -tagged template atau dengan menggunakan rds modulselect,, insertupdate, dan fungsi remove pembantu. AWS AppSync memanfaatkan ExecuteStatementtindakan Layanan RDS Data untuk menjalankan SQL pernyataan terhadap database.

SQLtemplate yang ditandai

AWS AppSync template yang sql diberi tag memungkinkan Anda membuat pernyataan statis yang dapat menerima nilai dinamis saat runtime dengan menggunakan ekspresi template. AWS AppSync membangun peta variabel dari nilai ekspresi untuk membuat SqlParameterizedkueri yang dikirim ke Data Tanpa Server Amazon Aurora. API Dengan metode ini, nilai dinamis tidak mungkin diteruskan pada waktu berjalan untuk memodifikasi pernyataan asli, yang dapat menyebabkan eksekusi yang tidak disengaja. Semua nilai dinamis dilewatkan sebagai parameter, tidak dapat memodifikasi pernyataan asli, dan tidak dieksekusi oleh database. Ini membuat kueri Anda kurang rentan terhadap SQL serangan injeksi.

catatan

Dalam semua kasus, saat menulis SQL pernyataan, Anda harus mengikuti pedoman keamanan untuk menangani data yang Anda terima sebagai masukan dengan benar.

catatan

Template sql yang ditandai hanya mendukung melewati nilai variabel. Anda tidak dapat menggunakan ekspresi untuk menentukan nama kolom atau tabel secara dinamis. Namun, Anda dapat menggunakan fungsi utilitas untuk membangun pernyataan dinamis.

Dalam contoh berikut, kami membuat kueri yang memfilter berdasarkan nilai col argumen yang diatur secara dinamis dalam kueri GraphQL saat dijalankan. Nilai hanya dapat ditambahkan ke pernyataan menggunakan ekspresi 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);
}

Dengan meneruskan semua nilai dinamis melalui peta variabel, kami mengandalkan mesin database untuk menangani dan membersihkan nilai dengan aman.

Membuat pernyataan

Fungsi dan resolver dapat berinteraksi dengan database My SQL dan SQL Postgre. Gunakan createMySQLStatement dan createPgStatement masing-masing untuk membangun pernyataan. Misalnya, createMySQLStatement dapat membuat SQL kueri Saya. Fungsi-fungsi ini menerima hingga dua pernyataan, berguna ketika permintaan harus segera mengambil hasil. Dengan MySQL, Anda dapat melakukan:


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

catatan

createPgStatementdan createMySQLStatement tidak luput atau mengutip pernyataan yang dibangun dengan template yang sql diberi tag.

Mengambil data

Hasil dari SQL pernyataan yang dieksekusi tersedia di handler respons Anda di context.result objek. Hasilnya adalah JSON string dengan elemen respons dari ExecuteStatement tindakan. Saat diurai, hasilnya memiliki bentuk sebagai berikut:


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

Anda dapat menggunakan toJsonObject utilitas untuk mengubah hasilnya menjadi daftar JSON objek yang mewakili baris yang dikembalikan. Sebagai contoh:


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

Perhatikan bahwa toJsonObject mengembalikan array hasil pernyataan. Jika Anda memberikan satu pernyataan, panjang array adalah1. Jika Anda memberikan dua pernyataan, panjang array adalah2. Setiap hasil dalam array berisi 0 atau lebih baris. toJsonObjectkembali null jika nilai hasil tidak valid atau tidak terduga.

Fungsi utilitas

Anda dapat menggunakan pembantu utilitas AWS AppSync RDS modul untuk berinteraksi dengan database Anda.

selectUtilitas membuat SELECT pernyataan untuk menanyakan database relasional Anda.

Penggunaan dasar

Dalam bentuk dasarnya, Anda dapat menentukan tabel yang ingin Anda kueri:


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

export function request(ctx) {

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

Perhatikan bahwa Anda juga dapat menentukan skema dalam pengidentifikasi tabel Anda:


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

export function request(ctx) {

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

Menentukan kolom

Anda dapat menentukan kolom dengan columns properti. Jika ini tidak disetel ke nilai, defaultnya adalah: *


export function request(ctx) {

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

Anda dapat menentukan tabel kolom juga:


export function request(ctx) {

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

Batas dan offset

Anda dapat menerapkan limit dan offset ke kueri:


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

Memesan oleh

Anda dapat mengurutkan hasil Anda dengan orderBy properti. Menyediakan array objek yang menentukan kolom dan dir properti opsional:


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

Anda dapat membangun filter dengan menggunakan objek kondisi khusus:


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

Anda juga dapat menggabungkan filter:


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

Anda juga dapat membuat OR pernyataan:


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

Anda juga dapat meniadakan suatu kondisi dengannot:


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

Anda juga dapat menggunakan operator berikut untuk membandingkan nilai:

Operator	Deskripsi	Jenis nilai yang mungkin
persamaan	Sama	nomor, string, boolean
ne	Tidak sama	nomor, string, boolean
le	Kurang dari atau sama	nomor, string
lt	Kurang dari	nomor, string
ge	Lebih besar dari atau sama	nomor, string
gt	Lebih besar dari	nomor, string
mengandung	Suka	string
notContains	Tidak suka	string
beginsWith	Dimulai dengan awalan	string
antara	Antara dua nilai	nomor, string
attributeExists	Atribut tidak null	nomor, string, boolean
ukuran	memeriksa panjang elemen	string

insertUtilitas menyediakan cara mudah untuk memasukkan item baris tunggal dalam database Anda dengan operasi. INSERT

Penyisipan item tunggal

Untuk menyisipkan item, tentukan tabel dan kemudian masukkan objek nilai Anda. Kunci objek dipetakan ke kolom tabel Anda. Nama kolom secara otomatis lolos, dan nilai dikirim ke database menggunakan peta variabel:


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

Kasus SQL penggunaan saya

Anda dapat menggabungkan insert diikuti oleh a select untuk mengambil baris yang disisipkan:


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

Kasus penggunaan postgres

Dengan Postgres, Anda dapat menggunakan returninguntuk mendapatkan data dari baris yang Anda masukkan. Ia menerima * atau array nama kolom:


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

updateUtilitas memungkinkan Anda untuk memperbarui baris yang ada. Anda dapat menggunakan objek kondisi untuk menerapkan perubahan pada kolom yang ditentukan di semua baris yang memenuhi kondisi. Sebagai contoh, katakanlah kita memiliki skema yang memungkinkan kita membuat mutasi ini. Kami ingin memperbarui name of Person dengan id nilai 3 tetapi hanya jika kami mengetahuinya (known_since) sejak tahun ini2000:


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

Resolver pembaruan kami terlihat seperti ini:


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

Kita dapat menambahkan cek ke kondisi kita untuk memastikan bahwa hanya baris yang memiliki kunci utama id sama dengan 3 yang diperbarui. Demikian pula, untuk Postgresinserts, Anda dapat menggunakan returning untuk mengembalikan data yang dimodifikasi.

removeUtilitas memungkinkan Anda untuk menghapus baris yang ada. Anda dapat menggunakan objek kondisi pada semua baris yang memenuhi kondisi. Perhatikan bahwa itu delete adalah kata kunci yang dicadangkan di JavaScript. removeharus digunakan sebagai gantinya:


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

Dalam beberapa kasus, Anda mungkin ingin lebih spesifisitas tentang jenis objek yang benar untuk digunakan dalam pernyataan Anda. Anda dapat menggunakan petunjuk jenis yang disediakan untuk menentukan jenis parameter Anda. AWS AppSync mendukung petunjuk jenis yang sama dengan DataAPI. Anda dapat mentransmisikan parameter Anda dengan menggunakan typeHint fungsi dari AWS AppSync rds modul.

Contoh berikut memungkinkan Anda untuk mengirim array sebagai nilai yang dicor sebagai JSON objek. Kami menggunakan -> operator untuk mengambil elemen di index 2 dalam JSON array:


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 juga berguna saat menangani dan membandingkanDATE,TIME, danTIMESTAMP:


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

Berikut contoh lain yang menunjukkan bagaimana Anda dapat mengirim tanggal dan waktu saat ini:


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

Petunjuk tipe yang tersedia

typeHint.DATE- Parameter yang sesuai dikirim sebagai objek dari DATE jenis ke database. Format yang diterima adalah YYYY-MM-DD.
typeHint.DECIMAL- Parameter yang sesuai dikirim sebagai objek dari DECIMAL jenis ke database.
typeHint.JSON- Parameter yang sesuai dikirim sebagai objek dari JSON jenis ke database.
typeHint.TIME- Nilai parameter string yang sesuai dikirim sebagai objek dari TIME tipe ke database. Format yang diterima adalah HH:MM:SS[.FFF].
typeHint.TIMESTAMP- Nilai parameter string yang sesuai dikirim sebagai objek dari TIMESTAMP tipe ke database. Format yang diterima adalah YYYY-MM-DD HH:MM:SS[.FFF].
typeHint.UUID- Nilai parameter string yang sesuai dikirim sebagai objek dari UUID tipe ke database.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

JavaScript referensi fungsi resolver untuk HTTP

JavaScript referensi fungsi resolver untuk Amazon Bedrock