Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Driver Amazon QLDB untuk Go **penting** Pemberitahuan akhir dukungan: Pelanggan yang ada akan dapat menggunakan Amazon QLDB hingga akhir dukungan pada 07/31/2025. Untuk detail selengkapnya, lihat [Memigrasi Buku Besar QLDB Amazon ke Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL. Untuk bekerja dengan data dalam buku besar Anda, Anda dapat terhubung ke Amazon QLDB dari aplikasi Go Anda dengan menggunakan driver yang disediakan. AWS Topik berikut menjelaskan cara memulai dengan driver QLDB untuk Go. **Topics** + [ ## Sumber daya pengemudi ](#getting-started.golang.resources) + [ ## Prasyarat ](#getting-started.golang.prereqs) + [ ## Penginstalan ](#getting-started.golang.install) + [Tutorial mulai cepat](driver-quickstart-golang.md) + [Referensi buku masak](driver-cookbook-golang.md) ## Sumber daya pengemudi Untuk informasi selengkapnya tentang fungsionalitas yang didukung oleh driver Go, lihat sumber daya berikut: + [Referensi API: [3.x, 2.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver)[, 1.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver)](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/qldbdriver) + [Kode sumber driver (GitHub)](https://github.com/awslabs/amazon-qldb-driver-go) + [Buku Masak Amazon Ion](http://amzn.github.io/ion-docs/guides/cookbook.html) ## Prasyarat Sebelum Anda memulai dengan driver QLDB untuk Go, Anda harus melakukan hal berikut: 1. Ikuti petunjuk AWS penyiapan di[Mengakses Amazon QLDB](accessing.md). Ini termasuk yang berikut: 1. Mendaftar untuk AWS. 1. Buat pengguna dengan izin QLDB yang sesuai. 1. Memberikan akses terprogram untuk pengembangan. 1. (Opsional) Instal lingkungan pengembangan terintegrasi (IDE) pilihan Anda. Untuk daftar yang umum digunakan IDEs untuk Go, lihat [Plugin editor dan IDEs](https://golang.org/doc/editors.html) di situs web Go. 1. Unduh dan instal salah satu versi Go berikut dari situs [unduhan Go](https://golang.org/dl/): + **1.15 atau yang lebih baru** - driver QLDB untuk Go v3 + **1.14** - Driver QLDB untuk Go v1 atau v2 1. Konfigurasikan lingkungan pengembangan Anda untuk [AWS SDK untuk Go](https://aws.amazon.com/sdk-for-go): 1. Siapkan AWS kredensyal Anda. Sebaiknya buat file kredensyal bersama. *Untuk petunjuknya, lihat [Menentukan Kredensyal di Panduan](https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/#specifying-credentials) Pengembang.AWS SDK untuk Go * 1. Tetapkan default Anda Wilayah AWS. Untuk mempelajari caranya, lihat [Menentukan. Wilayah AWS](https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/#specifying-the-aws-region) Untuk daftar lengkap Wilayah yang tersedia, lihat [titik akhir dan kuota Amazon QLDB](https://docs.aws.amazon.com/general/latest/gr/qldb.html) di bagian. *Referensi Umum AWS* Selanjutnya, Anda dapat mengatur aplikasi sampel dasar dan menjalankan contoh kode pendek—atau Anda dapat menginstal driver dalam proyek Go yang ada. + Untuk menginstal driver QLDB dan dalam proyek AWS SDK untuk Go yang ada, lanjutkan ke. [Penginstalan](#getting-started.golang.install) + Untuk menyiapkan proyek dan menjalankan contoh kode pendek yang menunjukkan transaksi data dasar pada buku besar, lihat. [Tutorial mulai cepat](driver-quickstart-golang.md) ## Penginstalan [Driver QLDB untuk Go adalah open source di repositori awslabs/. GitHub amazon-qldb-driver-go](http://github.com/awslabs/amazon-qldb-driver-go) QLDB mendukung versi driver berikut dan dependensi Go mereka. **** | Versi Driver | Versi Go | Status | Tanggal rilis terbaru | | --- | --- | --- | --- | | [1.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/qldbdriver) | 1.14 atau yang lebih baru | Rilis produksi | 16 Juni 2021 | | [2.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver) | 1.14 atau yang lebih baru | Rilis produksi | 21 Juli 2021 | | [3.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver) | 1.15 atau yang lebih baru | Rilis produksi | 10 November 2022 | **Untuk menginstal driver** 1. Pastikan proyek Anda menggunakan [modul Go](https://blog.golang.org/using-go-modules) untuk menginstal dependensi proyek. 1. Di direktori proyek Anda, masukkan `go get` perintah berikut. ------ #### [ 3.x ] ``` $ go get -u github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver ``` ------ #### [ 2.x ] ``` $ go get -u github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver ``` ------ Menginstal driver juga menginstal dependensinya, termasuk paket [AWS SDK untuk Go](https://github.com/aws/aws-sdk-go)atau [AWS SDK untuk Go v2](https://github.com/aws/aws-sdk-go-v2), dan [Amazon](https://github.com/amzn/ion-go) Ion. Untuk contoh kode singkat tentang cara menjalankan transaksi data dasar pada buku besar, lihat. [Referensi buku masak](driver-cookbook-golang.md) # Driver Amazon QLDB untuk Go - Tutorial mulai cepat **penting** Pemberitahuan akhir dukungan: Pelanggan yang ada akan dapat menggunakan Amazon QLDB hingga akhir dukungan pada 07/31/2025. Untuk detail selengkapnya, lihat [Memigrasi Buku Besar QLDB Amazon ke Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL. Dalam tutorial ini, Anda belajar cara mengatur aplikasi sederhana menggunakan versi terbaru dari driver Amazon QLDB untuk Go. Panduan ini mencakup langkah-langkah untuk menginstal driver dan contoh kode pendek dari operasi dasar *membuat, membaca, memperbarui, dan menghapus* (CRUD). **Topics** + [ ## Prasyarat ](#driver-quickstart-golang.prereqs) + [ ## Langkah 1: Instal driver ](#driver-quickstart-golang.install) + [ ## Langkah 2: Impor paket ](#driver-quickstart-golang.import) + [ ## Langkah 3: Inisialisasi driver ](#driver-quickstart-golang.initialize) + [ ## Langkah 4: Buat tabel dan indeks ](#driver-quickstart-golang.create-table-index) + [ ## Langkah 5: Masukkan dokumen ](#driver-quickstart-golang.insert) + [ ## Langkah 6: Kueri dokumen ](#driver-quickstart-golang.query) + [ ## Langkah 7: Perbarui dokumen ](#driver-quickstart-golang.update) + [ ## Langkah 8: Kueri dokumen yang diperbarui ](#driver-quickstart-golang.query-2) + [ ## Langkah 9: Jatuhkan meja ](#driver-quickstart-golang.drop-table) + [ ## Menjalankan aplikasi lengkap ](#driver-quickstart-golang.complete) ## Prasyarat Sebelum memulai, pastikan Anda melakukan hal berikut: 1. Lengkapi driver [Prasyarat](getting-started.golang.md#getting-started.golang.prereqs) for the Go, jika Anda belum melakukannya. Ini termasuk mendaftar AWS, memberikan akses terprogram untuk pengembangan, dan menginstal Go. 1. Buat buku besar bernama`quick-start`. Untuk mempelajari cara membuat buku besar, lihat [Operasi dasar untuk buku besar QLDB Amazon](ledger-management.basics.md) atau [Langkah 1: Buat buku besar baru](getting-started-step-1.md) di *Memulai dengan konsol*. ## Langkah 1: Instal driver Pastikan proyek Anda menggunakan [modul Go](https://blog.golang.org/using-go-modules) untuk menginstal dependensi proyek. Di direktori proyek Anda, masukkan `go get` perintah berikut. ``` $ go get -u github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver ``` Menginstal driver juga menginstal dependensinya, termasuk paket v2 [AWS SDK untuk Go dan](https://github.com/aws/aws-sdk-go-v2) [Amazon](https://github.com/amzn/ion-go) Ion. ## Langkah 2: Impor paket Impor AWS paket-paket berikut. ``` import ( "context" "fmt" "github.com/amzn/ion-go/ion" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/qldbSession" "github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver" ) ``` ## Langkah 3: Inisialisasi driver Inisialisasi instance driver yang terhubung ke buku besar bernama. `quick-start` ``` cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { panic(err) } qldbSession := qldbsession.NewFromConfig(cfg, func(options *qldbsession.Options) { options.Region = "us-east-1" }) driver, err := qldbdriver.New( "quick-start", qldbSession, func(options *qldbdriver.DriverOptions) { options.LoggerVerbosity = qldbdriver.LogInfo }) if err != nil { panic(err) } defer driver.Shutdown(context.Background()) ``` **catatan** Dalam contoh kode ini, ganti *us-east-1* dengan Wilayah AWS tempat Anda membuat buku besar Anda. ## Langkah 4: Buat tabel dan indeks Contoh kode berikut menunjukkan bagaimana menjalankan `CREATE TABLE` dan `CREATE INDEX` pernyataan. ``` _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { _, err := txn.Execute("CREATE TABLE People") if err != nil { return nil, err } // When working with QLDB, it's recommended to create an index on fields we're filtering on. // This reduces the chance of OCC conflict exceptions with large datasets. _, err = txn.Execute("CREATE INDEX ON People (firstName)") if err != nil { return nil, err } _, err = txn.Execute("CREATE INDEX ON People (age)") if err != nil { return nil, err } return nil, nil }) if err != nil { panic(err) } ``` Kode ini membuat tabel bernama`People`, dan indeks untuk `firstName` dan `age` bidang pada tabel itu. [Indeks](ql-reference.create-index.md) diperlukan untuk mengoptimalkan kinerja kueri dan membantu membatasi pengecualian konflik [kontrol konkurensi optimis (OCC](concurrency.md)). ## Langkah 5: Masukkan dokumen Contoh kode berikut menunjukkan cara menjalankan `INSERT` pernyataan. QLDB mendukung bahasa kueri [PartiQL](ql-reference.md) (kompatibel dengan SQL) dan format data [Amazon](ion.md) Ion (superset JSON). ### Menggunakan PartiQL literal Kode berikut menyisipkan dokumen ke dalam `People` tabel menggunakan pernyataan PartiQL string literal. ``` _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("INSERT INTO People {'firstName': 'Jane', 'lastName': 'Doe', 'age': 77}") }) if err != nil { panic(err) } ``` ### Menggunakan tipe data Ion Mirip dengan [paket JSON](https://golang.org/pkg/encoding/json/) bawaan Go, Anda dapat membuat marshal dan unmarshal tipe data Go ke dan dari Ion. 1. Misalkan Anda memiliki struktur Go berikut bernama`Person`. ``` type Person struct { FirstName string `ion:"firstName"` LastName string `ion:"lastName"` Age int `ion:"age"` } ``` 1. Buat instans `Person`. ``` person := Person{"John", "Doe", 54} ``` Pengemudi membuat representasi teks yang disandikan ion untuk Anda. `person` **penting** Agar marshal dan unmarshal berfungsi dengan baik, nama bidang struktur data Go harus diekspor (huruf pertama dikapitalisasi). 1. Lulus `person` instance ke `Execute` metode transaksi. ``` _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("INSERT INTO People ?", person) }) if err != nil { panic(err) } ``` Contoh ini menggunakan tanda tanya (`?`) sebagai placeholder variabel untuk meneruskan informasi dokumen ke pernyataan. Saat Anda menggunakan placeholder, Anda harus meneruskan nilai teks yang disandikan ion. **Tip** Untuk menyisipkan beberapa dokumen dengan menggunakan satu [INSERT](ql-reference.insert.md) pernyataan, Anda dapat meneruskan parameter [daftar](driver-working-with-ion.md#driver-ion-list) tipe ke pernyataan sebagai berikut. ``` // people is a list txn.Execute("INSERT INTO People ?", people) ``` Anda tidak melampirkan variabel placeholder (`?`) dalam tanda kurung sudut ganda (`<<...>>`) saat melewati daftar. *Dalam pernyataan PartiQL manual, tanda kurung sudut ganda menunjukkan koleksi tidak berurutan yang dikenal sebagai tas.* ## Langkah 6: Kueri dokumen Contoh kode berikut menunjukkan bagaimana menjalankan `SELECT` pernyataan. ``` p, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute("SELECT firstName, lastName, age FROM People WHERE age = 54") if err != nil { return nil, err } // Assume the result is not empty hasNext := result.Next(txn) if !hasNext && result.Err() != nil { return nil, result.Err() } ionBinary := result.GetCurrentData() temp := new(Person) err = ion.Unmarshal(ionBinary, temp) if err != nil { return nil, err } return *temp, nil }) if err != nil { panic(err) } var returnedPerson Person returnedPerson = p.(Person) if returnedPerson != person { fmt.Print("Queried result does not match inserted struct") } ``` Contoh ini menanyakan dokumen Anda dari `People` tabel, mengasumsikan bahwa kumpulan hasil tidak kosong, dan mengembalikan dokumen Anda dari hasilnya. ## Langkah 7: Perbarui dokumen Contoh kode berikut menunjukkan bagaimana menjalankan `UPDATE` pernyataan. ``` person.Age += 10 _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("UPDATE People SET age = ? WHERE firstName = ?", person.Age, person.FirstName) }) if err != nil { panic(err) } ``` ## Langkah 8: Kueri dokumen yang diperbarui Contoh kode berikut query `People` tabel oleh `firstName` dan mengembalikan semua dokumen dalam set hasil. ``` p, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute("SELECT firstName, lastName, age FROM People WHERE firstName = ?", person.FirstName) if err != nil { return nil, err } var people []Person for result.Next(txn) { ionBinary := result.GetCurrentData() temp := new(Person) err = ion.Unmarshal(ionBinary, temp) if err != nil { return nil, err } people = append(people, *temp) } if result.Err() != nil { return nil, result.Err() } return people, nil }) if err != nil { panic(err) } var people []Person people = p.([]Person) updatedPerson := Person{"John", "Doe", 64} if people[0] != updatedPerson { fmt.Print("Queried result does not match updated struct") } ``` ## Langkah 9: Jatuhkan meja Contoh kode berikut menunjukkan bagaimana menjalankan `DROP TABLE` pernyataan. ``` _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("DROP TABLE People") }) if err != nil { panic(err) } ``` ## Menjalankan aplikasi lengkap Contoh kode berikut adalah versi lengkap aplikasi. Alih-alih melakukan langkah-langkah sebelumnya satu per satu, Anda juga dapat menyalin dan menjalankan contoh kode ini dari awal hingga akhir. Aplikasi ini menunjukkan beberapa operasi CRUD dasar pada buku besar bernama. `quick-start` **catatan** Sebelum Anda menjalankan kode ini, pastikan bahwa Anda belum memiliki tabel aktif bernama `People` dalam `quick-start` buku besar. ``` package main import ( "context" "fmt" "github.com/amzn/ion-go/ion" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/qldbsession" "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver" ) func main() { awsSession := session.Must(session.NewSession(aws.NewConfig().WithRegion("us-east-1"))) qldbSession := qldbsession.New(awsSession) driver, err := qldbdriver.New( "quick-start", qldbSession, func(options *qldbdriver.DriverOptions) { options.LoggerVerbosity = qldbdriver.LogInfo }) if err != nil { panic(err) } defer driver.Shutdown(context.Background()) _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { _, err := txn.Execute("CREATE TABLE People") if err != nil { return nil, err } // When working with QLDB, it's recommended to create an index on fields we're filtering on. // This reduces the chance of OCC conflict exceptions with large datasets. _, err = txn.Execute("CREATE INDEX ON People (firstName)") if err != nil { return nil, err } _, err = txn.Execute("CREATE INDEX ON People (age)") if err != nil { return nil, err } return nil, nil }) if err != nil { panic(err) } _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("INSERT INTO People {'firstName': 'Jane', 'lastName': 'Doe', 'age': 77}") }) if err != nil { panic(err) } type Person struct { FirstName string `ion:"firstName"` LastName string `ion:"lastName"` Age int `ion:"age"` } person := Person{"John", "Doe", 54} _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("INSERT INTO People ?", person) }) if err != nil { panic(err) } p, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute("SELECT firstName, lastName, age FROM People WHERE age = 54") if err != nil { return nil, err } // Assume the result is not empty hasNext := result.Next(txn) if !hasNext && result.Err() != nil { return nil, result.Err() } ionBinary := result.GetCurrentData() temp := new(Person) err = ion.Unmarshal(ionBinary, temp) if err != nil { return nil, err } return *temp, nil }) if err != nil { panic(err) } var returnedPerson Person returnedPerson = p.(Person) if returnedPerson != person { fmt.Print("Queried result does not match inserted struct") } person.Age += 10 _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("UPDATE People SET age = ? WHERE firstName = ?", person.Age, person.FirstName) }) if err != nil { panic(err) } p, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute("SELECT firstName, lastName, age FROM People WHERE firstName = ?", person.FirstName) if err != nil { return nil, err } var people []Person for result.Next(txn) { ionBinary := result.GetCurrentData() temp := new(Person) err = ion.Unmarshal(ionBinary, temp) if err != nil { return nil, err } people = append(people, *temp) } if result.Err() != nil { return nil, result.Err() } return people, nil }) if err != nil { panic(err) } var people []Person people = p.([]Person) updatedPerson := Person{"John", "Doe", 64} if people[0] != updatedPerson { fmt.Print("Queried result does not match updated struct") } _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("DROP TABLE People") }) if err != nil { panic(err) } } ``` # Driver Amazon QLDB untuk Go - Referensi buku masak **penting** Pemberitahuan akhir dukungan: Pelanggan yang ada akan dapat menggunakan Amazon QLDB hingga akhir dukungan pada 07/31/2025. Untuk detail selengkapnya, lihat [Memigrasi Buku Besar QLDB Amazon ke Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL. Panduan referensi ini menunjukkan kasus penggunaan umum driver QLDB Amazon untuk Go. Ini memberikan contoh kode Go yang menunjukkan cara menggunakan driver untuk menjalankan operasi dasar *membuat, membaca, memperbarui, dan menghapus* (CRUD). Ini juga mencakup contoh kode untuk memproses data Amazon Ion. Selain itu, panduan ini menyoroti praktik terbaik untuk membuat transaksi idempoten dan menerapkan kendala keunikan. **catatan** Jika berlaku, beberapa kasus penggunaan memiliki contoh kode yang berbeda untuk setiap versi utama driver QLDB yang didukung untuk Go. **Contents** + [ ## Mengimpor driver ](#cookbook-golang.importing) + [ ## Membuat instantiasi pengemudi ](#cookbook-golang.instantiating) + [ ## Operasi CRUD ](#cookbook-golang.crud) + [ ### Membuat tabel ](#cookbook-golang.crud.creating-tables) + [ ### Membuat indeks ](#cookbook-golang.crud.creating-indexes) + [ ### Membaca dokumen ](#cookbook-golang.crud.reading) + [ #### Menggunakan parameter kueri ](#cookbook-golang.reading-using-params) + [ ### Menyisipkan dokumen ](#cookbook-golang.crud.inserting) + [ #### Menyisipkan beberapa dokumen dalam satu pernyataan ](#cookbook-golang.crud.inserting.multiple) + [ ### Memperbarui dokumen ](#cookbook-golang.crud.updating) + [ ### Menghapus dokumen ](#cookbook-golang.crud.deleting) + [ ### Menjalankan beberapa pernyataan dalam transaksi ](#cookbook-golang.crud.multi-statement) + [ ### Logika coba lagi ](#cookbook-golang.crud.retry-logic) + [ ### Menerapkan kendala keunikan ](#cookbook-golang.crud.uniqueness-constraints) + [ ## Bekerja dengan Amazon Ion ](#cookbook-golang.ion) + [ ### Mengimpor modul Ion ](#cookbook-golang.ion.import) + [ ### Membuat tipe Ion ](#cookbook-golang.ion.creating-types) + [ ### Mendapatkan biner Ion ](#cookbook-golang.ion.getting-binary) + [ ### Mendapatkan teks Ion ](#cookbook-golang.ion.getting-text) ## Mengimpor driver Contoh kode berikut mengimpor driver dan AWS paket lain yang diperlukan. ------ #### [ 3.x ] ``` import ( "github.com/amzn/ion-go/ion" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/qldbSession" "github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver" ) ``` ------ #### [ 2.x ] ``` import ( "github.com/amzn/ion-go/ion" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/qldbsession" "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver" ) ``` ------ **catatan** Contoh ini juga mengimpor paket Amazon Ion (`amzn/ion-go/ion`). Anda memerlukan paket ini untuk memproses data Ion saat menjalankan beberapa operasi data dalam referensi ini. Untuk mempelajari selengkapnya, lihat [Bekerja dengan Amazon Ion](#cookbook-golang.ion). ## Membuat instantiasi pengemudi Contoh kode berikut membuat instance dari driver yang menghubungkan ke nama buku besar tertentu dalam yang ditentukan Wilayah AWS. ------ #### [ 3.x ] ``` cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { panic(err) } qldbSession := qldbsession.NewFromConfig(cfg, func(options *qldbsession.Options) { options.Region = "us-east-1" }) driver, err := qldbdriver.New( "vehicle-registration", qldbSession, func(options *qldbdriver.DriverOptions) { options.LoggerVerbosity = qldbdriver.LogInfo }) if err != nil { panic(err) } defer driver.Shutdown(context.Background()) ``` ------ #### [ 2.x ] ``` awsSession := session.Must(session.NewSession(aws.NewConfig().WithRegion("us-east-1"))) qldbSession := qldbsession.New(awsSession) driver, err := qldbdriver.New( "vehicle-registration", qldbSession, func(options *qldbdriver.DriverOptions) { options.LoggerVerbosity = qldbdriver.LogInfo }) if err != nil { panic(err) } ``` ------ ## Operasi CRUD QLDB *menjalankan operasi create, read, update, and* delete (CRUD) sebagai bagian dari transaksi. **Awas** Sebagai praktik terbaik, buat transaksi tulis Anda benar-benar idempoten. **Membuat transaksi idempoten** Kami menyarankan Anda membuat transaksi tulis idempoten untuk menghindari efek samping yang tidak terduga dalam kasus percobaan ulang. Transaksi adalah *idempoten* jika dapat berjalan beberapa kali dan menghasilkan hasil yang identik setiap kali. Misalnya, pertimbangkan transaksi yang menyisipkan dokumen ke dalam tabel bernama`Person`. Transaksi harus terlebih dahulu memeriksa apakah dokumen sudah ada dalam tabel atau tidak. Tanpa pemeriksaan ini, tabel mungkin berakhir dengan dokumen duplikat. Misalkan QLDB berhasil melakukan transaksi di sisi server, tetapi waktu klien habis sambil menunggu respons. Jika transaksi tidak idempoten, dokumen yang sama dapat dimasukkan lebih dari sekali dalam kasus percobaan ulang. **Menggunakan indeks untuk menghindari pemindaian tabel penuh** Kami juga menyarankan Anda menjalankan pernyataan dengan klausa `WHERE` predikat menggunakan operator *kesetaraan* pada bidang yang diindeks atau ID dokumen; misalnya, atau. `WHERE indexedField = 123` `WHERE indexedField IN (456, 789)` *Tanpa pencarian yang diindeks ini, QLDB perlu melakukan pemindaian tabel, yang dapat menyebabkan batas waktu transaksi atau konflik kontrol konkurensi optimis (OCC).* Untuk informasi lebih lanjut tentang OCC, lihat[Model konkurensi QLDB Amazon](concurrency.md). **Transaksi yang dibuat secara implisit** Fungsi [QLDBDriver.Execute](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#QLDBDriver.Execute) menerima fungsi lambda yang menerima instance [Transaction](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#Transaction), yang dapat Anda gunakan untuk menjalankan pernyataan. Contoh `Transaction` membungkus transaksi yang dibuat secara implisit. Anda dapat menjalankan pernyataan dalam fungsi lambda dengan menggunakan `Transaction.Execute` fungsi. Pengemudi secara implisit melakukan transaksi saat fungsi lambda kembali. Bagian berikut menunjukkan cara menjalankan operasi CRUD dasar, menentukan logika coba ulang kustom, dan menerapkan kendala keunikan. **Contents** + [ ### Membuat tabel ](#cookbook-golang.crud.creating-tables) + [ ### Membuat indeks ](#cookbook-golang.crud.creating-indexes) + [ ### Membaca dokumen ](#cookbook-golang.crud.reading) + [ #### Menggunakan parameter kueri ](#cookbook-golang.reading-using-params) + [ ### Menyisipkan dokumen ](#cookbook-golang.crud.inserting) + [ #### Menyisipkan beberapa dokumen dalam satu pernyataan ](#cookbook-golang.crud.inserting.multiple) + [ ### Memperbarui dokumen ](#cookbook-golang.crud.updating) + [ ### Menghapus dokumen ](#cookbook-golang.crud.deleting) + [ ### Menjalankan beberapa pernyataan dalam transaksi ](#cookbook-golang.crud.multi-statement) + [ ### Logika coba lagi ](#cookbook-golang.crud.retry-logic) + [ ### Menerapkan kendala keunikan ](#cookbook-golang.crud.uniqueness-constraints) ### Membuat tabel ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("CREATE TABLE Person") }) ``` ### Membuat indeks ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("CREATE INDEX ON Person(GovId)") }) ``` ### Membaca dokumen ``` var decodedResult map[string]interface{} // Assumes that Person table has documents as follows: // { "GovId": "TOYENC486FH", "FirstName": "Brent" } _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'") if err != nil { return nil, err } for result.Next(txn) { ionBinary := result.GetCurrentData() err = ion.Unmarshal(ionBinary, &decodedResult) if err != nil { return nil, err } fmt.Println(decodedResult) // prints map[GovId: TOYENC486FH FirstName:Brent] } if result.Err() != nil { return nil, result.Err() } return nil, nil }) if err != nil { panic(err) } ``` #### Menggunakan parameter kueri Contoh kode berikut menggunakan parameter query tipe asli. ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("SELECT * FROM Person WHERE GovId = ?", "TOYENC486FH") }) if err != nil { panic(err) } ``` Contoh kode berikut menggunakan beberapa parameter query. ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?", "TOYENC486FH", "Brent") }) if err != nil { panic(err) } ``` Contoh kode berikut menggunakan daftar parameter query. ``` govIDs := []string{}{"TOYENC486FH", "ROEE1", "YH844"} result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("SELECT * FROM Person WHERE GovId IN (?,?,?)", govIDs...) }) if err != nil { panic(err) } ``` **catatan** Saat Anda menjalankan kueri tanpa pencarian yang diindeks, itu akan memanggil pemindaian tabel lengkap. Dalam contoh ini, kami merekomendasikan memiliki [indeks](ql-reference.create-index.md) di `GovId` lapangan untuk mengoptimalkan kinerja. Tanpa indeks aktif`GovId`, kueri dapat memiliki lebih banyak latensi dan juga dapat menyebabkan pengecualian konflik OCC atau batas waktu transaksi. ### Menyisipkan dokumen Contoh kode berikut menyisipkan tipe data asli. ``` _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { // Check if a document with a GovId of TOYENC486FH exists // This is critical to make this transaction idempotent result, err := txn.Execute("SELECT * FROM Person WHERE GovId = ?", "TOYENC486FH") if err != nil { return nil, err } // Check if there are any results if result.Next(txn) { // Document already exists, no need to insert } else { person := map[string]interface{}{ "GovId": "TOYENC486FH", "FirstName": "Brent", } _, err = txn.Execute("INSERT INTO Person ?", person) if err != nil { return nil, err } } return nil, nil }) ``` Transaksi ini memasukkan dokumen ke dalam `Person` tabel. Sebelum memasukkan, pertama-tama memeriksa apakah dokumen sudah ada di tabel. **Pemeriksaan ini membuat transaksi idempoten di alam.** Bahkan jika Anda menjalankan transaksi ini beberapa kali, itu tidak akan menyebabkan efek samping yang tidak diinginkan. **catatan** Dalam contoh ini, kami merekomendasikan memiliki indeks di `GovId` lapangan untuk mengoptimalkan kinerja. Tanpa indeks aktif`GovId`, pernyataan dapat memiliki lebih banyak latensi dan juga dapat menyebabkan pengecualian konflik OCC atau batas waktu transaksi. #### Menyisipkan beberapa dokumen dalam satu pernyataan Untuk menyisipkan beberapa dokumen dengan menggunakan satu [INSERT](ql-reference.insert.md) pernyataan, Anda dapat meneruskan parameter [daftar](driver-working-with-ion.md#driver-ion-list) tipe ke pernyataan sebagai berikut. ``` // people is a list txn.Execute("INSERT INTO People ?", people) ``` Anda tidak melampirkan variabel placeholder (`?`) dalam tanda kurung sudut ganda (`<<...>>`) saat melewati daftar. *Dalam pernyataan PartiQL manual, tanda kurung sudut ganda menunjukkan koleksi tidak berurutan yang dikenal sebagai tas.* ### Memperbarui dokumen Contoh kode berikut menggunakan tipe data asli. ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", "John", "TOYENC486FH") }) ``` **catatan** Dalam contoh ini, kami merekomendasikan memiliki indeks di `GovId` lapangan untuk mengoptimalkan kinerja. Tanpa indeks aktif`GovId`, pernyataan dapat memiliki lebih banyak latensi dan juga dapat menyebabkan pengecualian konflik OCC atau batas waktu transaksi. ### Menghapus dokumen Contoh kode berikut menggunakan tipe data asli. ``` result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("DELETE FROM Person WHERE GovId = ?", "TOYENC486FH") }) ``` **catatan** Dalam contoh ini, kami merekomendasikan memiliki indeks di `GovId` lapangan untuk mengoptimalkan kinerja. Tanpa indeks aktif`GovId`, pernyataan dapat memiliki lebih banyak latensi dan juga dapat menyebabkan pengecualian konflik OCC atau batas waktu transaksi. ### Menjalankan beberapa pernyataan dalam transaksi ``` // This code snippet is intentionally trivial. In reality you wouldn't do this because you'd // set your UPDATE to filter on vin and insured, and check if you updated something or not. func InsureCar(driver *qldbdriver.QLDBDriver, vin string) (bool, error) { insured, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { result, err := txn.Execute( "SELECT insured FROM Vehicles WHERE vin = ? AND insured = FALSE", vin) if err != nil { return false, err } hasNext := result.Next(txn) if !hasNext && result.Err() != nil { return false, result.Err() } if hasNext { _, err = txn.Execute( "UPDATE Vehicles SET insured = TRUE WHERE vin = ?", vin) if err != nil { return false, err } return true, nil } return false, nil }) if err != nil { panic(err) } return insured.(bool), err } ``` ### Logika coba lagi `Execute`Fungsi pengemudi memiliki mekanisme coba ulang bawaan yang mencoba ulang transaksi jika terjadi pengecualian yang dapat dicoba ulang (seperti batas waktu atau konflik OCC). Jumlah maksimum upaya coba lagi dan strategi backoff dapat dikonfigurasi. Batas coba lagi default adalah`4`, dan strategi backoff default adalah [ExponentialBackoffStrategy](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#ExponentialBackoffStrategy)dengan basis milidetik. `10` Anda dapat mengatur kebijakan coba lagi per instance driver dan juga per transaksi dengan menggunakan instance. [RetryPolicy](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#RetryPolicy) Contoh kode berikut menentukan logika coba lagi dengan batas coba ulang khusus dan strategi backoff khusus untuk instance driver. ``` import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/qldbsession" "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver" ) func main() { awsSession := session.Must(session.NewSession(aws.NewConfig().WithRegion("us-east-1"))) qldbSession := qldbsession.New(awsSession) // Configuring retry limit to 2 retryPolicy := qldbdriver.RetryPolicy{MaxRetryLimit: 2} driver, err := qldbdriver.New("test-ledger", qldbSession, func(options *qldbdriver.DriverOptions) { options.RetryPolicy = retryPolicy }) if err != nil { panic(err) } // Configuring an exponential backoff strategy with base of 20 milliseconds retryPolicy = qldbdriver.RetryPolicy{ MaxRetryLimit: 2, Backoff: qldbdriver.ExponentialBackoffStrategy{SleepBase: 20, SleepCap: 4000, }} driver, err = qldbdriver.New("test-ledger", qldbSession, func(options *qldbdriver.DriverOptions) { options.RetryPolicy = retryPolicy }) if err != nil { panic(err) } } ``` Contoh kode berikut menentukan logika coba lagi dengan batas coba ulang kustom dan strategi backoff khusus untuk fungsi anonim tertentu. `SetRetryPolicy`Fungsi ini mengesampingkan kebijakan coba lagi yang disetel untuk instance driver. ``` import ( "context" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/qldbsession" "github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver" ) func main() { awsSession := session.Must(session.NewSession(aws.NewConfig().WithRegion("us-east-1"))) qldbSession := qldbsession.New(awsSession) // Configuring retry limit to 2 retryPolicy1 := qldbdriver.RetryPolicy{MaxRetryLimit: 2} driver, err := qldbdriver.New("test-ledger", qldbSession, func(options *qldbdriver.DriverOptions) { options.RetryPolicy = retryPolicy1 }) if err != nil { panic(err) } // Configuring an exponential backoff strategy with base of 20 milliseconds retryPolicy2 := qldbdriver.RetryPolicy{ MaxRetryLimit: 2, Backoff: qldbdriver.ExponentialBackoffStrategy{SleepBase: 20, SleepCap: 4000, }} // Overrides the retry policy set by the driver instance driver.SetRetryPolicy(retryPolicy2) driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { return txn.Execute("CREATE TABLE Person") }) } ``` ### Menerapkan kendala keunikan QLDB tidak mendukung indeks unik, tetapi Anda dapat menerapkan perilaku ini dalam aplikasi Anda. Misalkan Anda ingin menerapkan kendala keunikan pada `GovId` bidang dalam tabel. `Person` Untuk melakukan ini, Anda dapat menulis transaksi yang melakukan hal berikut: 1. Tegaskan bahwa tabel tidak memiliki dokumen yang ada dengan yang ditentukan`GovId`. 1. Masukkan dokumen jika pernyataan lolos. Jika transaksi yang bersaing secara bersamaan melewati pernyataan, hanya satu transaksi yang akan berhasil dilakukan. Transaksi lainnya akan gagal dengan pengecualian konflik OCC. Contoh kode berikut menunjukkan bagaimana menerapkan logika kendala keunikan ini. ``` govID := "TOYENC486FH" document := map[string]interface{}{ "GovId": "TOYENC486FH", "FirstName": "Brent", } result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { // Check if doc with GovId = govID exists result, err := txn.Execute("SELECT * FROM Person WHERE GovId = ?", govID) if err != nil { return nil, err } // Check if there are any results if result.Next(txn) { // Document already exists, no need to insert return nil, nil } return txn.Execute("INSERT INTO Person ?", document) }) if err != nil { panic(err) } ``` **catatan** Dalam contoh ini, kami merekomendasikan memiliki indeks di `GovId` lapangan untuk mengoptimalkan kinerja. Tanpa indeks aktif`GovId`, pernyataan dapat memiliki lebih banyak latensi dan juga dapat menyebabkan pengecualian konflik OCC atau batas waktu transaksi. ## Bekerja dengan Amazon Ion Bagian berikut menunjukkan cara menggunakan modul Amazon Ion untuk memproses data Ion. **Contents** + [ ### Mengimpor modul Ion ](#cookbook-golang.ion.import) + [ ### Membuat tipe Ion ](#cookbook-golang.ion.creating-types) + [ ### Mendapatkan biner Ion ](#cookbook-golang.ion.getting-binary) + [ ### Mendapatkan teks Ion ](#cookbook-golang.ion.getting-text) ### Mengimpor modul Ion ``` import "github.com/amzn/ion-go/ion" ``` ### Membuat tipe Ion Pustaka Ion untuk Go saat ini tidak mendukung Document Object Model (DOM), sehingga Anda tidak dapat membuat tipe data Ion. Tetapi Anda dapat membuat marshal dan unmarshal antara tipe asli Go dan biner Ion saat bekerja dengan QLDB. ### Mendapatkan biner Ion ``` aDict := map[string]interface{}{ "GovId": "TOYENC486FH", "FirstName": "Brent", } ionBytes, err := ion.MarshalBinary(aDict) if err != nil { panic(err) } fmt.Println(ionBytes) // prints [224 1 0 234 238 151 129 131 222 147 135 190 144 133 71 111 118 73 100 137 70 105 114 115 116 78 97 109 101 222 148 138 139 84 79 89 69 78 67 52 56 54 70 72 139 133 66 114 101 110 116] ``` ### Mendapatkan teks Ion ``` aDict := map[string]interface{}{ "GovId": "TOYENC486FH", "FirstName": "Brent", } ionBytes, err := ion.MarshalText(aDict) if err != nil { panic(err) } fmt.Println(string(ionBytes)) // prints {FirstName:"Brent",GovId:"TOYENC486FH"} ``` Untuk informasi selengkapnya tentang Ion, lihat [dokumentasi Amazon Ion](http://amzn.github.io/ion-docs/) di GitHub. Untuk contoh kode lebih lanjut tentang bekerja dengan Ion di QLDB, lihat. [Bekerja dengan tipe data Amazon Ion di Amazon QLDB](driver-working-with-ion.md)