Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Driver Amazon QLDB untuk Python
<a name="getting-started.python"></a>

**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 Python Anda dengan menggunakan driver yang disediakan. AWS Topik berikut menjelaskan cara memulai dengan driver QLDB untuk Python.

**Topics**
+ [

## Sumber daya pengemudi
](#getting-started.python.resources)
+ [

## Prasyarat
](#getting-started.python.prereqs)
+ [

## Penginstalan
](#getting-started.python.install)
+ [Tutorial mulai cepat](driver-quickstart-python.md)
+ [Referensi buku masak](driver-cookbook-python.md)

## Sumber daya pengemudi
<a name="getting-started.python.resources"></a>

Untuk informasi selengkapnya tentang fungsionalitas yang didukung oleh driver Python, lihat sumber daya berikut:
+ [Referensi API: [3.x](https://amazon-qldb-driver-python.readthedocs.io/en/latest/), 2.x](https://amazon-qldb-driver-python.readthedocs.io/en/v2.0.2/)
+ [Kode sumber driver (GitHub)](https://github.com/awslabs/amazon-qldb-driver-python)
+ [Contoh kode sumber aplikasi (GitHub)](https://github.com/aws-samples/amazon-qldb-dmv-sample-python)
+ [Contoh kode Amazon Ion](ion.code-examples.md)

## Prasyarat
<a name="getting-started.python.prereqs"></a>

Sebelum Anda memulai dengan driver QLDB untuk Python, 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. Instal salah satu versi Python berikut dari situs unduhan [Python](https://www.python.org/downloads/):
   + **3.6 atau yang lebih baru - driver** QLDB untuk Python v3
   + **3.4 atau yang lebih baru** - driver QLDB untuk Python v2

1. Siapkan AWS kredensil Anda dan default Anda. Wilayah AWS Untuk petunjuk, lihat [Mulai cepat](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#configuration) di AWS SDK untuk Python (Boto3) dokumentasi.

   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 mengunduh aplikasi contoh tutorial lengkap—atau Anda hanya dapat menginstal driver dalam proyek Python dan menjalankan contoh kode pendek.
+ Untuk menginstal driver QLDB dan dalam proyek AWS SDK untuk Python (Boto3) yang ada, lanjutkan ke. [Penginstalan](#getting-started.python.install)
+ Untuk menyiapkan proyek dan menjalankan contoh kode pendek yang menunjukkan transaksi data dasar pada buku besar, lihat. [Tutorial mulai cepat](driver-quickstart-python.md)
+ Untuk menjalankan contoh yang lebih mendalam dari operasi API data dan manajemen dalam aplikasi contoh tutorial lengkap, lihat. [Tutorial Python](getting-started.python.tutorial.md)

## Penginstalan
<a name="getting-started.python.install"></a>

QLDB mendukung versi driver berikut dan dependensi Python mereka.


****  

| Versi Driver | Versi Python | Status | Tanggal rilis terbaru | 
| --- | --- | --- | --- | 
| [2.x](https://pypi.org/project/pyqldb/2.0.2/) | 3.4 atau yang lebih baru | Rilis produksi | 7 Mei 2020 | 
| [3.x](https://pypi.org/project/pyqldb/) | 3.6 atau yang lebih baru | Rilis produksi | 28 Oktober 2021 | 

Untuk menginstal driver QLDB dari PyPI `pip` menggunakan (manajer paket untuk Python), masukkan yang berikut ini di baris perintah.

------
#### [ 3.x ]

```
pip install pyqldb
```

------
#### [ 2.x ]

```
pip install pyqldb==2.0.2
```

------

Menginstal driver juga menginstal dependensinya, termasuk paket dan [AWS SDK untuk Python (Boto3)](https://aws.amazon.com/sdk-for-python)[Amazon](ion.md) Ion.

**Menggunakan driver untuk terhubung ke buku besar**

Kemudian Anda dapat mengimpor driver dan menggunakannya untuk terhubung ke buku besar. Contoh kode Python berikut menunjukkan cara membuat sesi untuk nama buku besar tertentu.

------
#### [ 3.x ]

```
from pyqldb.driver.qldb_driver import QldbDriver
qldb_driver = QldbDriver(ledger_name='testLedger')

for table in qldb_driver.list_tables():
    print(table)
```

------
#### [ 2.x ]

```
from pyqldb.driver.pooled_qldb_driver import PooledQldbDriver

qldb_driver = PooledQldbDriver(ledger_name='testLedger')
qldb_session = qldb_driver.get_session()

for table in qldb_session.list_tables():
    print(table)
```

------

Untuk contoh kode singkat tentang cara menjalankan transaksi data dasar pada buku besar, lihat. [Referensi buku masak](driver-cookbook-python.md)

# Driver Amazon QLDB untuk Python - Tutorial mulai cepat
<a name="driver-quickstart-python"></a>

**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 Python. Panduan ini mencakup langkah-langkah untuk menginstal driver dan contoh kode pendek dari operasi dasar *membuat, membaca, memperbarui, dan menghapus* (CRUD). Untuk contoh lebih mendalam yang menunjukkan operasi ini dalam aplikasi sampel lengkap, lihat. [Tutorial Python](getting-started.python.tutorial.md)

**Topics**
+ [

## Prasyarat
](#driver-quickstart-python.prereqs)
+ [

## Langkah 1: Siapkan proyek Anda
](#driver-quickstart-python.step-1)
+ [

## Langkah 2: Inisialisasi driver
](#driver-quickstart-python.step-2)
+ [

## Langkah 3: Buat tabel dan indeks
](#driver-quickstart-python.step-3)
+ [

## Langkah 4: Masukkan dokumen
](#driver-quickstart-python.step-4)
+ [

## Langkah 5: Kueri dokumen
](#driver-quickstart-python.step-5)
+ [

## Langkah 6: Perbarui dokumen
](#driver-quickstart-python.step-6)
+ [

## Menjalankan aplikasi lengkap
](#driver-quickstart-python.complete)

## Prasyarat
<a name="driver-quickstart-python.prereqs"></a>

Sebelum memulai, pastikan Anda melakukan hal berikut:

1. Selesaikan [Prasyarat](getting-started.python.md#getting-started.python.prereqs) untuk driver Python, jika Anda belum melakukannya. Ini termasuk mendaftar AWS, memberikan akses terprogram untuk pengembangan, dan menginstal Python versi 3.6 atau yang lebih baru.

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: Siapkan proyek Anda
<a name="driver-quickstart-python.step-1"></a>

Pertama, siapkan proyek Python Anda.

**catatan**  
Jika Anda menggunakan IDE yang memiliki fitur untuk mengotomatiskan langkah-langkah penyiapan ini, Anda dapat langsung melakukannya. [Langkah 2: Inisialisasi driver](#driver-quickstart-python.step-2)

1. Buat folder untuk aplikasi Anda.

   ```
   $ mkdir myproject
   $ cd myproject
   ```

1. Untuk menginstal driver QLDB untuk Python dari PyPI, masukkan perintah berikut. `pip`

   ```
   $ pip install pyqldb
   ```

   Menginstal driver juga menginstal dependensinya, termasuk paket dan [AWS SDK untuk Python (Boto3)](https://aws.amazon.com/sdk-for-net)[Amazon](ion.md) Ion.

1. Buat file baru bernama `app.py`.

   Kemudian, secara bertahap tambahkan contoh kode dalam langkah-langkah berikut untuk mencoba beberapa operasi CRUD dasar. Atau, Anda dapat melewati step-by-step tutorial dan menjalankan [aplikasi lengkap](#driver-quickstart-python.complete).

## Langkah 2: Inisialisasi driver
<a name="driver-quickstart-python.step-2"></a>

Inisialisasi instance driver yang terhubung ke buku besar bernama. `quick-start` Tambahkan kode berikut ke `app.py` file Anda.

```
from pyqldb.config.retry_config import RetryConfig
from pyqldb.driver.qldb_driver import QldbDriver

# Configure retry limit to 3
retry_config = RetryConfig(retry_limit=3)

# Initialize the driver
print("Initializing the driver")
qldb_driver = QldbDriver("quick-start", retry_config=retry_config)
```

## Langkah 3: Buat tabel dan indeks
<a name="driver-quickstart-python.step-3"></a>

Contoh kode berikut menunjukkan bagaimana menjalankan `CREATE TABLE` dan `CREATE INDEX` pernyataan.

Tambahkan kode berikut yang membuat tabel bernama `People` dan indeks untuk `lastName` 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)).

```
def create_table(transaction_executor):
    print("Creating a table")
    transaction_executor.execute_statement("Create TABLE People")

def create_index(transaction_executor):
    print("Creating an index")
    transaction_executor.execute_statement("CREATE INDEX ON People(lastName)")

# Create a table
qldb_driver.execute_lambda(lambda executor: create_table(executor))

# Create an index on the table
qldb_driver.execute_lambda(lambda executor: create_index(executor))
```

## Langkah 4: Masukkan dokumen
<a name="driver-quickstart-python.step-4"></a>

Contoh kode berikut menunjukkan bagaimana menjalankan `INSERT` pernyataan. QLDB mendukung bahasa kueri [PartiQL](ql-reference.md) (kompatibel dengan SQL) dan format data [Amazon](ion.md) Ion (superset JSON).

Tambahkan kode berikut yang menyisipkan dokumen ke dalam `People` tabel.

```
def insert_documents(transaction_executor, arg_1):
    print("Inserting a document")
    transaction_executor.execute_statement("INSERT INTO People ?", arg_1)

# Insert a document
doc_1 = { 'firstName': "John",
          'lastName': "Doe",
          'age': 32,
        }

qldb_driver.execute_lambda(lambda x: insert_documents(x, doc_1))
```

Contoh ini menggunakan tanda tanya (`?`) sebagai placeholder variabel untuk meneruskan informasi dokumen ke pernyataan. `execute_statement`Metode ini mendukung nilai di kedua jenis Amazon Ion dan tipe asli Python.

**Tip**  
Untuk menyisipkan beberapa dokumen dengan menggunakan [INSERT](ql-reference.insert.md) pernyataan tunggal, Anda dapat meneruskan parameter [daftar](driver-working-with-ion.md#driver-ion-list) tipe ke pernyataan sebagai berikut.  

```
# people is a list
transaction_executor.execute_statement("INSERT INTO Person ?", 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 5: Kueri dokumen
<a name="driver-quickstart-python.step-5"></a>

Contoh kode berikut menunjukkan bagaimana menjalankan `SELECT` pernyataan.

Tambahkan kode berikut yang menanyakan dokumen dari `People` tabel.

```
def read_documents(transaction_executor):
    print("Querying the table")
    cursor = transaction_executor.execute_statement("SELECT * FROM People WHERE lastName = ?", 'Doe')

    for doc in cursor:
        print(doc["firstName"])
        print(doc["lastName"])
        print(doc["age"])

# Query the table
qldb_driver.execute_lambda(lambda executor: read_documents(executor))
```

## Langkah 6: Perbarui dokumen
<a name="driver-quickstart-python.step-6"></a>

Contoh kode berikut menunjukkan bagaimana menjalankan `UPDATE` pernyataan.

1. Tambahkan kode berikut yang memperbarui dokumen dalam `People` tabel dengan memperbarui `age` ke`42`.

   ```
   def update_documents(transaction_executor, age, lastName):
       print("Updating the document")
       transaction_executor.execute_statement("UPDATE People SET age = ? WHERE lastName = ?", age, lastName)
   
   # Update the document
   age = 42
   lastName = 'Doe'
   
   qldb_driver.execute_lambda(lambda x: update_documents(x, age, lastName))
   ```

1. Kueri tabel lagi untuk melihat nilai yang diperbarui.

   ```
   # Query the updated document
   qldb_driver.execute_lambda(lambda executor: read_documents(executor))
   ```

1. Untuk menjalankan aplikasi, masukkan perintah berikut dari direktori proyek Anda.

   ```
   $ python app.py
   ```

## Menjalankan aplikasi lengkap
<a name="driver-quickstart-python.complete"></a>

Contoh kode berikut adalah versi lengkap `app.py` 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.

```
from pyqldb.config.retry_config import RetryConfig
from pyqldb.driver.qldb_driver import QldbDriver

def create_table(transaction_executor):
    print("Creating a table")
    transaction_executor.execute_statement("CREATE TABLE People")

def create_index(transaction_executor):
    print("Creating an index")
    transaction_executor.execute_statement("CREATE INDEX ON People(lastName)")

def insert_documents(transaction_executor, arg_1):
    print("Inserting a document")
    transaction_executor.execute_statement("INSERT INTO People ?", arg_1)

def read_documents(transaction_executor):
    print("Querying the table")
    cursor = transaction_executor.execute_statement("SELECT * FROM People WHERE lastName = ?", 'Doe')
                                                                                                                                          
    for doc in cursor:
        print(doc["firstName"])
        print(doc["lastName"])
        print(doc["age"])

def update_documents(transaction_executor, age, lastName):
    print("Updating the document")
    transaction_executor.execute_statement("UPDATE People SET age = ? WHERE lastName = ?", age, lastName)

# Configure retry limit to 3
retry_config = RetryConfig(retry_limit=3)

# Initialize the driver
print("Initializing the driver")
qldb_driver = QldbDriver("quick-start", retry_config=retry_config)

# Create a table
qldb_driver.execute_lambda(lambda executor: create_table(executor))

# Create an index on the table
qldb_driver.execute_lambda(lambda executor: create_index(executor))

# Insert a document
doc_1 = { 'firstName': "John",
          'lastName': "Doe",
          'age': 32,
        }

qldb_driver.execute_lambda(lambda x: insert_documents(x, doc_1))

# Query the table
qldb_driver.execute_lambda(lambda executor: read_documents(executor))

# Update the document
age = 42
lastName = 'Doe'

qldb_driver.execute_lambda(lambda x: update_documents(x, age, lastName))

# Query the table for the updated document
qldb_driver.execute_lambda(lambda executor: read_documents(executor))
```

Untuk menjalankan aplikasi lengkap, masukkan perintah berikut dari direktori proyek Anda.

```
$ python app.py
```

# Driver Amazon QLDB untuk Python - Referensi buku masak
<a name="driver-cookbook-python"></a>

**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 Python. Ini memberikan contoh kode Python yang menunjukkan bagaimana menggunakan driver untuk menjalankan operasi dasar *create, read, update, and delete* (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 yang didukung dari driver QLDB untuk Python.

**Contents**
+ [

## Mengimpor driver
](#cookbook-python.importing)
+ [

## Membuat instantiasi pengemudi
](#cookbook-python.instantiating)
+ [

## Operasi CRUD
](#cookbook-python.crud)
  + [

### Membuat tabel
](#cookbook-python.crud.creating-tables)
  + [

### Membuat indeks
](#cookbook-python.crud.creating-indexes)
  + [

### Membaca dokumen
](#cookbook-python.crud.reading)
    + [

#### Menggunakan parameter kueri
](#cookbook-python.reading-using-params)
  + [

### Memasukkan dokumen
](#cookbook-python.crud.inserting)
    + [

#### Memasukkan beberapa dokumen dalam satu pernyataan
](#cookbook-python.crud.inserting.multiple)
  + [

### Memperbarui dokumen
](#cookbook-python.crud.updating)
  + [

### Menghapus dokumen
](#cookbook-python.crud.deleting)
  + [

### Menjalankan beberapa pernyataan dalam transaksi
](#cookbook-python.crud.multi-statement)
  + [

### Logika coba lagi
](#cookbook-python.crud.retry-logic)
  + [

### Menerapkan kendala keunikan
](#cookbook-python.crud.uniqueness-constraints)
+ [

## Bekerja dengan Amazon Ion
](#cookbook-python.ion)
  + [

### Mengimpor modul Ion
](#cookbook-python.ion.import)
  + [

### Membuat tipe Ion
](#cookbook-python.ion.creating-types)
  + [

### Mendapatkan dump biner Ion
](#cookbook-python.ion.getting-binary)
  + [

### Mendapatkan dump teks Ion
](#cookbook-python.ion.getting-text)

## Mengimpor driver
<a name="cookbook-python.importing"></a>

Contoh kode berikut mengimpor driver.

------
#### [ 3.x ]

```
from pyqldb.driver.qldb_driver import QldbDriver
import amazon.ion.simpleion as simpleion
```

------
#### [ 2.x ]

```
from pyqldb.driver.pooled_qldb_driver import PooledQldbDriver
import amazon.ion.simpleion as simpleion
```

------

**catatan**  
Contoh ini juga mengimpor paket Amazon Ion (`amazon.ion.simpleion`). 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-python.ion).

## Membuat instantiasi pengemudi
<a name="cookbook-python.instantiating"></a>

Contoh kode berikut membuat instance driver yang terhubung ke nama buku besar tertentu menggunakan pengaturan default.

------
#### [ 3.x ]

```
qldb_driver = QldbDriver(ledger_name='vehicle-registration')
```

------
#### [ 2.x ]

```
qldb_driver = PooledQldbDriver(ledger_name='vehicle-registration')
```

------

## Operasi CRUD
<a name="cookbook-python.crud"></a>

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**

[Metode [pyqldb.driver.qldb\$1driver.execute\$1lambda menerima fungsi lambda yang menerima instance PyQLDB.Execution.Executor.Executor](https://amazon-qldb-driver-python.readthedocs.io/en/stable/reference/driver/qldb_driver.html#pyqldb.driver.qldb_driver.QldbDriver.execute_lambda), yang dapat Anda gunakan untuk menjalankan pernyataan.](https://amazon-qldb-driver-python.readthedocs.io/en/stable/reference/execution/executor.html#pyqldb.execution.executor.Executor) Contoh `Executor` membungkus transaksi yang dibuat secara implisit.

Anda dapat menjalankan pernyataan dalam fungsi lambda dengan menggunakan metode [execute\$1statement](https://amazon-qldb-driver-python.readthedocs.io/en/stable/reference/execution/executor.html#pyqldb.execution.executor.Executor.execute_statement) dari pelaksana transaksi. Pengemudi secara implisit melakukan transaksi saat fungsi lambda kembali.

**catatan**  
`execute_statement`Metode ini mendukung jenis Amazon Ion dan tipe asli Python. Jika Anda meneruskan tipe asli Python sebagai argumen`execute_statement`, driver mengubahnya menjadi tipe Ion menggunakan `amazon.ion.simpleion` modul (asalkan konversi untuk tipe data Python yang diberikan didukung). Untuk tipe data dan aturan konversi yang didukung, lihat [kode sumber simpleion](https://ion-python.readthedocs.io/en/latest/_modules/amazon/ion/simpleion.html).

Bagian berikut menunjukkan cara menjalankan operasi CRUD dasar, menentukan logika coba ulang kustom, dan menerapkan kendala keunikan.

**Contents**
+ [

### Membuat tabel
](#cookbook-python.crud.creating-tables)
+ [

### Membuat indeks
](#cookbook-python.crud.creating-indexes)
+ [

### Membaca dokumen
](#cookbook-python.crud.reading)
  + [

#### Menggunakan parameter kueri
](#cookbook-python.reading-using-params)
+ [

### Memasukkan dokumen
](#cookbook-python.crud.inserting)
  + [

#### Memasukkan beberapa dokumen dalam satu pernyataan
](#cookbook-python.crud.inserting.multiple)
+ [

### Memperbarui dokumen
](#cookbook-python.crud.updating)
+ [

### Menghapus dokumen
](#cookbook-python.crud.deleting)
+ [

### Menjalankan beberapa pernyataan dalam transaksi
](#cookbook-python.crud.multi-statement)
+ [

### Logika coba lagi
](#cookbook-python.crud.retry-logic)
+ [

### Menerapkan kendala keunikan
](#cookbook-python.crud.uniqueness-constraints)

### Membuat tabel
<a name="cookbook-python.crud.creating-tables"></a>

```
def create_table(transaction_executor):
    transaction_executor.execute_statement("CREATE TABLE Person")

qldb_driver.execute_lambda(lambda executor: create_table(executor))
```

### Membuat indeks
<a name="cookbook-python.crud.creating-indexes"></a>

```
def create_index(transaction_executor):
    transaction_executor.execute_statement("CREATE INDEX ON Person(GovId)")

qldb_driver.execute_lambda(lambda executor: create_index(executor))
```

### Membaca dokumen
<a name="cookbook-python.crud.reading"></a>

```
# Assumes that Person table has documents as follows:
# { "GovId": "TOYENC486FH", "FirstName": "Brent" }

def read_documents(transaction_executor):
    cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'")

    for doc in cursor:
        print(doc["GovId"]) # prints TOYENC486FH
        print(doc["FirstName"]) # prints Brent

qldb_driver.execute_lambda(lambda executor: read_documents(executor))
```

#### Menggunakan parameter kueri
<a name="cookbook-python.reading-using-params"></a>

Contoh kode berikut menggunakan parameter query tipe asli.

```
cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = ?", 'TOYENC486FH')
```

Contoh kode berikut menggunakan parameter query tipe Ion.

```
name = ion.loads('Brent')
cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE FirstName = ?", name)
```

Contoh kode berikut menggunakan beberapa parameter query.

```
cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?", 'TOYENC486FH', "Brent")
```

Contoh kode berikut menggunakan daftar parameter query.

```
gov_ids = ['TOYENC486FH','ROEE1','YH844']
cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId IN (?,?,?)", *gov_ids)
```

**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.

### Memasukkan dokumen
<a name="cookbook-python.crud.inserting"></a>

Contoh kode berikut menyisipkan tipe data asli.

```
def insert_documents(transaction_executor, arg_1):
    # Check if doc with GovId:TOYENC486FH exists
    # This is critical to make this transaction idempotent
    cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = ?", 'TOYENC486FH')
    # Check if there is any record in the cursor
    first_record = next(cursor, None)

    if first_record:
        # Record already exists, no need to insert
        pass
    else:
        transaction_executor.execute_statement("INSERT INTO Person ?", arg_1)

doc_1 = { 'FirstName': "Brent",
          'GovId': 'TOYENC486FH',
        }

qldb_driver.execute_lambda(lambda executor: insert_documents(executor, doc_1))
```

Contoh kode berikut menyisipkan tipe data Ion.

```
def insert_documents(transaction_executor, arg_1):
    # Check if doc with GovId:TOYENC486FH exists
    # This is critical to make this transaction idempotent
    cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = ?", 'TOYENC486FH')
    # Check if there is any record in the cursor
    first_record = next(cursor, None)

    if first_record:
        # Record already exists, no need to insert
        pass
    else:
        transaction_executor.execute_statement("INSERT INTO Person ?", arg_1)

doc_1 = { 'FirstName': 'Brent',
          'GovId': 'TOYENC486FH',
        }

# create a sample Ion doc
ion_doc_1 = simpleion.loads(simpleion.dumps(doc_1)))

qldb_driver.execute_lambda(lambda executor: insert_documents(executor, ion_doc_1))
```

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.

#### Memasukkan beberapa dokumen dalam satu pernyataan
<a name="cookbook-python.crud.inserting.multiple"></a>

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
transaction_executor.execute_statement("INSERT INTO Person ?", 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
<a name="cookbook-python.crud.updating"></a>

Contoh kode berikut menggunakan tipe data asli.

```
def update_documents(transaction_executor, gov_id, name):
    transaction_executor.execute_statement("UPDATE Person SET FirstName = ?  WHERE GovId = ?", name, gov_id)

gov_id = 'TOYENC486FH'
name = 'John'

qldb_driver.execute_lambda(lambda executor: update_documents(executor, gov_id, name))
```

Contoh kode berikut menggunakan tipe data Ion.

```
def update_documents(transaction_executor, gov_id, name):
    transaction_executor.execute_statement("UPDATE Person SET FirstName = ? WHERE GovId = ?", name, gov_id)

# Ion datatypes
gov_id = simpleion.loads('TOYENC486FH')
name = simpleion.loads('John')

qldb_driver.execute_lambda(lambda executor: update_documents(executor, gov_id, name))
```

**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
<a name="cookbook-python.crud.deleting"></a>

Contoh kode berikut menggunakan tipe data asli.

```
def delete_documents(transaction_executor, gov_id):
    cursor = transaction_executor.execute_statement("DELETE FROM Person WHERE GovId = ?", gov_id)

gov_id = 'TOYENC486FH'

qldb_driver.execute_lambda(lambda executor: delete_documents(executor, gov_id))
```

Contoh kode berikut menggunakan tipe data Ion.

```
def delete_documents(transaction_executor, gov_id):
    cursor = transaction_executor.execute_statement("DELETE FROM Person WHERE GovId = ?", gov_id)

# Ion datatypes
gov_id = simpleion.loads('TOYENC486FH')

qldb_driver.execute_lambda(lambda executor: delete_documents(executor, gov_id))
```

**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
<a name="cookbook-python.crud.multi-statement"></a>

```
# 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.

def do_insure_car(transaction_executor, vin):
    cursor = transaction_executor.execute_statement(
        "SELECT insured FROM Vehicles WHERE vin = ? AND insured = FALSE", vin)
    first_record = next(cursor, None)
    if first_record:
        transaction_executor.execute_statement(
            "UPDATE Vehicles SET insured = TRUE WHERE vin = ?", vin)
        return True
    else:
        return False

def insure_car(qldb_driver, vin_to_insure):
    return qldb_driver.execute_lambda(
        lambda executor: do_insure_car(executor, vin_to_insure))
```

### Logika coba lagi
<a name="cookbook-python.crud.retry-logic"></a>

`execute_lambda`Metode pengemudi memiliki mekanisme coba ulang bawaan yang mencoba ulang transaksi jika pengecualian yang dapat dicoba ulang terjadi (seperti batas waktu atau konflik OCC).

------
#### [ 3.x ]

Jumlah maksimum upaya coba lagi dan strategi backoff dapat dikonfigurasi.

Batas coba lagi default adalah`4`, dan strategi backoff default adalah [Exponential Backoff dan Jitter dengan basis milidetik](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/). `10` Anda dapat mengatur konfigurasi coba lagi per instance driver dan juga per transaksi dengan menggunakan instance [pyqldb.config.retry\$1config. RetryConfig](https://amazon-qldb-driver-python.readthedocs.io/en/stable/reference/config/retry_config.html#pyqldb.config.retry_config.RetryConfig).

Contoh kode berikut menentukan logika coba lagi dengan batas coba ulang khusus dan strategi backoff khusus untuk instance driver.

```
from pyqldb.config.retry_config import RetryConfig
from pyqldb.driver.qldb_driver import QldbDriver

# Configuring retry limit to 2
retry_config = RetryConfig(retry_limit=2)
qldb_driver = QldbDriver("test-ledger", retry_config=retry_config)

# Configuring a custom backoff which increases delay by 1s for each attempt.
def custom_backoff(retry_attempt, error, transaction_id):
    return 1000 * retry_attempt

retry_config_custom_backoff = RetryConfig(retry_limit=2, custom_backoff=custom_backoff)
qldb_driver = QldbDriver("test-ledger", retry_config=retry_config_custom_backoff)
```

Contoh kode berikut menentukan logika coba lagi dengan batas coba ulang khusus dan strategi backoff khusus untuk eksekusi lambda tertentu. Konfigurasi ini untuk `execute_lambda` mengganti logika coba lagi yang disetel untuk instance driver.

```
from pyqldb.config.retry_config import RetryConfig
from pyqldb.driver.qldb_driver import QldbDriver

# Configuring retry limit to 2
retry_config_1 = RetryConfig(retry_limit=4)
qldb_driver = QldbDriver("test-ledger", retry_config=retry_config_1)

# Configuring a custom backoff which increases delay by 1s for each attempt.
def custom_backoff(retry_attempt, error, transaction_id):
    return 1000 * retry_attempt

retry_config_2 = RetryConfig(retry_limit=2, custom_backoff=custom_backoff)

# The config `retry_config_1` will be overriden by `retry_config_2`
qldb_driver.execute_lambda(lambda txn: txn.execute_statement("CREATE TABLE Person"), retry_config_2)
```

------
#### [ 2.x ]

Jumlah maksimum upaya coba lagi dapat dikonfigurasi. Anda dapat mengonfigurasi batas coba lagi dengan menyetel `retry_limit` properti saat menginisialisasi`PooledQldbDriver`.

Batas coba ulang default adalah`4`.

------

### Menerapkan kendala keunikan
<a name="cookbook-python.crud.uniqueness-constraints"></a>

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.

```
def insert_documents(transaction_executor, gov_id, document):
    # Check if doc with GovId = gov_id exists
    cursor = transaction_executor.execute_statement("SELECT * FROM Person WHERE GovId = ?", gov_id)
    # Check if there is any record in the cursor
    first_record = next(cursor, None)

    if first_record:
        # Record already exists, no need to insert
        pass
    else:
        transaction_executor.execute_statement("INSERT INTO Person ?", document)

qldb_driver.execute_lambda(lambda executor: insert_documents(executor, gov_id, document))
```

**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
<a name="cookbook-python.ion"></a>

Bagian berikut menunjukkan cara menggunakan modul Amazon Ion untuk memproses data Ion.

**Contents**
+ [

### Mengimpor modul Ion
](#cookbook-python.ion.import)
+ [

### Membuat tipe Ion
](#cookbook-python.ion.creating-types)
+ [

### Mendapatkan dump biner Ion
](#cookbook-python.ion.getting-binary)
+ [

### Mendapatkan dump teks Ion
](#cookbook-python.ion.getting-text)

### Mengimpor modul Ion
<a name="cookbook-python.ion.import"></a>

```
import amazon.ion.simpleion as simpleion
```

### Membuat tipe Ion
<a name="cookbook-python.ion.creating-types"></a>

Contoh kode berikut membuat objek Ion dari teks Ion.

```
ion_text = '{GovId: "TOYENC486FH", FirstName: "Brent"}'
ion_obj = simpleion.loads(ion_text)

print(ion_obj['GovId']) # prints TOYENC486FH
print(ion_obj['Name']) # prints Brent
```

Contoh kode berikut membuat objek Ion dari Python`dict`.

```
a_dict = { 'GovId': 'TOYENC486FH',
           'FirstName': "Brent"
         }
ion_obj = simpleion.loads(simpleion.dumps(a_dict))

print(ion_obj['GovId']) # prints TOYENC486FH
print(ion_obj['FirstName']) # prints Brent
```

### Mendapatkan dump biner Ion
<a name="cookbook-python.ion.getting-binary"></a>

```
# ion_obj is an Ion struct
print(simpleion.dumps(ion_obj)) # b'\xe0\x01\x00\xea\xee\x97\x81\x83\xde\x93\x87\xbe\x90\x85GovId\x89FirstName\xde\x94\x8a\x8bTOYENC486FH\x8b\x85Brent'
```

### Mendapatkan dump teks Ion
<a name="cookbook-python.ion.getting-text"></a>

```
# ion_obj is an Ion struct
print(simpleion.dumps(ion_obj, binary=False)) # prints $ion_1_0 {GovId:'TOYENC486FH',FirstName:"Brent"}
```

Untuk informasi selengkapnya tentang bekerja dengan 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)