Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# AWS AppSync JavaScript referensi fungsi resolver untuk Amazon RDS
Fungsi dan resolver AWS AppSync RDS memungkinkan pengembang untuk mengirim SQL kueri ke database cluster Amazon Aurora menggunakan API Data RDS dan mendapatkan kembali hasil kueri ini. Anda dapat menulis SQL pernyataan yang dikirim ke API Data dengan menggunakan AWS AppSync template `sql` yang diberi tag `rds` modul atau dengan menggunakan fungsi `rds` modul`select`,, `insert``update`, dan `remove` pembantu. AWS AppSync menggunakan [https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html)tindakan RDS Data Service untuk menjalankan pernyataan SQL terhadap database.
**Topik**
+ [Templat dengan tag SQL](#sql-tagged-templates)
+ [Membuat pernyataan](#creating-statements)
+ [Mengambil data](#retrieving-data)
+ [Fungsi utilitas](#utility-functions)
+ [SQL Pilih](#utility-functions-select)
+ [Sisipkan SQL](#utility-functions-insert)
+ [Pembaruan SQL](#utility-functions-update)
+ [SQL Hapus](#utility-functions-delete)
+ [Casting](#casting)
## Templat dengan tag SQL
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 [https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html)kueri yang dikirim ke API Data Tanpa Server Amazon Aurora. 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 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 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 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**
`createPgStatement`dan `createMySQLStatement` tidak luput atau mengutip pernyataan yang dibangun dengan template yang `sql` diberi tag.
## Mengambil data
Hasil dari pernyataan SQL Anda yang dieksekusi tersedia di handler respons Anda di objek. `context.result` Hasilnya adalah string JSON dengan [elemen respons](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_ExecuteStatement.html#API_ExecuteStatement_ResponseElements) 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 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 adalah`1`. Jika Anda memberikan dua pernyataan, panjang array adalah`2`. Setiap hasil dalam array berisi `0` atau lebih baris. `toJsonObject`kembali `null` jika nilai hasil tidak valid atau tidak terduga.
## Fungsi utilitas
Anda dapat menggunakan pembantu utilitas modul AWS AppSync RDS untuk berinteraksi dengan database Anda.
### SQL Pilih
`select`Utilitas membuat `SELECT` pernyataan untuk query 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 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 |
| --- |--- |--- |
| 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 |
| NotBerisi | Tidak suka | string |
| Mulailah dengan | Dimulai dengan awalan | string |
| antara | Antara dua nilai | nomor, string |
| AttributeExists | Atribut tidak null | nomor, string, boolean |
| ukuran | memeriksa panjang elemen | string |
### Sisipkan SQL
`insert`Utilitas 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 penggunaan MySQL**
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 [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)untuk 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)
}
```
### Pembaruan SQL
`update`Utilitas 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 ini`2000`:
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
Penyelesai 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` diperbarui. Demikian pula, untuk Postgres`inserts`, Anda dapat menggunakan `returning` untuk mengembalikan data yang dimodifikasi.
### SQL Hapus
`remove`Utilitas 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. `remove`harus 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](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) dengan Data API. 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 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 membandingkan`DATE`,`TIME`, dan`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)
}
```
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 `DATE` tipe ke database. Format yang diterima adalah `YYYY-MM-DD`.
+ `typeHint.DECIMAL`- Parameter yang sesuai dikirim sebagai objek `DECIMAL` tipe ke database.
+ `typeHint.JSON`- Parameter yang sesuai dikirim sebagai objek `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.