Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # PartiQL - Bahasa kueri yang kompatibel dengan SQL untuk Amazon DynamoDB Amazon DynamoDB mendukung [PartiQL](https://partiql.org/), bahasa kueri yang kompatibel dengan SQL untuk memilih, menyisipkan, memperbarui, dan menghapus data di Amazon DynamoDB. Menggunakan PartiQL, Anda dapat dengan mudah berinteraksi dengan tabel DynamoDB dan menjalankan kueri ad hoc menggunakan, Konsol Manajemen AWS NoSQL Workbench,, dan DynamoDB untuk PartiQL. AWS Command Line Interface APIs Operasi PartiQL memberikan ketersediaan, latensi, dan performa yang sama seperti operasi bidang data DynamoDB lainnya. Bagian berikut menjelaskan implementasi DynamoDB PartiQL. **Topics** + [Apa yang dimaksud dengan PartiQL?](#ql-reference.what-is) + [PartiQL di Amazon DynamoDB](#ql-reference.what-is) + [Memulai](ql-gettingstarted.md) + [Jenis data](ql-reference.data-types.md) + [Pernyataan](ql-reference.statements.md) + [Fungsi](ql-functions.md) + [Operator](ql-operators.md) + [Transaksi](ql-reference.multiplestatements.transactions.md) + [Operasi batch](ql-reference.multiplestatements.batching.md) + [Kebijakan IAM](ql-iam.md) ## Apa yang dimaksud dengan PartiQL? *PartiQL* menyediakan akses kueri yang kompatibel dengan SQL di beberapa penyimpanan data yang berisi data terstruktur, data semi terstruktur, dan data bersarang. Ini banyak digunakan di Amazon dan sekarang tersedia sebagai bagian dari banyak AWS layanan, termasuk DynamoDB. Untuk spesifikasi PartiQL dan tutorial tentang bahasa kueri inti, lihat [Dokumentasi PartiQL](https://partiql.org/docs.html). **catatan** Amazon DynamoDB mendukung *subset* dari bahasa kueri [PartiQL](https://partiql.org/). Amazon DynamoDB tidak mendukung format data [Amazon ion](http://amzn.github.io/ion-docs/) atau literal Amazon Ion. ## PartiQL di Amazon DynamoDB Untuk menjalankan kueri PartiQL di DynamoDB, Anda dapat menggunakan: + Konsol DynamoDB + NoSQL Workbench + AWS Command Line Interface (AWS CLI) + DynamoDB APIs Untuk informasi tentang cara menggunakan metode ini guna mengakses DynamoDB, lihat [Mengakses DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). # Mulai menggunakan PartiQL untuk DynamoDB Bagian ini menjelaskan cara menggunakan PartiQL untuk DynamoDB dari konsol Amazon DynamoDB, (), dan DynamoDB. AWS Command Line Interface AWS CLI APIs Dalam contoh berikut, tabel DynamoDB yang ditentukan dalam tutorial [Mulai menggunakan DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) adalah prasyarat. [Untuk informasi tentang menggunakan konsol DynamoDB, AWS Command Line Interface, atau DynamoDB untuk mengakses DynamoDB, lihat Mengakses APIs DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html) Untuk [mengunduh](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) dan menggunakan [NoSQL workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) untuk membuat pernyataan [PartiQL untuk DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), pilih **operasi PartiQL** di sudut kanan atas [pembangun Operasi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html) NoSQL Workbench untuk DynamoDB. ------ #### [ Console ] ![\[Antarmuka editor PartiQL yang menunjukkan hasil menjalankan operasi Query pada tabel Musik.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png) 1. Masuk ke Konsol Manajemen AWS dan buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Di panel navigasi di sisi kiri konsol, pilih **editor PartiQL**. 1. Pilih tabel **Musik**. 1. Pilih **tabel Kueri**. Tindakan ini menghasilkan kueri yang tidak akan menghasilkan pemindaian tabel penuh. 1. Ganti `partitionKeyValue` dengan nilai string `Acme Band`. Ganti `sortKeyValue` dengan nilai string `Happy Day`. 1. Pilih tombol **Jalankan**. 1. Anda dapat melihat hasil kueri dengan memilih tombol **Tampilan tabel** atau **Tampilan JSON**. ------ #### [ NoSQL workbench ] ![\[Antarmuka meja kerja NoSQL. Ini menunjukkan pernyataan PartiQL SELECT yang dapat Anda jalankan di tabel Musik.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png) 1. Pilih **pernyataan PartiQL**. 1. Masukkan [pernyataan SELECT](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) PartiQL berikut ``` SELECT * FROM Music WHERE Artist=? and SongTitle=? ``` 1. Untuk menentukan nilai parameter `Artist` dan `SongTitle`: 1. Pilih **Parameter permintaan opsional**. 1. Pilih **Tambahkan parameter baru**. 1. Pilih jenis atribut **string** dan nilai `Acme Band`. 1. Ulangi langkah b dan c, lalu pilih jenis **string** dan nilai `PartiQL Rocks`. 1. Jika Anda ingin membuat kode, pilih **Buat kode**. Pilih bahasa yang Anda inginkan dari tab yang ditampilkan. Sekarang Anda dapat menyalin kode ini dan menggunakannya dalam aplikasi Anda. 1. Jika Anda ingin operasi segera dijalankan, pilih **Jalankan**. ------ #### [ AWS CLI ] 1. Buat item dalam tabel `Music` menggunakan pernyataan PartiQL INSERT. ``` aws dynamodb execute-statement --statement "INSERT INTO Music \ VALUE \ {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}" ``` 1. Ambil item dari tabel Musik menggunakan pernyataan PartiQL SELECT. ``` aws dynamodb execute-statement --statement "SELECT * FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Perbarui item dalam tabel `Music` menggunakan pernyataan PartiQL UPDATE. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardsWon=1 \ SET AwardDetail={'Grammys':[2020, 2018]} \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Tambahkan nilai daftar untuk item dalam tabel `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Hapus nilai daftar untuk item dalam tabel `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ REMOVE AwardDetail.Grammys[2] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Tambahkan anggota peta baru untuk item dalam tabel `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.BillBoard=[2020] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Tambahkan atribut set string baru untuk item dalam tabel `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =<<'member1', 'member2'>> \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Perbarui atribut set string untuk item dalam tabel `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =set_add(BandMembers, <<'newmember'>>) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Hapus item dari tabel `Music` menggunakan pernyataan PartiQL DELETE. ``` aws dynamodb execute-statement --statement "DELETE FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` ------ #### [ Java ] ``` import java.util.ArrayList; import java.util.List; import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import software.amazon.dynamodb.AmazonDynamoDB; import software.amazon.dynamodb.AmazonDynamoDBClientBuilder; import software.amazon.dynamodb.model.AttributeValue; import software.amazon.dynamodb.model.ConditionalCheckFailedException; import software.amazon.dynamodb.model.ExecuteStatementRequest; import software.amazon.dynamodb.model.ExecuteStatementResult; import software.amazon.dynamodb.model.InternalServerErrorException; import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException; import software.amazon.dynamodb.model.ProvisionedThroughputExceededException; import software.amazon.dynamodb.model.RequestLimitExceededException; import software.amazon.dynamodb.model.ResourceNotFoundException; import software.amazon.dynamodb.model.TransactionConflictException; public class DynamoDBPartiQGettingStarted { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1"); try { // Create ExecuteStatementRequest ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest(); List parameters= getPartiQLParameters(); //Create an item in the Music table using the INSERT PartiQL statement processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //Update an item in the Music table using the UPDATE PartiQL statement. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters)); //Add a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters)); //Remove a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters)); //Add a new map member for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters)); //Add a new string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters)); //update a string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //delete an item from the Music Table processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters)); } catch (Exception e) { handleExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static List getPartiQLParameters() { List parameters = new ArrayList(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); return parameters; } private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) { ExecuteStatementRequest request = new ExecuteStatementRequest(); request.setStatement(statement); request.setParameters(parameters); return client.executeStatement(request); } private static void processResults(ExecuteStatementResult executeStatementResult) { System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString()); } // Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteStatementErrors(Exception exception) { try { throw exception; } catch (ConditionalCheckFailedException ccfe) { System.out.println("Condition check specified in the operation failed, review and update the condition " + "check before retrying. Error: " + ccfe.getErrorMessage()); } catch (TransactionConflictException tce) { System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " + "safe to retry with exponential back-off. Error: " + tce.getErrorMessage()); } catch (ItemCollectionSizeLimitExceededException icslee) { System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " + "size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ ## Menggunakan pernyataan berparameter Alih-alih menyematkan nilai secara langsung dalam string pernyataan PartiQL, Anda dapat menggunakan placeholder tanda tanya `?` () dan memberikan nilai secara terpisah di bidang. `Parameters` Masing-masing `?` diganti dengan nilai parameter yang sesuai, sesuai urutan yang disediakan. Menggunakan pernyataan berparameter adalah praktik terbaik karena memisahkan struktur pernyataan dari nilai data, membuat pernyataan lebih mudah dibaca dan digunakan kembali. Ini juga menghindari kebutuhan untuk secara manual memformat dan melarikan diri nilai atribut dalam string pernyataan. Pernyataan parameter didukung dalam`ExecuteStatement`,`BatchExecuteStatement`, dan `ExecuteTransaction` operasi. Contoh berikut mengambil item dari `Music` tabel menggunakan nilai parameter untuk kunci partisi dan kunci sortir. ------ #### [ AWS CLI parameterized ] ``` aws dynamodb execute-statement \ --statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \ --parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]' ``` ------ #### [ Java parameterized ] ``` List parameters = new ArrayList<>(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); ExecuteStatementRequest request = new ExecuteStatementRequest() .withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?") .withParameters(parameters); ExecuteStatementResult result = dynamoDB.executeStatement(request); ``` ------ #### [ Python parameterized ] ``` response = dynamodb_client.execute_statement( Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?", Parameters=[ {'S': 'Acme Band'}, {'S': 'PartiQL Rocks'} ] ) ``` ------ **catatan** Contoh Java di bagian memulai sebelumnya menggunakan pernyataan berparameter di seluruh. `getPartiQLParameters()`Metode ini membangun daftar parameter, dan setiap pernyataan menggunakan `?` placeholder alih-alih nilai inline. # Jenis data PartiQL untuk DynamoDB Tabel berikut mencantumkan jenis data yang dapat Anda gunakan dengan PartiQL untuk DynamoDB. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/ql-reference.data-types.html) ## Contoh Pernyataan berikut menunjukkan cara memasukkan jenis data berikut: `String`, `Number`, `Map`, `List`, `Number Set`, dan `String Set`. ``` INSERT INTO TypesTable value {'primarykey':'1', 'NumberType':1, 'MapType' : {'entryname1': 'value', 'entryname2': 4}, 'ListType': [1,'stringval'], 'NumberSetType':<<1,34,32,4.5>>, 'StringSetType':<<'stringval','stringval2'>> } ``` Pernyataan berikut menunjukkan cara menyisipkan elemen baru ke dalam jenis `Map`, `List`, `Number Set`, and `String Set` serta mengubah nilai jenis `Number`. ``` UPDATE TypesTable SET NumberType=NumberType + 100 SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4] SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>]) SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>) SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>) WHERE primarykey='1' ``` Pernyataan berikut menunjukkan cara menghapus elemen dari jenis `Map`, `List`, `Number Set`, and `String Set` serta mengubah nilai jenis `Number`. ``` UPDATE TypesTable SET NumberType=NumberType - 1 REMOVE ListType[1] REMOVE MapType.NewMapEntry SET NumberSetType = SET_DELETE( NumberSetType, <<345>>) SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>) WHERE primarykey='1' ``` Untuk informasi selengkapnya, lihat [jenis data DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). # Pernyataan PartiQL untuk DynamoDB Amazon DynamoDB mendukung pernyataan PartiQL berikut. **catatan** DynamoDB tidak mendukung semua pernyataan PartiQL. Referensi ini memberikan sintaks dasar dan contoh penggunaan pernyataan PartiQL yang Anda jalankan secara manual menggunakan or. AWS CLI APIs *Bahasa manipulasi data* (DML) adalah kumpulan pernyataan PartiQL yang Anda gunakan untuk mengelola data dalam tabel DynamoDB. Anda menggunakan pernyataan DML untuk menambah, mengubah, atau menghapus data dalam sebuah tabel. Berikut DML dan kueri bahasa pernyataan yang didukung: + [Pernyataan pemilihan PartiQL untuk DynamoDB](ql-reference.select.md) + [Pernyataan pembaruan PartiQL untuk DynamoDB](ql-reference.update.md) + [Pernyataan sisipkan PartiQL untuk DynamoDB](ql-reference.insert.md) + [Pernyataan hapus PartiQL untuk DynamoDB](ql-reference.delete.md) [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) and [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md) juga didukung oleh PartiQL untuk DynamoDB. # Pernyataan pemilihan PartiQL untuk DynamoDB Gunakan pernyataan `SELECT` untuk mengambil data dari tabel di Amazon DynamoDB. Menggunakan `SELECT` pernyataan dapat menghasilkan pemindaian tabel lengkap jika kondisi kesetaraan atau IN dengan kunci partisi tidak disediakan dalam klausa WHERE. Operasi pemindaian memeriksa setiap item untuk nilai yang diminta dan dapat menggunakan throughput yang disediakan untuk indeks atau tabel besar dalam satu operasi. Jika ingin menghindari pemindaian tabel secara lengkap di PartiQL, Anda dapat: + Menulis pernyataan `SELECT` Anda agar tidak memindai tabel secara lengkap dengan memastikan [ketentuan klausul WHERE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) Anda dikonfigurasi dengan semestinya. + Menonaktifkan pemindaian tabel lengkap menggunakan kebijakan IAM yang ditentukan di [Contoh: Mengizinkan pernyataan pilihan dan menolak pernyataan pemindaian tabel lengkap di PartiQL untuk DynamoDB](ql-iam.md#access-policy-ql-iam-example6), dalam panduan developer DynamoDB. Untuk informasi selengkapnya, lihat [Praktik terbaik untuk Mengkueri dan memindai data](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html), dalam panduan developer DynamoDB. **Topics** + [Sintaks](#ql-reference.select.syntax) + [Parameter](#ql-reference.select.parameters) + [Contoh](#ql-reference.select.examples) ## Sintaks ``` SELECT expression [, ...] FROM table[.index] [ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...] ``` ## Parameter ***expression*** (Diperlukan) Proyeksi yang terbentuk dari wildcard `*` atau daftar proyeksi dari satu nama atribut atau lebih atau jalur dokumen dari set hasil. Ekspresi dapat terdiri dari panggilan ke [Gunakan fungsi PartiQL dengan DynamoDB](ql-functions.md) atau bidang yang diubah oleh [Aritmatika PartiQL, perbandingan, dan operator logika untuk DynamoDB](ql-operators.md). ***table*** (Diperlukan) Nama tabel untuk kueri. ***index*** (Opsional) Nama indeks untuk kueri. Anda harus menambahkan tanda kutip ganda ke nama tabel dan nama indeks saat mengkueri indeks. ``` SELECT * FROM "TableName"."IndexName" ``` ***condition*** (Opsional) Kriteria seleksi untuk kueri. Untuk memastikan bahwa pernyataan `SELECT` tidak menghasilkan pemindaian tabel secara lengkap, kondisi klausul `WHERE` harus menentukan kunci partisi. Gunakan kesetaraan atau operator IN. Misalnya, jika Anda memiliki tabel `Orders` dengan kunci partisi `OrderID` dan atribut non-kunci lainnya, termasuk `Address`, pernyataan berikut tidak akan menghasilkan pemindaian tabel secara lengkap: ``` SELECT * FROM "Orders" WHERE OrderID = 100 SELECT * FROM "Orders" WHERE OrderID = 100 and Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 or OrderID = 200 SELECT * FROM "Orders" WHERE OrderID IN [100, 300, 234] ``` Namun, pernyataan `SELECT` berikut akan menghasilkan pemindaian tabel secara lengkap: ``` SELECT * FROM "Orders" WHERE OrderID > 1 SELECT * FROM "Orders" WHERE Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 OR Address='some address' ``` ***key*** (Opsional) Kunci hash atau kunci urutan untuk digunakan dalam mengurutkan hasil yang dikembalikan. Urutan defaultnya adalah naik (`ASC`) tentukan `DESC` jika Anda ingin hasil dikembalikan dalam urutan turun. **catatan** Jika Anda menghapus klausul `WHERE`, semua item dalam tabel akan diambil. ## Contoh Kueri berikut mengembalikan satu item, jika ada, dari tabel `Orders` dengan menentukan kunci partisi, `OrderID`, dan menggunakan operator kesetaraan. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 ``` Kueri berikut mengembalikan semua item dalam tabel `Orders` yang memiliki kunci partisi spesifik, `OrderID`, nilai menggunakan operator OR. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 OR OrderID = 2 ``` Kueri berikut mengembalikan semua item dalam tabel `Orders` yang memiliki kunci partisi spesifik, `OrderID`, nilai menggunakan operator IN. Hasil yang dikembalikan dalam urutan turun, berdasarkan nilai atribut kunci `OrderID`. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC ``` Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` yang memiliki `Total` lebih dari 500, dengan `Total` adalah atribut non-kunci. ``` SELECT OrderID, Total FROM "Orders" WHERE Total > 500 ``` Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` di dalam rentang urutan `Total` tertentu, menggunakan operator IN dan atribut non-kunci `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total IN [500, 600] ``` Kueri berikut menunjukkan pemindaian tabel secara lengkap yang mengembalikan semua item dari tabel `Orders` di dalam rentang urutan `Total` tertentu, menggunakan operator BETWEEN dan atribut non-kunci `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total BETWEEN 500 AND 600 ``` Kueri berikut mengembalikan tanggal pertama perangkat firestick digunakan untuk menonton dengan menentukan kunci partisi `CustomerID` dan kunci urutan `MovieID` dalam kondisi klausul WHERE dan menggunakan jalur dokumen dalam klausul SELECT. ``` SELECT Devices.FireStick.DateWatched[0] FROM WatchList WHERE CustomerID= 'C1' AND MovieID= 'M1' ``` Kueri berikut menunjukkan pemindaian tabel secara penuh yang mengembalikan daftar item tempat perangkat firestick pertama kali digunakan setelah 24/12/19 menggunakan jalur dokumen dalam kondisi klausul WHERE. ``` SELECT Devices FROM WatchList WHERE Devices.FireStick.DateWatched[0] >= '12/24/19' ``` # Pernyataan pembaruan PartiQL untuk DynamoDB Gunakan pernyataan `UPDATE` untuk mengubah nilai dari satu atribut atau lebih dalam item dalam tabel Amazon DynamoDB. **catatan** Anda hanya dapat memperbarui satu item pada satu waktu; Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang memperbarui beberapa item. Untuk informasi tentang memperbarui beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaks](#ql-reference.update.syntax) + [Parameter](#ql-reference.update.parameters) + [Nilai yang dikembalikan](#ql-reference.update.return) + [Contoh](#ql-reference.update.examples) ## Sintaks ``` UPDATE table [SET | REMOVE] path [= data] […] WHERE condition [RETURNING returnvalues] ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] * ``` ## Parameter ***table*** (Diperlukan) Tabel yang berisi data yang akan diubah. ***path*** (Diperlukan) Nama atribut atau jalur dokumen yang akan dibuat atau diubah. ***data*** (Diperlukan) Nilai atribut atau hasil operasi. Operasi yang didukung untuk digunakan bersama SET: + LIST\$1APPEND: menambahkan nilai ke jenis daftar. + SET\$1ADD: menambahkan nilai ke set angka atau string. + SET\$1DELETE: menghapus nilai dari set angka atau string. ***condition*** (Diperlukan) Kriteria pemilihan untuk item yang akan diubah. Syarat ini harus diselesaikan untuk satu nilai kunci primer. ***returnvalues*** (Opsional) Gunakan `returnvalues` jika Anda ingin mendapatkan atribut item seperti yang muncul sebelum atau setelah diperbarui. Nilai yang valid adalah: + `ALL OLD *`- Mengembalikan semua atribut item, saat atribut item tersebut muncul sebelum operasi pembaruan. + `MODIFIED OLD *`- Mengembalikan hanya atribut yang diperbarui, saat atribut item tersebut muncul sebelum operasi pembaruan. + `ALL NEW *`- Mengembalikan semua atribut item, seperti yang muncul setelah operasi pembaruan. + `MODIFIED NEW *`- Hanya mengembalikan atribut yang diperbarui, seperti yang muncul setelah operasi `UpdateItem`. ## Nilai yang dikembalikan Pernyataan ini tidak mengembalikan nilai kecuali parameter `returnvalues` ditentukan. **catatan** Jika klausul WHERE pernyataan UPDATE tidak dinilai true untuk item apa pun dalam tabel DynamoDB, `ConditionalCheckFailedException` akan dikembalikan. ## Contoh Memperbarui nilai atribut dalam item yang sudah ada. Jika atribut tersebut tidak ada, atribut tersebut akan dibuat. Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan atribut dari nomor jenis (`AwardsWon`) dan atribut dari jenis peta (`AwardDetail`). ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Anda dapat menambahkan `RETURNING ALL OLD *` untuk mengembalikan atribut seperti yang muncul sebelum operasi `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL OLD * ``` Ini akan menghasilkan hal berikut: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` Anda dapat menambahkan `RETURNING ALL NEW *` untuk mengembalikan atribut seperti yang muncul setelah operasi `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL NEW * ``` Ini akan menghasilkan hal berikut: ``` { "Items": [ { "AwardDetail": { "M": { "Grammys": { "L": [ { "N": "2020" }, { "N": "2018" } ] } } }, "AwardsWon": { "N": "1" } } ] } ``` Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan ke daftar `AwardDetail.Grammys`. ``` UPDATE "Music" SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Kueri berikut memperbarui item dalam tabel `"Music"` dengan menghapus dari daftar `AwardDetail.Grammys`. ``` UPDATE "Music" REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan `BillBoard` ke peta `AwardDetail`. ``` UPDATE "Music" SET AwardDetail.BillBoard=[2020] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan atribut set string `BandMembers`. ``` UPDATE "Music" SET BandMembers =<<'member1', 'member2'>> WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Kueri berikut memperbarui item dalam tabel `"Music"` dengan menambahkan `newbandmember` ke set string `BandMembers`. ``` UPDATE "Music" SET BandMembers =set_add(BandMembers, <<'newbandmember'>>) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` # Pernyataan hapus PartiQL untuk DynamoDB Gunakan pernyataan `DELETE` untuk menghapus item yang sudah ada dari tabel Amazon DynamoDB Anda. **catatan** Anda hanya dapat menghapus satu item dalam satu waktu. Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang menghapus beberapa item. Untuk informasi tentang menghapus beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaks](#ql-reference.delete.syntax) + [Parameter](#ql-reference.delete.parameters) + [Nilai yang dikembalikan](#ql-reference.delete.return) + [Contoh](#ql-reference.delete.examples) ## Sintaks ``` DELETE FROM table WHERE condition [RETURNING returnvalues] ::= ALL OLD * ``` ## Parameter ***table*** (Diperlukan) Tabel DynamoDB yang berisi item yang akan dihapus. ***condition*** (Diperlukan) Kriteria seleksi untuk item yang akan dihapus; syarat ini harus diselesaikan untuk nilai kunci primer tunggal. ***returnvalues*** (Opsional) Gunakan `returnvalues` jika Anda ingin mendapatkan atribut item seperti yang muncul sebelum atribut item tersebut dihapus. Nilai yang valid adalah: + `ALL OLD *`- Konten dari item lama akan dikembalikan. ## Nilai yang dikembalikan Pernyataan ini tidak mengembalikan nilai kecuali parameter `returnvalues` ditentukan. **catatan** Jika tabel DynamoDB tidak memiliki item dengan kunci primer yang sama seperti yang item yang DELETE-nya dikeluarkan, SUCCESS dikembalikan dengan 0 item dihapus. Jika tabel memiliki item dengan kunci primer yang sama, tetapi syarat dalam klausul WHERE pernyataan dari DELETE bernilai false, `ConditionalCheckFailedException` akan dikembalikan. ## Contoh Kueri berikut akan menghapus item dalam tabel `"Music"`. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' ``` Anda dapat menambahkan parameter `RETURNING ALL OLD *` untuk mengembalikan data yang telah dihapus. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * ``` Pernyataan `Delete` sekarang mengembalikan yang berikut: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` # Pernyataan sisipkan PartiQL untuk DynamoDB Gunakan pernyataan `INSERT` untuk menambahkan item ke tabel di Amazon DynamoDB. **catatan** Anda hanya dapat menyisipkan satu item pada satu waktu; Anda tidak dapat mengeluarkan pernyataan DynamoDB PartiQL tunggal yang menyisipkan beberapa item. Untuk informasi tentang cara menyisipkan beberapa item, lihat [Melakukan transaksi dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.transactions.md) atau [Menjalankan operasi batch dengan PartiQL untuk DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaksis](#ql-reference.insert.syntax) + [Parameter](#ql-reference.insert.parameters) + [Nilai yang dikembalikan](#ql-reference.insert.return) + [Contoh](#ql-reference.insert.examples) ## Sintaksis Sisipkan satu item. ``` INSERT INTO table VALUE item ``` ## Parameter ***table*** (Diperlukan) Tabel tempat Anda ingin menyisipkan data. Tabel harus sudah ada. ***item*** (Diperlukan) Item DynamoDB yang valid diwakili sebagai [tupel PartiQL](https://partiql.org/docs.html). Anda harus menentukan hanya *satu* item dan setiap nama atribut dalam item adalah peka huruf besar-kecil dan dapat dilambangkan dengan tanda petik *tunggal* (`'...'`) di PartiQL. Nilai string juga dilambangkan dengan tanda petik *tunggal* (`'...'`) di PartiQL. ## Nilai yang dikembalikan Pernyataan ini tidak mengembalikan nilai apa pun. **catatan** Jika tabel DynamoDB sudah memiliki item dengan kunci primer yang sama sebagai kunci primer dari item yang sedang disisipkan, `DuplicateItemException` dikembalikan. ## Contoh ``` INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} ``` # Gunakan fungsi PartiQL dengan DynamoDB PartiQL di Amazon DynamoDB mendukung varian bawaan fungsi standar SQL berikut. **catatan** Fungsi SQL apa pun yang tidak termasuk dalam daftar ini saat ini tidak didukung di DynamoDB. ## Fungsi agregat + [Menggunakan Fungsi SIZE dengan PartiQL untuk Amazon DynamoDB](ql-functions.size.md) ## Fungsi kondisional + [Menggunakan fungsi EXISTS dengan PartiQL untuk DynamoDB](ql-functions.exists.md) + [Menggunakan Fungsi ATTRIBUTE\$1TYPE dengan PartiQL untuk DynamoDB](ql-functions.attribute_type.md) + [Menggunakan Fungsi BEGINS\$1WITH dengan PartiQL untuk DynamoDB](ql-functions.beginswith.md) + [Menggunakan fungsi COUNTAINS dengan PartiQL untuk DynamoDB](ql-functions.contains.md) + [Menggunakan fungsi MISSING dengan PartiQL untuk DynamoDB](ql-functions.missing.md) # Menggunakan fungsi EXISTS dengan PartiQL untuk DynamoDB Anda dapat menggunakan EXISTS untuk melakukan fungsi yang sama seperti `ConditionCheck` di [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API. Fungsi EXISTS hanya dapat digunakan dalam transaksi. Dengan nilai, mengembalikan `TRUE` jika nilai adalah kumpulan yang tidak kosong. Jika tidak, mengembalikan `FALSE`. **catatan** Fungsi ini hanya dapat digunakan dalam operasi transaksional. ## Sintaks ``` EXISTS ( statement ) ``` ## Pendapat *statement* (Diperlukan) Pernyataan SELECT yang dievaluasi oleh fungsi. Pernyataan SELECT harus menentukan kunci primer lengkap dan satu kondisi lainnya. ## Jenis pengembalian `bool` ## Contoh ``` EXISTS( SELECT * FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks') ``` # Menggunakan Fungsi BEGINS\$1WITH dengan PartiQL untuk DynamoDB Mengembalikan `TRUE` jika atribut yang ditentukan dimulai dengan substring tertentu. ## Sintaks ``` begins_with(path, value ) ``` ## Pendapat *path* (Diperlukan) Nama atribut atau jalur dokumen yang akan digunakan. *value* (Diperlukan) String untuk mencari. ## Jenis pengembalian `bool` ## Contoh ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th') ``` # Menggunakan fungsi MISSING dengan PartiQL untuk DynamoDB Mengembalikan `TRUE` jika item tidak berisi atribut yang ditentukan. Hanya operator kesetaraan dan ketidaksetaraan yang dapat digunakan dengan fungsi ini. ## Sintaks ``` attributename IS | IS NOT MISSING ``` ## Pendapat *attributename* (Diperlukan) Nama atribut yang akan dicari. ## Jenis pengembalian `bool` ## Contoh ``` SELECT * FROM Music WHERE "Awards" is MISSING ``` # Menggunakan Fungsi ATTRIBUTE\$1TYPE dengan PartiQL untuk DynamoDB Mengembalikan `TRUE` jika atribut pada jalur yang ditentukan adalah jenis data tertentu. ## Sintaks ``` attribute_type( attributename, type ) ``` ## Pendapat *attributename* (Diperlukan) Nama atribut yang digunakan. *type* (Wajib) Jenis atribut yang akan diperiksa. Untuk daftar nilai yang valid, lihat [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Jenis pengembalian `bool` ## Contoh ``` SELECT * FROM "Music" WHERE attribute_type("Artist", 'S') ``` # Menggunakan fungsi COUNTAINS dengan PartiQL untuk DynamoDB Mengembalikan `TRUE` jika atribut yang ditentukan oleh jalur tersebut adalah salah satu dari hal berikut: + String yang berisi substring tertentu. + Set yang berisi elemen tertentu dalam set. Untuk informasi selengkapnya, lihat fungsi [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Sintaks ``` contains( path, substring ) ``` ## Pendapat *path* (Diperlukan) Nama atribut atau jalur dokumen yang akan digunakan. *substring* (Diperlukan) Substring atribut atau anggota yang ditetapkan yang akan diperiksa. Untuk informasi selengkapnya, lihat fungsi [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Jenis pengembalian `bool` ## Contoh ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland') ``` # Menggunakan Fungsi SIZE dengan PartiQL untuk Amazon DynamoDB Mengembalikan angka yang mewakili ukuran atribut dalam byte. Berikut ini adalah jenis daya yang valid untuk digunakan dengan size. Untuk informasi selengkapnya, lihat fungsi [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Sintaks ``` size( path) ``` ## Pendapat *path* (Diperlukan) Nama atribut atau jalur dokumen. Untuk jenis yang didukung, lihat fungsi [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Jenis pengembalian `int` ## Contoh ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300 ``` # Aritmatika PartiQL, perbandingan, dan operator logika untuk DynamoDB PartiQL di Amazon DynamoDB mendukung [Operator standar SQL](https://www.w3schools.com/sql/sql_operators.asp) berikut. **catatan** Operator SQL apa pun yang tidak termasuk dalam daftar ini saat ini tidak didukung di DynamoDB. ## Operator aritmatika **** | Operator | Deskripsi | | --- | --- | | \$1 | Tambahkan | | - | Kurangi | ## Operator perbandingan **** | Operator | Deskripsi | | --- | --- | | = | Sama dengan | | <> | Tidak Sama dengan | | \$1= | Tidak Sama dengan | | > | Lebih besar dari | | < | Kurang dari | | >= | Lebih besar dari atau sama dengan | | <= | Kurang dari atau sama dengan | ## Operator logis **** | Operator | Deskripsi | | --- | --- | | AND | TRUE jika semua kondisi yang dipisahkan oleh AND adalah TRUE | | BETWEEN | `TRUE`jika operan berada dalam kisaran perbandingan. Operator ini termasuk batas bawah dan atas operan tempat Anda menerapkannya. | | IN | `TRUE`jika operan sama dengan salah satu daftar ekspresi (maksimal 50 nilai atribut hash atau maksimal 100 nilai atribut non-kunci). Hasil dikembalikan dalam halaman hingga 10 item. Jika `IN` daftar berisi lebih banyak nilai, Anda harus menggunakan yang `NextToken` dikembalikan dalam respons untuk mengambil halaman berikutnya. | | IS | TRUE jika operannya adalah jenis data PartiQL tertentu, termasuk NULL atau MISSING | | NOT | Membalikkan nilai ekspresi Boolean yang diberikan | | OR | TRUE jika semua kondisi yang dipisahkan oleh OR adalah TRUE | Untuk informasi selengkapnya tentang menggunakan operator logika, lihat [Membuat perbandingan](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) dan[Evaluasi logika](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations). # Melakukan transaksi dengan PartiQL untuk DynamoDB Bagian ini menjelaskan cara menggunakan transaksi dengan PartiQL untuk DynamoDB. Transaksi PartiQL dibatasi hingga 100 total pernyataan (tindakan). Untuk informasi lebih lanjut tentang transaksi DynamoDB, lihat [Mengelola alur kerja kompleks dengan transaksi DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **catatan** Seluruh transaksi harus terdiri dari pernyataan baca atau pernyataan tulis. Anda tidak dapat menggabungkan keduanya dalam satu transaksi. Fungsi EXISTS merupakan pengecualian. Anda dapat menggunakannya untuk memeriksa kondisi atribut tertentu dari item dengan cara yang mirip `ConditionCheck` dengan operasi [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API. **Topics** + [Sintaks](#ql-reference.multiplestatements.transactions.syntax) + [Parameter](#ql-reference.multiplestatements.transactions.parameters) + [Nilai yang dikembalikan](#ql-reference.multiplestatements.transactions.return) + [Contoh](#ql-reference.multiplestatements.transactions.examples) ## Sintaks ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameter ***statement*** (Diperlukan) Pernyataan yang didukung PartiQL untuk DynamoDB. Seluruh transaksi harus terdiri dari pernyataan baca atau pernyataan tulis. Anda tidak dapat menggabungkan keduanya dalam satu transaksi. ***parametertype*** (Opsional) Jenis DynamoDB, jika parameter digunakan saat menentukan pernyataan PartiQL. ***parametervalue*** (Opsional) Nilai parameter jika parameter digunakan saat menentukan pernyataan PartiQL. ## Nilai yang dikembalikan Pernyataan ini tidak mengembalikan nilai apa pun untuk operasi Tulis (INSERT, UPDATE, atau DELETE). Namun, ia mengembalikan nilai yang berbeda untuk operasi Baca (SELECT) berdasarkan kondisi yang ditentukan dalam klausul WHERE. **catatan** Jika salah satu operasi INSERT, UPDATE, atau DELETE singleton mengembalikan kesalahan, transaksi dibatalkan dengan pengecualian `TransactionCanceledException`, dan kode alasan pembatalan termasuk kesalahan dari operasi singleton individual. ## Contoh Contoh berikut menjalankan beberapa pernyataan sebagai sebuah transaksi. ------ #### [ AWS CLI ] 1. Simpan kode JSON berikut ke file bernama partiql.json. ``` [ { "Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)" }, { "Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}", "Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}] }, { "Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'" } ] ``` 1. Jalankan perintah berikut di prompt perintah. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlTransaction { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create ExecuteTransactionRequest ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest(); ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest); System.out.println("ExecuteTransaction successful."); // Handle executeTransactionResult } catch (Exception e) { handleExecuteTransactionErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static ExecuteTransactionRequest createExecuteTransactionRequest() { ExecuteTransactionRequest request = new ExecuteTransactionRequest(); // Create statements List statements = getPartiQLTransactionStatements(); request.setTransactStatements(statements); return request; } private static List getPartiQLTransactionStatements() { List statements = new ArrayList(); statements.add(new ParameterizedStatement() .withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)")); statements.add(new ParameterizedStatement() .withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}") .withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song"))); statements.add(new ParameterizedStatement() .withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteTransactionErrors(Exception exception) { try { throw exception; } catch (TransactionCanceledException tce) { System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage()); } catch (TransactionInProgressException tipe) { System.out.println("The transaction with the given request token is already in progress, consider changing " + "retry strategy for this type of error. Error: " + tipe.getErrorMessage()); } catch (IdempotentParameterMismatchException ipme) { System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " + "change request token for this payload to be accepted. Error: " + ipme.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ Contoh berikut menunjukkan nilai pengembalian yang berbeda ketika DynamoDB membaca item dengan kondisi berbeda yang ditentukan dalam klausul WHERE. ------ #### [ AWS CLI ] 1. Simpan kode JSON berikut ke file bernama partiql.json. ``` [ // Item exists and projected attribute exists { "Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item exists but projected attributes do not exist { "Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item does not exist { "Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'" } ] ``` 1. perintah berikut di prompt perintah. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` 1. Respons berikut dikembalikan: ``` { "Responses": [ // Item exists and projected attribute exists { "Item": { "Artist":{ "S": "No One You Know" }, "SongTitle":{ "S": "Call Me Today" } } }, // Item exists but projected attributes do not exist { "Item": {} }, // Item does not exist {} ] } ``` ------ # Menjalankan operasi batch dengan PartiQL untuk DynamoDB Bagian ini menjelaskan cara menggunakan pernyataan batch dengan PartiQL untuk DynamoDB. **catatan** Keseluruhan batch harus terdiri dari pernyataan baca atau pernyataan tulis; Anda tidak dapat mencampur keduanya dalam satu batch. `BatchExecuteStatement` dan `BatchWriteItem` dapat melakukan tidak lebih dari 25 pernyataan per batch. `BatchExecuteStatement`memanfaatkan `BatchGetItem` yang mengambil daftar kunci utama dalam pernyataan terpisah. **Topics** + [Sintaks](#ql-reference.multiplestatements.batching.syntax) + [Parameter](#ql-reference.multiplestatements.batching.parameters) + [Contoh](#ql-reference.multiplestatements.batching.examples) ## Sintaks ``` [ { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'" }, { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'" } ] ``` ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameter ***statement*** (Diperlukan) Pernyataan yang didukung PartiQL untuk DynamoDB. + Keseluruhan batch harus terdiri dari pernyataan baca atau pernyataan tulis; Anda tidak dapat mencampur keduanya dalam satu batch. + `BatchExecuteStatement` dan `BatchWriteItem` dapat melakukan tidak lebih dari 25 pernyataan per batch. ***parametertype*** (Opsional) Jenis DynamoDB, jika parameter digunakan saat menentukan pernyataan PartiQL. ***parametervalue*** (Opsional) Nilai parameter jika parameter digunakan saat menentukan pernyataan PartiQL. ## Contoh ------ #### [ AWS CLI ] 1. Simpan json berikut ke file bernama partiql.json ``` [ { "Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}", "Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}] }, { "Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" } ] ``` 1. Jalankan perintah berikut di prompt perintah. ``` aws dynamodb batch-execute-statement --statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlBatch { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create BatchExecuteStatementRequest BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest(); BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest); System.out.println("BatchExecuteStatement successful."); // Handle batchExecuteStatementResult } catch (Exception e) { handleBatchExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() { BatchExecuteStatementRequest request = new BatchExecuteStatementRequest(); // Create statements List statements = getPartiQLBatchStatements(); request.setStatements(statements); return request; } private static List getPartiQLBatchStatements() { List statements = new ArrayList(); statements.add(new BatchStatementRequest() .withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}")); statements.add(new BatchStatementRequest() .withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleBatchExecuteStatementErrors(Exception exception) { try { throw exception; } catch (Exception e) { // There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ # Kebijakan keamanan IAM dengan PartiQL untuk DynamoDB Izin berikut diperlukan: + Untuk membaca item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLSelect` pada tabel atau indeks. + Untuk menyisipkan item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLInsert` pada tabel atau indeks. + Untuk memperbarui item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLUpdate` pada tabel atau indeks. + Untuk menghapus item menggunakan PartiQL untuk DynamoDB, Anda harus memiliki izin `dynamodb:PartiQLDelete` pada tabel atau indeks. ## Contoh: Izinkan semua PartiQL untuk pernyataan DynamoDB () di atas meja Select/Insert/Update/Delete Kebijakan IAM berikut memberikan izin untuk menjalankan semua pernyataan PartiQL untuk DynamoDB pada tabel. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Contoh: Mengizinkan pernyataan pilih PartiQL untuk DynamoDB pada tabel Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `select` pada tabel tertentu. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Contoh: Mengizinkan PartiQL untuk pernyataan penyisipan DynamoDB pada indeks Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `insert` pada indeks tertentu. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1" ] } ] } ``` ------ ## Contoh: Mengizinkan PartiQL untuk pernyataan transaksional DynamoDB hanya pada tabel Kebijakan IAM berikut memberikan izin untuk hanya menjalankan pernyataan transaksional pada tabel tertentu. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } } ] } ``` ------ ## Contoh: Mengizinkan PartiQL untuk pembacaan dan penulisan non-transaksional DynamoDB dan memblokir pernyataan transaksional pembacaan dan penulisan transaksional PartiQL pada tabel. Kebijakan IAM berikut memberikan izin untuk menjalankan PartiQL untuk pembacaan dan penulisan non-transaksional DynamoDB sambil memblokir PartiQL untuk pembacaan dan penulisan transaksional DynamoDB. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Contoh: Mengizinkan pernyataan pilihan dan menolak pernyataan pemindaian tabel lengkap di PartiQL untuk DynamoDB Kebijakan IAM berikut memberikan izin untuk menjalankan pernyataan `select` pada tabel tertentu sambil memblokir pernyataan `select` yang menghasilkan pemindaian tabel penuh. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ], "Condition":{ "Bool":{ "dynamodb:FullTableScan":[ "true" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ] } ] } ``` ------