Template dengan tag SQL Membuat pernyataan Mengambil data Fungsi utilitas Casting

AWS AppSync JavaScript referensi fungsi resolver untuk Amazon RDS

Fungsi dan resolver AWS AppSync RDS memungkinkan pengembang mengirim SQL kueri ke database cluster Amazon Aurora menggunakan API Data RDS dan mendapatkan kembali hasil dari kueri ini. Anda dapat menulis SQL pernyataan yang dikirim ke API Data dengan menggunakan AWS AppSync template yang sql diberi tag rds modul atau dengan menggunakan fungsi rds modulselect,insert,update, dan remove helper. AWS AppSync memanfaatkan ExecuteStatement tindakan RDS Data Service untuk menjalankan pernyataan SQL terhadap database.

Template dengan tag SQL

AWS AppSync Tem sql plate 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 SqlParameterized kueri yang dikirim ke API Data Tanpa Server Amazon Aurora. Dengan metode ini, tidak mungkin nilai dinamis yang diteruskan pada waktu berjalan untuk memodifikasi pernyataan asli, yang dapat menyebabkan eksekusi tanpa maksud. Semua nilai dinamis diteruskan sebagai parameter, tidak dapat memodifikasi pernyataan asli, dan tidak dieksekusi oleh database. Ini membuat kueri Anda kurang rentan terhadap serangan SQL injeksi.

catatan

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

catatan

Template sql yang ditandai hanya mendukung nilai variabel yang diteruskan. 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, kita membuat kueri yang memfilter berdasarkan nilai col argumen yang disetel secara dinamis dalam kueri GraphQL pada waktu berjalan. 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 MySQL dan PostgreSQL. Gunakan createMySQLStatement dan createPgStatement masing-masing untuk membangun pernyataan. Misalnya, createMySQLStatement dapat membuat query MySQL. 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 lolos atau mengutip pernyataan yang dibuat dengan template sql yang ditandai.

Mengambil data

Hasil dari pernyataan SQL yang dieksekusi tersedia di handler respons Anda di context.result objek. Hasilnya adalah string JSON 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 hasil menjadi daftar objek JSON yang mewakili baris yang dikembalikan. 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 banyak baris. toJsonObjectmengembalikan null jika nilai hasilnya tidak valid atau tidak terduga.

Fungsi utilitas

Anda dapat menggunakan pembantu utilitas modul AWS AppSync RDS 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 menjadi: *


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

Urutkan berdasarkan

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 membuat 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 kondisi dengan: 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 } }
        ]}
    }));
}

Anda juga dapat menggunakan operator berikut untuk membandingkan nilai:

Operator	Deskripsi	Jenis nilai yang mungkin
eq	Sama	angka, string, boolean
no	Tidak sama	angka, 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
Tidak mengandung	Tidak seperti	string
MulaiDengan	Dimulai dengan awalan	string
antara	Antara dua nilai	nomor, string
Atribut Ada	Atributnya bukan null	angka, string, boolean
ukuran	memeriksa panjang elemen	string

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

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 penggunaan MySQL

Anda dapat menggabungkan insert diikuti dengan a select untuk mengambil baris yang dimasukkan:


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 returning untuk mendapatkan data dari baris yang Anda masukkan. Ini 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 ini memungkinkan Anda untuk memperbarui baris yang ada. Anda dapat menggunakan objek kondisi untuk menerapkan perubahan ke kolom yang ditentukan di semua baris yang memenuhi kondisi. Misalnya, katakanlah kita memiliki skema yang memungkinkan kita membuat mutasi ini. Kami ingin memperbarui name of Person dengan id nilai 3 tetapi hanya jika kami telah mengetahuinya (known_since) sejak tahun2000:


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 ini 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 spesifik tentang jenis objek yang benar untuk digunakan dalam pernyataan Anda. Anda dapat menggunakan petunjuk tipe yang disediakan untuk menentukan jenis parameter Anda. AWS AppSync mendukung petunjuk tipe yang sama dengan API Data. Anda dapat mentransmisikan parameter Anda dengan menggunakan typeHint fungsi dari AWS AppSync rds modul.

Contoh berikut memungkinkan Anda mengirim array sebagai nilai yang dicetak sebagai objek JSON. Kami menggunakan -> operator untuk mengambil elemen di index 2 dalam array 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
}

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 jenis yang tersedia

typeHint.DATE- Parameter yang sesuai dikirim sebagai objek dari DATE tipe ke database. Format yang diterima adalah YYYY-MM-DD.
typeHint.DECIMAL- Parameter yang sesuai dikirim sebagai objek dari DECIMAL tipe ke database.
typeHint.JSON- Parameter yang sesuai dikirim sebagai objek dari JSON tipe 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