Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Modul bawaan Modul adalah bagian dari `APPSYNC_JS` runtime dan menyediakan utilitas untuk membantu menulis JavaScript resolver dan fungsi. Untuk sampel dan contoh, lihat [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub repositori. ## Fungsi modul DynamoDB Fungsi modul DynamoDB memberikan pengalaman yang ditingkatkan saat berinteraksi dengan sumber data DynamoDB. Anda dapat membuat permintaan terhadap sumber data DynamoDB Anda menggunakan fungsi dan tanpa menambahkan pemetaan tipe. Modul diimpor menggunakan`@aws-appsync/utils/dynamodb`: ``` // Modules are imported using @aws-appsync/utils/dynamodb import * as ddb from '@aws-appsync/utils/dynamodb'; ``` ### Fungsi #### Daftar fungsi **` get(payload: GetInput): DynamoDBGetItemRequest`** Lihat [Masukan](#built-in-ddb-modules-inputs) untuk informasi tentang GetInput. Menghasilkan `DynamoDBGetItemRequest` objek untuk membuat [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)permintaan ke DynamoDB. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Menghasilkan `DynamoDBPutItemRequest` objek untuk membuat [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)permintaan ke DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.put({ key: { id: util.autoId() }, item: ctx.args }); } ``` **`remove(payload): DynamoDBDeleteItemRequest`** Menghasilkan `DynamoDBDeleteItemRequest` objek untuk membuat [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)permintaan ke DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return ddb.remove({ key: { id: ctx.args.id } }); } ``` **`scan(payload): DynamoDBScanRequest`** Menghasilkan permintaan `DynamoDBScanRequest` untuk membuat [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) ke DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken } = ctx.args; return ddb.scan({ limit, nextToken }); } ``` **`sync(payload): DynamoDBSyncRequest`** Menghasilkan `DynamoDBSyncRequest` objek untuk membuat permintaan [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). Permintaan hanya menerima data yang diubah sejak kueri terakhir (pembaruan delta). Permintaan hanya dapat dibuat ke sumber data DynamoDB berversi. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken, lastSync } = ctx.args; return ddb.sync({ limit, nextToken, lastSync }); } ``` **`update(payload): DynamoDBUpdateItemRequest`** Menghasilkan `DynamoDBUpdateItemRequest` objek untuk membuat [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)permintaan ke DynamoDB. ### Operasi Pembantu operasi memungkinkan Anda untuk mengambil tindakan spesifik pada bagian data Anda selama pembaruan. Untuk memulai, impor `operations` dari`@aws-appsync/utils/dynamodb`: ``` // Modules are imported using operations import {operations} from '@aws-appsync/utils/dynamodb'; ``` #### Daftar operasi **`add(payload)`** Fungsi pembantu yang menambahkan item atribut baru saat memperbarui DynamoDB. **Contoh** Untuk menambahkan alamat (jalan, kota, dan kode pos) ke item DynamoDB yang ada menggunakan nilai ID: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { address: operations.add({ street1: '123 Main St', city: 'New York', zip: '10001', }), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`append (payload)`** Fungsi pembantu yang menambahkan payload ke daftar yang ada di DynamoDB. **Contoh** Untuk menambahkan friend IDs (`newFriendIds`) yang baru ditambahkan ke daftar teman yang ada (`friendsIds`) selama pembaruan: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.append(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`decrement (by?)`** Fungsi pembantu yang mengurangi nilai atribut yang ada di item saat memperbarui DynamoDB. **Contoh** Untuk mengurangi counter teman (`friendsCount`) sebesar 10: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.decrement(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`increment (by?)`** Fungsi pembantu yang menambah nilai atribut yang ada di item saat memperbarui DynamoDB. **Contoh** Untuk menambah counter teman (`friendsCount`) sebesar 10: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.increment(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`prepend (payload)`** Fungsi pembantu yang ditambahkan ke daftar yang ada di DynamoDB. **Contoh** Untuk menambahkan friend IDs (`newFriendIds`) yang baru ditambahkan ke daftar teman yang ada (`friendsIds`) selama pembaruan: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.prepend(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`replace (payload)`** Fungsi pembantu yang menggantikan atribut yang ada saat memperbarui item di DynamoDB. Ini berguna ketika Anda ingin memperbarui seluruh objek atau subobject di atribut dan bukan hanya kunci di payload. **Contoh** Untuk mengganti alamat (jalan, kota, dan kode pos) dalam suatu `info` objek: ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { info: { address: operations.replace({ street1: '123 Main St', city: 'New York', zip: '10001', }), }, }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`updateListItem (payload, index)`** Fungsi pembantu yang menggantikan item dalam daftar. **Contoh** Dalam lingkup update (`newFriendIds`), contoh ini digunakan `updateListItem` untuk memperbarui nilai ID dari item kedua (index:`1`, new ID:`102`) dan item ketiga (index:`2`, new ID:`112`) dalam list (`friendsIds`). ``` import { update, operations as ops } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [ ops.updateListItem('102', 1), ops.updateListItem('112', 2) ]; const updateObj = { friendsIds: newFriendIds }; return update({ key: { id: 1 }, update: updateObj }); } ``` ### Masukan #### Daftar masukan **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Jenis Deklarasi** + `consistentRead?: boolean` (opsional) Boolean opsional untuk menentukan apakah Anda ingin melakukan pembacaan yang sangat konsisten dengan DynamoDB. + `key: DynamoDBKey`(Diperlukan) Parameter yang diperlukan yang menentukan kunci item di DynamoDB. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir. **`Type PutInput`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Jenis Deklarasi** + `_version?: number` (opsional) + `condition?: DynamoDBFilterObject | null` (opsional) Ketika Anda meletakkan objek dalam tabel DynamoDB, Anda dapat secara opsional menentukan ekspresi kondisional yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan. + `customPartitionKey?: string` (opsional) Saat diaktifkan, nilai string ini memodifikasi format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan. + `item: Partial`(Diperlukan) Sisa atribut item yang akan ditempatkan ke DynamoDB. + `key: DynamoDBKey`(Diperlukan) Parameter yang diperlukan yang menentukan kunci item di DynamoDB di mana put akan dilakukan. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir. + `populateIndexFields?: boolean` (opsional) Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk` Untuk informasi selengkapnya, lihat [Deteksi dan sinkronisasi konflik](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) di *Panduan AWS AppSync Pengembang*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Jenis Deklarasi** + `query: DynamoDBKeyCondition>`(Diperlukan) Menentukan kondisi kunci yang menjelaskan item untuk query. Untuk indeks tertentu, kondisi untuk kunci partisi harus berupa persamaan dan kunci pengurutan perbandingan atau a `beginsWith` (ketika itu adalah string). Hanya tipe angka dan string yang didukung untuk kunci partisi dan sortir. **Contoh** Ambil `User` tipe di bawah ini: ``` type User = { id: string; name: string; age: number; isVerified: boolean; friendsIds: string[] } ``` Kueri hanya dapat menyertakan bidang-bidang berikut:`id`,`name`, dan`age`: ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Jenis Deklarasi** + `_version?: number` (opsional) + `condition?: DynamoDBFilterObject` (opsional) Saat Anda menghapus objek di DynamoDB, Anda dapat secara opsional menentukan ekspresi bersyarat yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan. **Contoh** Contoh berikut adalah `DeleteItem` ekspresi yang berisi kondisi yang memungkinkan operasi berhasil hanya jika pemilik dokumen cocok dengan pengguna yang membuat permintaan. ``` type Task = { id: string; title: string; description: string; owner: string; isComplete: boolean; } const condition: DynamoDBFilterObject = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (opsional) Saat diaktifkan, `customPartitionKey` nilai mengubah format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan. + `key: DynamoDBKey`(Diperlukan) Parameter yang diperlukan yang menentukan kunci item di DynamoDB yang sedang dihapus. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir. **Contoh** Jika `User` hanya memiliki kunci hash dengan pengguna`id`, maka kuncinya akan terlihat seperti ini: ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { id: 1, } ``` Jika pengguna tabel memiliki kunci hash (`id`) dan sort key (`name`), maka kuncinya akan terlihat seperti ini: ``` type User = { id: number name: string age: number isVerified: boolean friendsIds: string[] } const key: DynamoDBKey = { id: 1, name: 'XXXXXXXXXX', } ``` + `populateIndexFields?: boolean` (opsional) Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk` **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | null; index?: string | null; limit?: number | null; nextToken?: string | null; scanIndexForward?: boolean | null; segment?: number; select?: DynamoDBSelectAttributes; totalSegments?: number; } ``` **Jenis Deklarasi** + `consistentRead?: boolean | null` (opsional) Boolean opsional untuk menunjukkan pembacaan yang konsisten saat menanyakan DynamoDB. Nilai default-nya adalah `false`. + `filter?: DynamoDBFilterObject | null` (opsional) Filter opsional untuk diterapkan pada hasil setelah mengambilnya dari tabel. + `index?: string | null` (opsional) Nama opsional indeks untuk memindai. + `limit?: number | null` (opsional) Jumlah maksimal hasil opsional untuk dikembalikan. + `nextToken?: string | null` (opsional) Token pagination opsional untuk melanjutkan kueri sebelumnya. Ini akan diperoleh dari kueri sebelumnya. + `scanIndexForward?: boolean | null` (opsional) Boolean opsional untuk menunjukkan apakah kueri dilakukan dalam urutan naik atau turun. Secara default, nilai ini diatur ke `true`. + `segment?: number` (opsional) + `select?: DynamoDBSelectAttributes` (opsional) Atribut untuk kembali dari DynamoDB. Secara default, AWS AppSync DynamoDB resolver hanya mengembalikan atribut yang diproyeksikan ke dalam indeks. Nilai yang didukung adalah: + `ALL_ATTRIBUTES` Mengembalikan semua atribut item dari tabel tertentu atau indeks. Jika Anda menanyakan indeks sekunder lokal, DynamoDB mengambil seluruh item dari tabel induk untuk setiap item yang cocok dalam indeks. Jika indeks dikonfigurasi untuk memproyeksikan semua atribut item, semua data dapat diperoleh dari indeks sekunder lokal dan tidak diperlukan pengambilan. + `ALL_PROJECTED_ATTRIBUTES` Mengembalikan semua atribut yang telah diproyeksikan ke dalam indeks. Jika indeks dikonfigurasi untuk memproyeksikan semua atribut, nilai pengembalian ini setara dengan menentukan`ALL_ATTRIBUTES`. + `SPECIFIC_ATTRIBUTES` Mengembalikan hanya atribut yang tercantum dalam`ProjectionExpression`. Nilai pengembalian ini setara dengan menentukan `ProjectionExpression` tanpa menentukan nilai apa pun untuk. `AttributesToGet` + `totalSegments?: number` (opsional) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Jenis Deklarasi** + `basePartitionKey?: string` (opsional) Kunci partisi dari tabel dasar yang akan digunakan saat melakukan operasi Sync. Bidang ini memungkinkan operasi Sync dilakukan ketika tabel menggunakan kunci partisi kustom. + `deltaIndexName?: string` (opsional) Indeks yang digunakan untuk operasi Sync. Indeks ini diperlukan untuk mengaktifkan operasi Sinkronisasi di seluruh tabel penyimpanan delta saat tabel menggunakan kunci partisi khusus. Operasi Sinkronisasi akan dilakukan pada GSI (dibuat pada `gsi_ds_pk` dan`gsi_ds_sk`). + `filter?: DynamoDBFilterObject | null` (opsional) Filter opsional untuk diterapkan pada hasil setelah mengambilnya dari tabel. + `lastSync?: number` (opsional) Saat itu, dalam milidetik epoch, di mana operasi Sync sukses terakhir dimulai. Jika ditentukan, hanya item yang telah berubah setelah `lastSync` dikembalikan. Bidang ini seharusnya hanya diisi setelah mengambil semua halaman dari operasi Sinkronisasi awal. Jika dihilangkan, hasil dari tabel dasar akan dikembalikan. Jika tidak, hasil dari tabel delta akan dikembalikan. + `limit?: number | null` (opsional) Jumlah maksimum opsional item untuk dievaluasi pada satu waktu. Jika dihilangkan, batas default akan diatur ke `100` item. Nilai maksimum untuk bidang ini adalah `1000` item. + `nextToken?: string | null` (opsional) **`Type DynamoDBUpdateInput`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Jenis Deklarasi** + `_version?: number` (opsional) + `condition?: DynamoDBFilterObject` (opsional) Saat Anda memperbarui objek di DynamoDB, Anda dapat secara opsional menentukan ekspresi bersyarat yang mengontrol apakah permintaan harus berhasil atau tidak berdasarkan status objek yang sudah ada di DynamoDB sebelum operasi dilakukan. + `customPartitionKey?: string` (opsional) Saat diaktifkan, `customPartitionKey` nilai mengubah format `ds_sk` dan `ds_pk` catatan yang digunakan oleh tabel sinkronisasi delta saat pembuatan versi telah diaktifkan. Saat diaktifkan, pemrosesan `populateIndexFields` entri juga diaktifkan. + `key: DynamoDBKey`(Diperlukan) Parameter yang diperlukan yang menentukan kunci item di DynamoDB yang sedang diperbarui. Item DynamoDB mungkin memiliki kunci hash tunggal atau kunci hash dan sortir. + `populateIndexFields?: boolean` (opsional) Nilai boolean yang, ketika diaktifkan bersama dengan`customPartitionKey`, membuat entri baru untuk setiap catatan dalam tabel sinkronisasi delta, khususnya di kolom dan`gsi_ds_pk`. `gsi_ds_sk` + `update: DynamoDBUpdateObject` Objek yang menentukan atribut yang akan diperbarui bersama dengan nilai-nilai baru untuk mereka. Objek pembaruan dapat digunakan dengan`add`,`remove`,`replace`,`increment`,`decrement`,`append`,`prepend`,`updateListItem`. ## Fungsi modul Amazon RDS Fungsi modul Amazon RDS memberikan pengalaman yang disempurnakan saat berinteraksi dengan database yang dikonfigurasi dengan Amazon RDS Data API. Modul diimpor menggunakan`@aws-appsync/utils/rds`: ``` import * as rds from '@aws-appsync/utils/rds'; ``` Fungsi juga dapat diimpor secara individual. Misalnya, impor di bawah ini menggunakan`sql`: ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Fungsi Anda dapat menggunakan pembantu utilitas modul AWS AppSync RDS untuk berinteraksi dengan database Anda. #### 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 `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) } ``` #### Perbarui `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` yang diperbarui. Demikian pula, untuk Postgres`inserts`, Anda dapat menggunakan `returning` untuk mengembalikan data yang dimodifikasi. #### Menghapus `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.