Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memanggil Amazon RDS Data API
Dengan Amazon RDS Data API (Data API) diaktifkan pada cluster Aurora DB Anda, Anda dapat menjalankan pernyataan SQL pada cluster Aurora DB dengan menggunakan Data API atau file. AWS CLI Data API mendukung bahasa pemrograman yang didukung oleh AWS SDKs. Untuk informasi selengkapnya, lihat [Alat untuk dibangun AWS](https://aws.amazon.com/tools/).
**Topics**
+ [Referensi operasi Amazon RDS Data API](data-api-operations.md)
+ [Memanggil API Data Amazon RDS dengan AWS CLI](data-api.calling.cli.md)
+ [Memanggil Amazon RDS Data API dari aplikasi Python](data-api.calling.python.md)
+ [Memanggil Amazon RDS Data API dari aplikasi Java](data-api.calling.java.md)
+ [Mengontrol perilaku batas waktu API Data](data-api-timeouts.md)
# Referensi operasi Amazon RDS Data API
Amazon RDS Data API menyediakan operasi berikut untuk melakukan pernyataan SQL.
****
| Operasi API Data | AWS CLI perintah | Deskripsi |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html) | Menjalankan pernyataan SQL pada basis data. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html) | Menjalankan pernyataan SQL batch pada array data untuk pembaruan massal dan operasi penyisipan. Anda dapat menjalankan pernyataan bahasa manipulasi data (DML) dengan array set parameter. Pernyataan SQL batch dapat memberikan peningkatan performa yang signifikan atas pernyataan penyisipan dan pembaruan individu. |
Anda dapat menggunakan operasi mana pun untuk menjalankan pernyataan SQL individual atau untuk menjalankan transaksi. Untuk transaksi, Data API menyediakan operasi berikut.
****
| Operasi API Data | AWS CLI perintah | Deskripsi |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html) | Memulai transaksi SQL. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html) | Mengakhiri transaksi SQL dan menerapkan perubahan. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html) | Melakukan pembatalan transaksi. |
Operasi untuk melakukan pernyataan SQL dan transaksi pendukung memiliki parameter dan AWS CLI opsi API Data umum berikut. Beberapa operasi mendukung parameter atau opsi lain.
****
| Parameter operasi API Data | AWS CLI opsi perintah | Diperlukan | Deskripsi |
| --- | --- | --- | --- |
| `resourceArn` | `--resource-arn` | Ya | Nama Sumber Daya Amazon (ARN) dari cluster Aurora DB. Cluster harus Akun AWS sama dengan peran IAM atau pengguna yang memanggil API Data. Untuk mengakses klaster di akun yang berbeda, ambil peran dalam akun itu. |
| `secretArn` | `--secret-arn` | Ya | Nama atau ARN rahasia yang memungkinkan akses ke klaster basis data. |
RDS Data API mendukung tipe data berikut untuk Aurora MySQL:
+ `TINYINT(1)`, `BOOLEAN`, `BOOL`
+ `TINYINT`
+ `SMALLINT` [`SIGNED` \$1 `UNSIGNED`]
+ `MEDIUMINT` [`SIGNED` \$1 `UNSIGNED`]
+ `INT` [`SIGNED` \$1 `UNSIGNED`]
+ `BIGINT` [`SIGNED` \$1 `UNSIGNED`]
+ `FLOAT`
+ `DOUBLE`
+ `VARCHAR`, `CHAR`, `TEXT`, `ENUM`
+ `VARBINARY`, `BINARY`, `BLOB`
+ `DATE`, `TIME`, `DATETIME`, `TIMESTAMP`
+ `DECIMAL`
+ `JSON`
+ `BIT`, `BIT(N)`
RDS Data API mendukung jenis skalar Aurora PostgreSQL berikut:
+ `BOOL`
+ `BYTEA`
+ `DATE`
+ `CIDR`
+ `DECIMAL`, `NUMERIC`
+ `ENUM`
+ `FLOAT8`, `DOUBLE PRECISION`
+ `INET`
+ `INT`, `INT4`, `SERIAL`
+ `INT2`, `SMALLINT`, `SMALLSERIAL`
+ `INT8`, `BIGINT`, `BIGSERIAL`
+ `JSONB`, `JSON`
+ `REAL`, `FLOAT`
+ `TEXT`, `CHAR(N)`, `VARCHAR`, `NAME`
+ `TIME`
+ `TIMESTAMP`
+ `UUID`
+ `VECTOR`
RDS Data API mendukung tipe array Aurora PostgreSQL berikut:
+ `BOOL[]`, `BIT[]`
+ `DATE[]`
+ `DECIMAL[]`, `NUMERIC[]`
+ `FLOAT8[]`, `DOUBLE PRECISION[]`
+ `INT[]`, `INT4[]`
+ `INT2[]`
+ `INT8[]`, `BIGINT[]`
+ `JSON[]`
+ `REAL[]`, `FLOAT[]`
+ `TEXT[]`, `CHAR(N)[]`, `VARCHAR[]`, `NAME[]`
+ `TIME[]`
+ `TIMESTAMP[]`
+ `UUID[]`
Anda dapat menggunakan parameter dalam panggilan Data API ke `ExecuteStatement` dan`BatchExecuteStatement`, dan ketika Anda menjalankan AWS CLI perintah `execute-statement` dan`batch-execute-statement`. Untuk menggunakan parameter, tentukan pasangan nama-nilai di tipe data `SqlParameter`. Tentukan nilai dengan tipe data `Field`. Tabel berikut memetakan tipe data Java Database Connectivity (JDBC) ke tipe data yang Anda tentukan dalam panggilan API Data.
****
| Tipe data JDBC | Tipe data API Data |
| --- | --- |
| `INTEGER, TINYINT, SMALLINT, BIGINT` | `LONG` (atau `STRING`) |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY, VARBINARY` | `BLOB` |
| `CLOB` | `STRING` |
| Tipe lainnya (termasuk tipe terkait tanggal dan waktu) | `STRING` |
**catatan**
Anda dapat menentukan tipe data `LONG` atau `STRING` dalam panggilan API Data Anda untuk nilai `LONG` yang dihasilkan oleh basis data. Kami menyarankan Anda melakukannya untuk menghindari kehilangan presisi untuk jumlah yang sangat besar, yang dapat terjadi ketika Anda bekerja dengan JavaScript.
Tipe tertentu, seperti `DECIMAL` dan`TIME`, memerlukan petunjuk agar Data API meneruskan `String` nilai ke database sebagai tipe yang benar. Untuk menggunakan petunjuk, sertakan nilai untuk `typeHint` di tipe data `SqlParameter`. Berikut adalah nilai-nilai yang mungkin untuk `typeHint`:
+ `DATE` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `DATE` ke basis data. Format yang diterima adalah `YYYY-MM-DD`.
+ `DECIMAL` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `DECIMAL` ke basis data.
+ `JSON` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `JSON` ke basis data.
+ `TIME` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `TIME` ke basis data. Format yang diterima adalah `HH:MM:SS[.FFF]`.
+ `TIMESTAMP` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `TIMESTAMP` ke basis data. Format yang diterima adalah `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `UUID` – Nilai parameter `String` yang sesuai dikirim sebagai objek tipe `UUID` ke basis data.
**catatan**
Saat ini, Data API tidak mendukung array Universal Unique Identifiers ()UUIDs.
**catatan**
Untuk Amazon Aurora PostgreSQL, Data API selalu menampilkan tipe data Aurora PostgreSQL di zona waktu UTC. `TIMESTAMPTZ`
# Memanggil API Data Amazon RDS dengan AWS CLI
Anda dapat memanggil RDS Data API (Data API) menggunakan file. AWS CLI
Contoh berikut menggunakan AWS CLI for Data API. Lihat informasi selengkapnya di [Referensi AWS CLI untuk API Data](https://docs.aws.amazon.com/cli/latest/reference/rds-data/index.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) untuk cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**catatan**
Kaleng AWS CLI memformat tanggapan di JSON.
**Topics**
+ [Memulai transaksi SQL](#data-api.calling.cli.begin-transaction)
+ [Menjalankan pernyataan SQL](#data-api.calling.cli.execute-statement)
+ [Menjalankan pernyataan SQL batch pada array data](#data-api.calling.cli.batch-execute-statement)
+ [Menerapkan transaksi SQL](#data-api.calling.cli.commit-transaction)
+ [Membatalkan transaksi SQL](#data-api.calling.cli.rollback-transaction)
## Memulai transaksi SQL
Anda dapat memulai transaksi SQL menggunakan perintah CLI `aws rds-data begin-transaction`. Panggilan ini menghasilkan pengidentifikasi transaksi.
**penting**
Dalam Data API, transaksi akan habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum dilakukan, Data API akan mengembalikannya secara otomatis.
Pernyataan bahasa definisi data MySQL (DDL) di dalam transaksi menyebabkan komit implisit. Kami menyarankan Anda menjalankan setiap pernyataan MySQL DDL dalam perintah `execute-statement` terpisah dengan opsi. `--continue-after-timeout`
Selain opsi umum, tentukan opsi `--database` yang menyediakan nama basis data.
Misalnya, perintah CLI berikut memulai transaksi SQL.
Untuk Linux, macOS, atau Unix:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Untuk Windows:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionId": "ABC1234567890xyz"
}
```
## Menjalankan pernyataan SQL
Anda dapat menjalankan pernyataan SQL menggunakan perintah CLI `aws rds-data execute-statement`.
Anda dapat menjalankan pernyataan SQL dalam transaksi dengan menentukan pengidentifikasi transaksi dengan opsi `--transaction-id`. Anda dapat memulai transaksi menggunakan perintah CLI `aws rds-data begin-transaction`. Anda dapat mengakhiri dan menerapkan transaksi menggunakan perintah CLI `aws rds-data commit-transaction`.
**penting**
Jika Anda tidak menentukan opsi `--transaction-id`, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--sql` (wajib) – Pernyataan SQL untuk dijalankan pada klaster basis data.
+ `--transaction-id` (opsional) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda sertakan pernyataan SQL-nya.
+ `--parameters` (opsional) – Parameter untuk pernyataan SQL.
+ `--include-result-metadata | --no-include-result-metadata` (opsional) – Nilai yang menunjukkan apakah metadata disertakan dalam hasil. Nilai default-nya `--no-include-result-metadata`.
+ `--database` (opsional) – Nama basis data.
Opsi `--database` mungkin tidak berfungsi ketika Anda menjalankan pernyataan SQL setelah menjalankan `--sql "use database_name;"` di permintaan sebelumnya. Kami merekomendasikan agar Anda menggunakan `--database` opsi, bukan menjalankan pernyataan `--sql "use database_name;"`.
+ `--continue-after-timeout | --no-continue-after-timeout`(opsional) — Nilai yang menunjukkan apakah akan terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data 45 detik. Nilai default-nya `--no-continue-after-timeout`.
Untuk pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis untuk menghindari kesalahan dan kemungkinan struktur data rusak.
+ `--format-records-as "JSON"|"NONE"` – Nilai opsional yang menentukan apakah hasil yang ditetapkan akan diformat sebagai string JSON. Nilai default-nya `"NONE"`. Lihat informasi penggunaan tentang pemrosesan set hasil JSON di [Memproses hasil kueri Amazon RDS Data API dalam format JSON](data-api-json.md).
Klaster basis data menghasilkan respons untuk panggilan.
**catatan**
Batas ukuran respons adalah 1 MiB. Jika panggilan menghasilkan data respons dengan ukuran lebih dari 1 MiB, panggilan tersebut akan diakhiri.
UntukAurora Serverless v1, jumlah maksimum permintaan per detik adalah 1.000. Untuk semua database lain yang didukung, tidak ada batasan.
Misalnya, perintah CLI berikut menjalankan satu pernyataan SQL dan menghilangkan metadata dalam hasil (default).
Untuk Linux, macOS, atau Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "select * from mytable"
```
Untuk Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "select * from mytable"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 0,
"records": [
[
{
"longValue": 1
},
{
"stringValue": "ValueOne"
}
],
[
{
"longValue": 2
},
{
"stringValue": "ValueTwo"
}
],
[
{
"longValue": 3
},
{
"stringValue": "ValueThree"
}
]
]
}
```
Perintah CLI berikut menjalankan satu pernyataan SQL dalam transaksi dengan menentukan opsi `--transaction-id`.
Untuk Linux, macOS, atau Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Untuk Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 1
}
```
Perintah CLI berikut menjalankan satu pernyataan SQL dengan parameter.
Untuk Linux, macOS, atau Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Untuk Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Berikut adalah contoh respons tersebut.
```
{
"numberOfRecordsUpdated": 1
}
```
Perintah CLI berikut menjalankan pernyataan SQL bahasa definisi data (DDL). Pernyataan DDL mengganti nama kolom `job` menjadi kolom `role`.
**penting**
Untuk pernyataan DDL, kami merekomendasikan agar Anda terus menjalankan pernyataan tersebut setelah waktu panggilan habis. Ketika pernyataan DDL berakhir sebelum selesai dijalankan, itu dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, tentukan opsi. `--continue-after-timeout`
Untuk Linux, macOS, atau Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Untuk Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Berikut adalah contoh respons tersebut.
```
{
"generatedFields": [],
"numberOfRecordsUpdated": 0
}
```
**catatan**
Data `generatedFields` tidak didukung oleh Aurora PostgreSQL. Untuk mendapatkan nilai-nilai bidang yang dihasilkan, gunakan klausa `RETURNING`. Lihat informasi selengkapnya di [Returning data from modified rows](https://www.postgresql.org/docs/10/dml-returning.html) dalam dokumentasi PostgreSQL.
## Menjalankan pernyataan SQL batch pada array data
Anda dapat menjalankan pernyataan SQL batch pada array data dengan menggunakan perintah CLI `aws rds-data batch-execute-statement`. Anda dapat menggunakan perintah ini untuk melakukan impor massal atau operasi pembaruan.
Anda dapat menjalankan pernyataan SQL dalam transaksi dengan menentukan pengidentifikasi transaksi dengan opsi `--transaction-id`. Anda dapat memulai transaksi menggunakan perintah CLI `aws rds-data begin-transaction`. Anda dapat mengakhiri dan menerapkan transaksi menggunakan perintah CLI `aws rds-data commit-transaction`.
**penting**
Jika Anda tidak menentukan opsi `--transaction-id`, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--sql` (wajib) – Pernyataan SQL untuk dijalankan pada klaster basis data.
**Tip**
Untuk pernyataan yang kompatibel dengan MySQL, jangan sertakan titik koma di akhir parameter `--sql`. Titik koma di belakang dapat menyebabkan kesalahan sintaksis.
+ `--transaction-id` (opsional) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda sertakan pernyataan SQL-nya.
+ `--parameter-set` (opsional) – Set parameter untuk operasi batch.
+ `--database` (opsional) – Nama basis data.
Klaster basis data menghasilkan respons untuk panggilan.
**catatan**
Tidak ada batas atas tetap pada jumlah set parameter. Namun, ukuran maksimum permintaan HTTP yang dikirimkan melalui Data API adalah 4 MiB. Jika permintaan melebihi batas ini, Data API mengembalikan kesalahan dan tidak memproses permintaan. Batas 4 MiB ini mencakup ukuran header HTTP dan notasi JSON dalam permintaan. Dengan demikian, jumlah set parameter yang dapat Anda sertakan tergantung pada kombinasi faktor, seperti ukuran pernyataan SQL dan ukuran setiap set parameter.
Batas ukuran respons adalah 1 MiB. Jika panggilan menghasilkan data respons dengan ukuran lebih dari 1 MiB, panggilan tersebut akan diakhiri.
UntukAurora Serverless v1, jumlah maksimum permintaan per detik adalah 1.000. Untuk semua database lain yang didukung, tidak ada batasan.
Misalnya, perintah CLI berikut menjalankan pernyataan SQL batch pada array data dengan satu set parameter.
Untuk Linux, macOS, atau Unix:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" \
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
Untuk Windows:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" ^
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
**catatan**
Jangan sertakan jeda baris di opsi `--parameter-sets`.
## Menerapkan transaksi SQL
Dengan menggunakan perintah CLI `aws rds-data commit-transaction`, Anda dapat mengakhiri transaksi SQL yang Anda mulai dengan `aws rds-data begin-transaction` dan menerapkan perubahan.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--transaction-id` (wajib) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda akhiri dan terapkan.
Misalnya, perintah CLI berikut mengakhiri transaksi SQL dan menerapkan perubahan.
Untuk Linux, macOS, atau Unix:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Untuk Windows:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionStatus": "Transaction Committed"
}
```
## Membatalkan transaksi SQL
Dengan menggunakan perintah CLI `aws rds-data rollback-transaction`, Anda dapat membatalkan transaksi SQL yang Anda mulai dengan `aws rds-data begin-transaction`. Membatalkan transaksi akan membatalkan perubahannya.
**penting**
Jika ID transaksi telah kedaluwarsa, transaksi dibatalkan secara otomatis. Dalam kasus ini, perintah `aws rds-data rollback-transaction` yang menentukan ID transaksi yang kedaluwarsa akan menghasilkan kesalahan.
Selain opsi umum, tentukan opsi-opsi berikut:
+ `--transaction-id` (wajib) – Pengidentifikasi transaksi yang dimulai menggunakan perintah CLI `begin-transaction`. Tentukan ID transaksi yang ingin Anda batalkan.
Misalnya, AWS CLI perintah berikut memutar kembali transaksi SQL.
Untuk Linux, macOS, atau Unix:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Untuk Windows:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Berikut adalah contoh respons tersebut.
```
{
"transactionStatus": "Rollback Complete"
}
```
# Memanggil Amazon RDS Data API dari aplikasi Python
Anda dapat memanggil Amazon RDS Data API (Data API) dari aplikasi Python.
Contoh berikut menggunakan AWS SDK untuk Python (Boto). Lihat informasi selengkapnya tentang Boto, lihat [Dokumentasi AWS SDK for Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**Topics**
+ [Menjalankan kueri SQL](#data-api.calling.python.run-query)
+ [Menjalankan pernyataan SQL DML](#data-api.calling.python.run-inert)
+ [Menjalankan transaksi SQL](#data-api.calling.python.run-transaction)
## Menjalankan kueri SQL
Anda dapat menjalankan pernyataan `SELECT` dan mengambil hasilnya dengan aplikasi Python.
Contoh berikut menjalankan kueri SQL.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
response1 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'select * from employees limit 3')
print (response1['records'])
[
[
{
'longValue': 1
},
{
'stringValue': 'ROSALEZ'
},
{
'stringValue': 'ALEJANDRO'
},
{
'stringValue': '2016-02-15 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'DOE'
},
{
'stringValue': 'JANE'
},
{
'stringValue': '2014-05-09 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'STILES'
},
{
'stringValue': 'JOHN'
},
{
'stringValue': '2017-09-20 04:34:33.0'
}
]
]
```
## Menjalankan pernyataan SQL DML
Anda dapat menjalankan pernyataan bahasa manipulasi data (DML) untuk memasukkan, memperbarui, atau menghapus data dalam basis data Anda. Anda juga dapat menggunakan parameter dalam pernyataan DML.
**penting**
Jika panggilan bukan bagian dari transaksi karena tidak menyertakan parameter `transactionID`, perubahan yang dihasilkan dari panggilan tersebut diterapkan secara otomatis.
Contoh berikut menjalankan pernyataan penyisipan SQL dan menggunakan parameter.
```
import boto3
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
rdsData = boto3.client('rds-data')
param1 = {'name':'firstname', 'value':{'stringValue': 'JACKSON'}}
param2 = {'name':'lastname', 'value':{'stringValue': 'MATEO'}}
paramSet = [param1, param2]
response2 = rdsData.execute_statement(resourceArn=cluster_arn,
secretArn=secret_arn,
database='mydb',
sql='insert into employees(first_name, last_name) VALUES(:firstname, :lastname)',
parameters = paramSet)
print (response2["numberOfRecordsUpdated"])
```
## Menjalankan transaksi SQL
Anda dapat memulai transaksi SQL, menjalankan satu atau beberapa pernyataan SQL, lalu menerapkan perubahan dengan aplikasi Python.
**penting**
Waktu transaksi habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum diterapkan, transaksi akan dibatalkan secara otomatis.
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan transaksi SQL yang menyisipkan baris dalam tabel.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
tr = rdsData.begin_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb')
response3 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'insert into employees(first_name, last_name) values('XIULAN', 'WANG')',
transactionId = tr['transactionId'])
cr = rdsData.commit_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
transactionId = tr['transactionId'])
cr['transactionStatus']
'Transaction Committed'
response3['numberOfRecordsUpdated']
1
```
**catatan**
Jika Anda menjalankan pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis. Ketika pernyataan DDL dihentikan sebelum selesai dijalankan, hal ini dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, setel `continueAfterTimeout` parameter ke. `true`
# Memanggil Amazon RDS Data API dari aplikasi Java
Anda dapat memanggil Amazon RDS Data API (Data API) dari aplikasi Java.
Contoh berikut menggunakan AWS SDK for Java. Lihat informasi selengkapnya di [Panduan Developer AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/welcome.html).
Dalam setiap contoh, ganti Amazon Resource Name (ARN) cluster DB dengan ARN untuk cluster Aurora DB Anda. Selain itu, ganti ARN rahasia dengan ARN rahasia di Secrets Manager yang mengizinkan akses ke klaster basis data.
**Topics**
+ [Menjalankan kueri SQL](#data-api.calling.java.run-query)
+ [Menjalankan transaksi SQL](#data-api.calling.java.run-transaction)
+ [Menjalankan operasi SQL batch](#data-api.calling.java.run-batch)
## Menjalankan kueri SQL
Anda dapat menjalankan pernyataan `SELECT` dan mengambil hasilnya dengan aplikasi Java.
Contoh berikut menjalankan kueri SQL.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementResult;
import com.amazonaws.services.rdsdata.model.Field;
import java.util.List;
public class FetchResultsExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
ExecuteStatementRequest request = new ExecuteStatementRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb")
.withSql("select * from mytable");
ExecuteStatementResult result = rdsData.executeStatement(request);
for (List fields: result.getRecords()) {
String stringValue = fields.get(0).getStringValue();
long numberValue = fields.get(1).getLongValue();
System.out.println(String.format("Fetched row: string = %s, number = %d", stringValue, numberValue));
}
}
}
```
## Menjalankan transaksi SQL
Anda dapat memulai transaksi SQL, menjalankan satu atau beberapa pernyataan SQL, lalu menerapkan perubahan dengan aplikasi Java.
**penting**
Waktu transaksi habis jika tidak ada panggilan yang menggunakan ID transaksinya dalam tiga menit. Jika waktu transaksi habis sebelum diterapkan, transaksi akan dibatalkan secara otomatis.
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan transaksi SQL.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BeginTransactionRequest;
import com.amazonaws.services.rdsdata.model.BeginTransactionResult;
import com.amazonaws.services.rdsdata.model.CommitTransactionRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
public class TransactionExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BeginTransactionRequest beginTransactionRequest = new BeginTransactionRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb");
BeginTransactionResult beginTransactionResult = rdsData.beginTransaction(beginTransactionRequest);
String transactionId = beginTransactionResult.getTransactionId();
ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table VALUES ('hello world!')");
rdsData.executeStatement(executeStatementRequest);
CommitTransactionRequest commitTransactionRequest = new CommitTransactionRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN);
rdsData.commitTransaction(commitTransactionRequest);
}
}
```
**catatan**
Jika Anda menjalankan pernyataan bahasa definisi data (DDL), kami merekomendasikan agar Anda terus menjalankan pernyataan setelah waktu panggilan habis. Ketika pernyataan DDL dihentikan sebelum selesai dijalankan, hal ini dapat mengakibatkan kesalahan dan kemungkinan struktur data rusak. Untuk terus menjalankan pernyataan setelah panggilan melebihi interval batas waktu API Data RDS 45 detik, setel `continueAfterTimeout` parameter ke. `true`
## Menjalankan operasi SQL batch
Anda dapat menjalankan operasi penyisipan dan pembaruan massal pada array data dengan aplikasi Java. Anda dapat menjalankan pernyataan DML dengan array set parameter.
**penting**
Jika Anda tidak menentukan ID transaksi, perubahan yang dihasilkan dari panggilan akan diterapkan secara otomatis.
Contoh berikut menjalankan operasi penyisipan batch.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BatchExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.Field;
import com.amazonaws.services.rdsdata.model.SqlParameter;
import java.util.Arrays;
public class BatchExecuteExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BatchExecuteStatementRequest request = new BatchExecuteStatementRequest()
.withDatabase("test")
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table2 VALUES (:string, :number)")
.withParameterSets(Arrays.asList(
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("Hello")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(1L))
),
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("World")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(2L))
)
));
rdsData.batchExecuteStatement(request);
}
}
```
# Mengontrol perilaku batas waktu API Data
Semua panggilan ke API Data bersifat sinkron. Misalkan Anda melakukan operasi API Data yang menjalankan pernyataan SQL seperti `INSERT` atau`CREATE TABLE`. Jika panggilan Data API berhasil kembali, pemrosesan SQL selesai saat panggilan kembali.
Secara default, Data API membatalkan operasi dan mengembalikan kesalahan batas waktu jika operasi tidak selesai diproses dalam waktu 45 detik. Dalam hal ini, data tidak dimasukkan, tabel tidak dibuat, dan sebagainya.
Anda dapat menggunakan Data API untuk melakukan operasi jangka panjang yang tidak dapat diselesaikan dalam waktu 45 detik. Jika Anda berharap bahwa operasi seperti operasi massal `INSERT` atau DDL pada tabel besar membutuhkan waktu lebih dari 45 detik, Anda dapat menentukan `continueAfterTimeout` parameter untuk `ExecuteStatement` operasi tersebut. Aplikasi Anda masih menerima kesalahan batas waktu. Namun, operasi terus berjalan dan tidak dibatalkan. Sebagai contoh, lihat [Menjalankan transaksi SQL](data-api.calling.java.md#data-api.calling.java.run-transaction).
Jika AWS SDK untuk bahasa pemrograman Anda memiliki periode batas waktu sendiri untuk panggilan API atau koneksi soket HTTP, pastikan bahwa semua periode batas waktu tersebut lebih dari 45 detik. Bagi sebagian orang SDKs, periode batas waktu kurang dari 45 detik secara default. Sebaiknya setel periode batas waktu khusus SDK atau khusus klien menjadi setidaknya satu menit. Melakukannya menghindari kemungkinan bahwa aplikasi Anda menerima kesalahan batas waktu sementara operasi Data API masih berhasil diselesaikan. Dengan begitu, Anda dapat yakin apakah akan mencoba kembali operasi atau tidak.
Misalnya, SDK mengembalikan kesalahan batas waktu ke aplikasi Anda, tetapi operasi Data API masih selesai dalam interval batas waktu API Data. Dalam hal ini, mencoba kembali operasi mungkin menyisipkan data duplikat atau menghasilkan hasil yang salah. SDK mungkin mencoba ulang operasi secara otomatis, menyebabkan data yang salah tanpa tindakan apa pun dari aplikasi Anda.
Interval batas waktu sangat penting untuk SDK Java 2. Dalam SDK tersebut, batas waktu panggilan API dan batas waktu soket HTTP keduanya 30 detik secara default. Berikut adalah contoh pengaturan batas waktu tersebut ke nilai yang lebih tinggi:
```
public RdsDataClient createRdsDataClient() {
return RdsDataClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.httpClientBuilder(createHttpClientBuilder())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return ApacheHttpClient.builder() // Change this to your desired HttpClient
.socketTimeout(Duration.ofSeconds(60));
}
```
Berikut adalah contoh yang setara menggunakan klien data asinkron:
```
public static RdsDataAsyncClient createRdsDataAsyncClient() {
return RdsDataAsyncClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallAttemptTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return NettyNioAsyncHttpClient.builder() // Change this to your desired AsyncHttpClient
.readTimeout(Duration.ofSeconds(60));
}
```