Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon QLDB-Treiber für Go
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Um mit Daten in Ihrem Ledger zu arbeiten, können Sie von Ihrer Go-Anwendung aus mithilfe eines bereitgestellten Treibers eine AWS Verbindung zu Amazon QLDB herstellen. In den folgenden Themen werden die ersten Schritte mit dem QLDB-Treiber für Go beschrieben.
**Topics**
+ [Ressourcen für Treiber](#getting-started.golang.resources)
+ [Voraussetzungen](#getting-started.golang.prereqs)
+ [Installation](#getting-started.golang.install)
+ [Schnellstart-Tutorial](driver-quickstart-golang.md)
+ [Referenz zum Kochbuch](driver-cookbook-golang.md)
## Ressourcen für Treiber
Weitere Informationen zu den vom Go-Treiber unterstützten Funktionen finden Sie in den folgenden Ressourcen:
+ [API-Referenz: [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)
+ [Treiber-Quellcode () GitHub](https://github.com/awslabs/amazon-qldb-driver-go)
+ [Amazon Ion Cookbook](http://amzn.github.io/ion-docs/guides/cookbook.html)
## Voraussetzungen
Bevor Sie mit dem QLDB-Treiber für Go beginnen, müssen Sie Folgendes tun:
1. Folgen Sie den Anweisungen zur AWS Einrichtung unter. [Zugreifen auf Amazon QLDB](accessing.md) Diese umfasst die folgenden Funktionen:
1. Melde dich an für AWS.
1. Erstellen Sie einen Benutzer mit den entsprechenden QLDB-Berechtigungen.
1. Gewähren Sie programmatischen Zugriff für die Entwicklung.
1. (Optional) Installieren Sie eine integrierte Entwicklungsumgebung (IDE) Ihrer Wahl. Eine Liste der häufig IDEs für Go verwendeten Plugins finden Sie unter [Editor-Plugins und IDEs](https://golang.org/doc/editors.html) auf der Go-Website.
1. Laden Sie eine der folgenden Versionen von Go von der [Go-Download-Website herunter und installieren Sie](https://golang.org/dl/) sie:
+ **1.15 oder höher** — QLDB-Treiber für Go v3
+ **1.14** — QLDB-Treiber für Go v1 oder v2
1. Konfigurieren Sie die Entwicklungsumgebung für das [AWS SDK für Go](https://aws.amazon.com/sdk-for-go):
1. Richten Sie Ihre Anmeldeinformationen ein. AWS Wir empfehlen, eine gemeinsame Anmeldeinformationsdatei zu erstellen.
Eine Anleitung dazu finden Sie im *AWS SDK für Go Entwicklerhandbuch* [unter Angeben von Anmeldeinformationen](https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/#specifying-credentials).
1. Stellen Sie Ihre Standardeinstellung ein AWS-Region. Wie das geht, erfahren Sie unter [Spezifizieren von AWS-Region](https://aws.github.io/aws-sdk-go-v2/docs/configuring-sdk/#specifying-the-aws-region).
Eine vollständige Liste der verfügbaren Regionen finden Sie unter [Amazon QLDB-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/qldb.html) in der. *Allgemeine AWS-Referenz*
Als Nächstes können Sie eine einfache Beispielanwendung einrichten und kurze Codebeispiele ausführen — oder Sie können den Treiber in einem vorhandenen Go-Projekt installieren.
+ Um den QLDB-Treiber und den AWS SDK für Go in einem vorhandenen Projekt zu installieren, fahren Sie mit fort. [Installation](#getting-started.golang.install)
+ Informationen zum Einrichten eines Projekts und zur Ausführung kurzer Codebeispiele, die grundlegende Datentransaktionen in einem Ledger veranschaulichen, finden Sie unter. [Schnellstart-Tutorial](driver-quickstart-golang.md)
## Installation
[Der QLDB-Treiber für Go ist Open Source im GitHub Repository awslabs/. amazon-qldb-driver-go](http://github.com/awslabs/amazon-qldb-driver-go) QLDB unterstützt die folgenden Treiberversionen und ihre Go-Abhängigkeiten.
****
| Treiberversion | Go-Version | Status | Neuestes Veröffentlichungsdatum |
| --- | --- | --- | --- |
| [1.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/qldbdriver) | 1.14 oder später | Produktionsfreigabe | 16. Juni 2021 |
| [2.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v2/qldbdriver) | 1.14 oder später | Produktionsfreigabe | 21. Juli 2021 |
| [3.x](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver) | 1.15 oder später | Produktionsfreigabe | 10. November 2022 |
**Um den Treiber zu installieren**
1. Stellen Sie sicher, dass Ihr Projekt [Go-Module](https://blog.golang.org/using-go-modules) verwendet, um Projektabhängigkeiten zu installieren.
1. Geben Sie in Ihrem Projektverzeichnis den folgenden `go get` Befehl ein.
------
#### [ 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
```
------
Durch die Installation des Treibers werden auch seine Abhängigkeiten installiert, einschließlich der Pakete [AWS SDK für Go](https://github.com/aws/aws-sdk-go)oder [AWS SDK für Go v2](https://github.com/aws/aws-sdk-go-v2) und [Amazon Ion](https://github.com/amzn/ion-go).
Kurze Codebeispiele für die Ausführung grundlegender Datentransaktionen in einem Ledger finden Sie unter[Referenz zum Kochbuch](driver-cookbook-golang.md).
# Amazon QLDB-Treiber für Go — Schnellstartanleitung
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
In diesem Tutorial erfahren Sie, wie Sie eine einfache Anwendung mit der neuesten Version des Amazon QLDB-Treibers für Go einrichten. Dieses Handbuch enthält Schritte zum Installieren des Treibers und kurze Codebeispiele für grundlegende CRUD-Vorgänge (*Create, Read, Update und Delete*).
**Topics**
+ [Voraussetzungen](#driver-quickstart-golang.prereqs)
+ [Schritt 1: Installieren Sie den Treiber](#driver-quickstart-golang.install)
+ [Schritt 2: Importieren Sie die Pakete](#driver-quickstart-golang.import)
+ [Schritt 3: Initialisieren Sie den Treiber](#driver-quickstart-golang.initialize)
+ [Schritt 4: Erstellen Sie eine Tabelle und einen Index](#driver-quickstart-golang.create-table-index)
+ [Schritt 5: Fügen Sie ein Dokument ein](#driver-quickstart-golang.insert)
+ [Schritt 6: Fragen Sie das Dokument ab](#driver-quickstart-golang.query)
+ [Schritt 7: Aktualisieren Sie das Dokument](#driver-quickstart-golang.update)
+ [Schritt 8: Fragen Sie das aktualisierte Dokument ab](#driver-quickstart-golang.query-2)
+ [Schritt 9: Löschen Sie die Tabelle](#driver-quickstart-golang.drop-table)
+ [Ausführen der vollständigen Anwendung](#driver-quickstart-golang.complete)
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass die folgende Voraussetzung erfüllt ist:
1. Füllen Sie den [Voraussetzungen](getting-started.golang.md#getting-started.golang.prereqs) For the Go-Treiber aus, falls Sie dies noch nicht getan haben. Dazu gehören die Registrierung für Go AWS, die Gewährung des programmatischen Zugriffs für die Entwicklung und die Installation von Go.
1. Ledger mit dem Namen `quick-start` erstellen.
Informationen zum Erstellen eines Ledgers finden Sie unter [Grundlegende Operationen für Amazon QLDB-Ledger](ledger-management.basics.md) oder [Schritt 1: Erstellen Sie ein neues Hauptbuch](getting-started-step-1.md) in *Erste Schritte mit der Konsole*.
## Schritt 1: Installieren Sie den Treiber
Stellen Sie sicher, dass Ihr Projekt [Go-Module](https://blog.golang.org/using-go-modules) verwendet, um Projektabhängigkeiten zu installieren.
Geben Sie in Ihrem Projektverzeichnis den folgenden `go get` Befehl ein.
```
$ go get -u github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver
```
Durch die Installation des Treibers werden auch seine Abhängigkeiten installiert, einschließlich der Pakete [AWS SDK für Go v2](https://github.com/aws/aws-sdk-go-v2) und [Amazon Ion](https://github.com/amzn/ion-go).
## Schritt 2: Importieren Sie die Pakete
Importieren Sie die folgenden AWS Pakete.
```
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"
)
```
## Schritt 3: Initialisieren Sie den Treiber
Initialisieren Sie eine Instance des Treibers, der eine Verbindung mit dem Ledger `quick-start` herstellt.
```
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())
```
**Anmerkung**
Ersetzen Sie es in diesem Codebeispiel durch den Ort, AWS-Region an *us-east-1* dem Sie Ihr Ledger erstellt haben.
## Schritt 4: Erstellen Sie eine Tabelle und einen Index
Im folgenden Codebeispiel wird veranschaulicht, wie `CREATE TABLE`- und `CREATE INDEX`-Anweisungen ausgeführt werden.
```
_, 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)
}
```
Dieser Code erstellt eine Tabelle mit dem Namen `People` und Indizes für die `age` Felder `firstName` und in dieser Tabelle. [Indizes](ql-reference.create-index.md) sind erforderlich, um die Abfrageleistung zu optimieren und zur Begrenzung von Konfliktausnahmen bei der [optimistischen Parallelitätssteuerung (OCC](concurrency.md)) beizutragen.
## Schritt 5: Fügen Sie ein Dokument ein
Die folgenden Codebeispiele zeigen, wie eine `INSERT` Anweisung ausgeführt wird. QLDB unterstützt die [PartiQL-Abfragesprache](ql-reference.md) (SQL-kompatibel) und das [Amazon Ion-Datenformat](ion.md) (Superset von JSON).
### Literales PartiQL verwenden
Der folgende Code fügt ein Dokument mithilfe einer partiQL-Anweisung mit einem Zeichenfolgenliteral in die `People` Tabelle ein.
```
_, 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)
}
```
### Verwendung von Ion-Datentypen
Ähnlich wie beim integrierten [JSON-Paket](https://golang.org/pkg/encoding/json/) von Go können Sie Go-Datentypen zu und von Ion weiterleiten und ihr Marshalling rückgängig machen.
1. Angenommen, Sie haben die folgende Go-Struktur benannt. `Person`
```
type Person struct {
FirstName string `ion:"firstName"`
LastName string `ion:"lastName"`
Age int `ion:"age"`
}
```
1. Erstellen Sie eine Instance von `Person`.
```
person := Person{"John", "Doe", 54}
```
Der Treiber stellt eine ION-kodierte Textdarstellung von für Sie bereit. `person`
**Wichtig**
Damit Marshal und Unmarshal ordnungsgemäß funktionieren, müssen die Feldnamen der Go-Datenstruktur exportiert werden (erster Buchstabe in Großbuchstaben).
1. Übergeben Sie die `person` Instanz an die Methode der Transaktion. `Execute`
```
_, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("INSERT INTO People ?", person)
})
if err != nil {
panic(err)
}
```
In diesem Beispiel wird ein Fragezeichen (`?`) als Variablenplatzhalter verwendet, um die Dokumentinformationen an die Anweisung zu übergeben. Wenn Sie Platzhalter verwenden, müssen Sie einen ION-codierten Textwert übergeben.
**Tipp**
Um mehrere Dokumente mithilfe einer einzigen [INSERT](ql-reference.insert.md) Anweisung einzufügen, können Sie der Anweisung wie folgt einen Parameter vom Typ [list](driver-working-with-ion.md#driver-ion-list) übergeben.
```
// people is a list
txn.Execute("INSERT INTO People ?", people)
```
Sie setzen den Platzhalter für die Variable (`?`) nicht in doppelte spitze Klammern (`<<...>>`), wenn Sie eine Liste übergeben. *In manuellen PartiQL-Anweisungen bezeichnen doppelte spitze Klammern eine ungeordnete Sammlung, die als Tasche bezeichnet wird.*
## Schritt 6: Fragen Sie das Dokument ab
Im folgenden Codebeispiel wird veranschaulicht, wie eine `SELECT`-Anweisung ausgeführt wird.
```
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")
}
```
In diesem Beispiel wird Ihr Dokument anhand der `People` Tabelle abgefragt, wobei davon ausgegangen wird, dass die Ergebnismenge nicht leer ist, und gibt Ihr Dokument anhand des Ergebnisses zurück.
## Schritt 7: Aktualisieren Sie das Dokument
Im folgenden Codebeispiel wird veranschaulicht, wie eine `UPDATE`-Anweisung ausgeführt wird.
```
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)
}
```
## Schritt 8: Fragen Sie das aktualisierte Dokument ab
Das folgende Codebeispiel fragt die `People` Tabelle nach `firstName` ab und gibt alle Dokumente in der Ergebnismenge zurück.
```
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")
}
```
## Schritt 9: Löschen Sie die Tabelle
Im folgenden Codebeispiel wird veranschaulicht, wie eine `DROP TABLE`-Anweisung ausgeführt wird.
```
_, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("DROP TABLE People")
})
if err != nil {
panic(err)
}
```
## Ausführen der vollständigen Anwendung
Das folgende Codebeispiel ist die vollständige Version der Anwendung. Anstatt die vorherigen Schritte einzeln auszuführen, können Sie dieses Codebeispiel auch kopieren und von Anfang bis Ende ausführen. Diese Anwendung demonstriert einige grundlegende CRUD-Operationen für den Ledger namens `quick-start`.
**Anmerkung**
Bevor Sie diesen Code ausführen, stellen Sie sicher, dass Sie noch keine aktive Tabelle mit dem Namen `People` im `quick-start`-Ledger besitzen.
```
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)
}
}
```
# Amazon QLDB-Treiber für Go — Kochbuch-Referenz
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Dieses Referenzhandbuch zeigt allgemeine Anwendungsfälle des Amazon QLDB-Treibers für Go. Es enthält Go-Codebeispiele, die zeigen, wie der Treiber verwendet wird, um grundlegende *Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge* (CRUD) auszuführen. Es enthält auch Codebeispiele für die Verarbeitung von Amazon Ion-Daten. Darüber hinaus werden in diesem Leitfaden bewährte Verfahren zur idempotenten Gestaltung von Transaktionen und zur Implementierung von Eindeutigkeitsbeschränkungen beschrieben.
**Anmerkung**
Gegebenenfalls haben einige Anwendungsfälle unterschiedliche Codebeispiele für jede unterstützte Hauptversion des QLDB-Treibers für Go.
**Contents**
+ [Der Treiber wird importiert](#cookbook-golang.importing)
+ [Der Treiber wird instanziiert](#cookbook-golang.instantiating)
+ [CRUD-Operationen](#cookbook-golang.crud)
+ [Erstellen von Tabellen](#cookbook-golang.crud.creating-tables)
+ [Erstellen von Indizes](#cookbook-golang.crud.creating-indexes)
+ [Dokumente lesen](#cookbook-golang.crud.reading)
+ [Verwenden von Abfrageparametern](#cookbook-golang.reading-using-params)
+ [Dokumente werden eingefügt](#cookbook-golang.crud.inserting)
+ [Einfügen mehrerer Dokumente in eine Anweisung](#cookbook-golang.crud.inserting.multiple)
+ [Dokumente werden aktualisiert](#cookbook-golang.crud.updating)
+ [Dokumente löschen](#cookbook-golang.crud.deleting)
+ [Ausführung mehrerer Anweisungen in einer Transaktion](#cookbook-golang.crud.multi-statement)
+ [Logik für Wiederholversuche](#cookbook-golang.crud.retry-logic)
+ [Implementierung von Eindeutigkeitsbeschränkungen](#cookbook-golang.crud.uniqueness-constraints)
+ [Arbeiten mit Amazon Ion](#cookbook-golang.ion)
+ [Das Ion-Modul importieren](#cookbook-golang.ion.import)
+ [Ion-Typen erstellen](#cookbook-golang.ion.creating-types)
+ [Binärdatei von Ion herunterladen](#cookbook-golang.ion.getting-binary)
+ [Ion-Text abrufen](#cookbook-golang.ion.getting-text)
## Der Treiber wird importiert
Das folgende Codebeispiel importiert den Treiber und andere erforderliche AWS Pakete.
------
#### [ 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"
)
```
------
**Anmerkung**
In diesem Beispiel wird auch das Amazon Ion-Paket (`amzn/ion-go/ion`) importiert. Sie benötigen dieses Paket, um Ion-Daten zu verarbeiten, wenn Sie einige Datenoperationen in dieser Referenz ausführen. Weitere Informationen hierzu finden Sie unter [Arbeiten mit Amazon Ion](#cookbook-golang.ion).
## Der Treiber wird instanziiert
Im folgenden Codebeispiel wird eine Instanz des Treibers erstellt, die eine Verbindung zu einem bestimmten Ledgernamen in einem angegebenen Verzeichnis herstellt. AWS-Region
------
#### [ 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)
}
```
------
## CRUD-Operationen
QLDB führt *Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge* (CRUD) als Teil einer Transaktion aus.
**Warnung**
Als bewährte Methode sollten Sie Ihre Schreibtransaktionen strikt idempotent gestalten.
**Machen Sie Transaktionen idempotent**
Wir empfehlen, Schreibtransaktionen idempotent zu machen, um unerwartete Nebenwirkungen bei Wiederholungsversuchen zu vermeiden. Eine Transaktion ist *idempotent*, wenn sie mehrfach ausgeführt werden kann und jedes Mal identische Ergebnisse liefert.
Stellen Sie sich zum Beispiel eine Transaktion vor, die ein Dokument in eine Tabelle mit dem Namen einfügt. `Person` Bei der Transaktion sollte zunächst geprüft werden, ob das Dokument bereits in der Tabelle vorhanden ist. Ohne diese Prüfung könnte die Tabelle am Ende doppelte Dokumente enthalten.
Nehmen wir an, dass QLDB die Transaktion auf der Serverseite erfolgreich festschreibt, der Client jedoch während des Wartens auf eine Antwort eine Zeitüberschreitung ausführt. Wenn die Transaktion nicht idempotent ist, könnte dasselbe Dokument bei einem erneuten Versuch mehrmals eingefügt werden.
**Verwendung von Indizes, um vollständige Tabellenscans zu vermeiden**
Es wird außerdem empfohlen, Anweisungen mit einer `WHERE` Prädikatklausel unter Verwendung eines *Gleichheitsoperators* für ein indiziertes Feld oder eine Dokument-ID auszuführen, z. B. oder. `WHERE indexedField = 123` `WHERE indexedField IN (456, 789)` Ohne diese indizierte Suche muss QLDB einen Tabellenscan durchführen, was zu Transaktions-Timeouts oder Konflikten mit *optimistischer Parallelitätskontrolle* (OCC) führen kann.
Weitere Informationen zu OCC finden Sie unter [Amazon QLDB-Parallelitätsmodell](concurrency.md).
**Implizit erstellte Transaktionen**
Die Funktion [QLDBDriver.Execute](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#QLDBDriver.Execute) akzeptiert eine Lambda-Funktion, die eine Instanz von [Transaction](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#Transaction) empfängt, mit der Sie Anweisungen ausführen können. Die Instanz von `Transaction` umschließt eine implizit erstellte Transaktion.
Sie können Anweisungen innerhalb der Lambda-Funktion ausführen, indem Sie die Funktion verwenden. `Transaction.Execute` Der Treiber schreibt die Transaktion implizit fest, wenn die Lambda-Funktion zurückkehrt.
In den folgenden Abschnitten wird gezeigt, wie grundlegende CRUD-Operationen ausgeführt, eine benutzerdefinierte Wiederholungslogik angegeben und Eindeutigkeitsbeschränkungen implementiert werden.
**Contents**
+ [Erstellen von Tabellen](#cookbook-golang.crud.creating-tables)
+ [Erstellen von Indizes](#cookbook-golang.crud.creating-indexes)
+ [Dokumente lesen](#cookbook-golang.crud.reading)
+ [Verwenden von Abfrageparametern](#cookbook-golang.reading-using-params)
+ [Dokumente werden eingefügt](#cookbook-golang.crud.inserting)
+ [Einfügen mehrerer Dokumente in eine Anweisung](#cookbook-golang.crud.inserting.multiple)
+ [Dokumente werden aktualisiert](#cookbook-golang.crud.updating)
+ [Dokumente löschen](#cookbook-golang.crud.deleting)
+ [Ausführung mehrerer Anweisungen in einer Transaktion](#cookbook-golang.crud.multi-statement)
+ [Logik für Wiederholversuche](#cookbook-golang.crud.retry-logic)
+ [Implementierung von Eindeutigkeitsbeschränkungen](#cookbook-golang.crud.uniqueness-constraints)
### Erstellen von Tabellen
```
result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("CREATE TABLE Person")
})
```
### Erstellen von Indizes
```
result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("CREATE INDEX ON Person(GovId)")
})
```
### Dokumente lesen
```
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)
}
```
#### Verwenden von Abfrageparametern
Im folgenden Codebeispiel wird ein systemeigener Abfrageparameter verwendet.
```
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)
}
```
Das folgende Codebeispiel verwendet mehrere Abfrageparameter.
```
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)
}
```
Das folgende Codebeispiel verwendet eine Liste von Abfrageparametern.
```
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)
}
```
**Anmerkung**
Wenn Sie eine Abfrage ohne indizierte Suche ausführen, wird ein vollständiger Tabellenscan aufgerufen. In diesem Beispiel empfehlen wir, einen [Index](ql-reference.create-index.md) für das `GovId` Feld zu verwenden, um die Leistung zu optimieren. Ohne aktivierten `GovId` Index können Abfragen eine höhere Latenz haben und auch zu OCC-Konfliktausnahmen oder Transaktions-Timeouts führen.
### Dokumente werden eingefügt
Im folgenden Codebeispiel werden systemeigene Datentypen eingefügt.
```
_, 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
})
```
Diese Transaktion fügt ein Dokument in die `Person` Tabelle ein. Vor dem Einfügen wird zunächst geprüft, ob das Dokument bereits in der Tabelle vorhanden ist. **Diese Prüfung macht die Transaktion ihrem Wesen nach idempotent.** Selbst wenn Sie diese Transaktion mehrmals ausführen, hat sie keine unbeabsichtigten Nebenwirkungen.
**Anmerkung**
In diesem Beispiel empfehlen wir, einen Index für das `GovId` Feld zu verwenden, um die Leistung zu optimieren. Ohne aktivierten `GovId` Index können Anweisungen eine längere Latenz haben und auch zu OCC-Konfliktausnahmen oder Transaktions-Timeouts führen.
#### Einfügen mehrerer Dokumente in eine Anweisung
Um mehrere Dokumente mit einer einzigen [INSERT](ql-reference.insert.md) Anweisung einzufügen, können Sie der Anweisung wie folgt einen Parameter vom Typ [list](driver-working-with-ion.md#driver-ion-list) übergeben.
```
// people is a list
txn.Execute("INSERT INTO People ?", people)
```
Sie setzen den Platzhalter für die Variable (`?`) nicht in doppelte spitze Klammern (`<<...>>`), wenn Sie eine Liste übergeben. *In manuellen PartiQL-Anweisungen bezeichnen doppelte spitze Klammern eine ungeordnete Sammlung, die als Tasche bezeichnet wird.*
### Dokumente werden aktualisiert
Im folgenden Codebeispiel werden systemeigene Datentypen verwendet.
```
result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", "John", "TOYENC486FH")
})
```
**Anmerkung**
In diesem Beispiel empfehlen wir, einen Index für das `GovId` Feld zu verwenden, um die Leistung zu optimieren. Ohne aktivierten `GovId` Index können Anweisungen eine längere Latenz haben und auch zu OCC-Konfliktausnahmen oder Transaktions-Timeouts führen.
### Dokumente löschen
Im folgenden Codebeispiel werden systemeigene Datentypen verwendet.
```
result, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
return txn.Execute("DELETE FROM Person WHERE GovId = ?", "TOYENC486FH")
})
```
**Anmerkung**
In diesem Beispiel empfehlen wir, einen Index für das `GovId` Feld zu verwenden, um die Leistung zu optimieren. Ohne aktivierten `GovId` Index können Anweisungen eine längere Latenz haben und auch zu OCC-Konfliktausnahmen oder Transaktions-Timeouts führen.
### Ausführung mehrerer Anweisungen in einer Transaktion
```
// 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
}
```
### Logik für Wiederholversuche
Die `Execute` Treiberfunktion verfügt über einen integrierten Wiederholungsmechanismus, der die Transaktion erneut versucht, wenn eine Ausnahme auftritt, die erneut versucht werden kann (z. B. Timeouts oder OCC-Konflikte). Die maximale Anzahl von Wiederholungsversuchen und die Backoff-Strategie sind konfigurierbar.
Das Standardlimit für Wiederholungsversuche ist`4`, und die Standard-Backoff-Strategie basiert [ExponentialBackoffStrategy](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#ExponentialBackoffStrategy)auf einer Basis von Millisekunden. `10` Sie können die Wiederholungsrichtlinie pro Treiberinstanz und auch pro Transaktion festlegen, indem Sie eine Instanz von verwenden. [RetryPolicy](https://pkg.go.dev/github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver#RetryPolicy)
Das folgende Codebeispiel spezifiziert die Wiederholungslogik mit einem benutzerdefinierten Wiederholungslimit und einer benutzerdefinierten Backoff-Strategie für eine Instanz des Treibers.
```
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)
}
}
```
Das folgende Codebeispiel spezifiziert die Wiederholungslogik mit einem benutzerdefinierten Wiederholungslimit und einer benutzerdefinierten Backoff-Strategie für eine bestimmte anonyme Funktion. Die `SetRetryPolicy` Funktion überschreibt die Wiederholungsrichtlinie, die für die Treiberinstanz festgelegt ist.
```
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")
})
}
```
### Implementierung von Eindeutigkeitsbeschränkungen
QLDB unterstützt keine eindeutigen Indizes, aber Sie können dieses Verhalten in Ihrer Anwendung implementieren.
Angenommen, Sie möchten eine Eindeutigkeitsbeschränkung für das `GovId` Feld in der Tabelle implementieren. `Person` Zu diesem Zweck können Sie eine Transaktion schreiben, die Folgendes tut:
1. Bestätigen Sie, dass die Tabelle keine vorhandenen Dokumente mit einem angegebenen Wert enthält`GovId`.
1. Fügt das Dokument ein, wenn die Assertion erfolgreich ist.
Wenn eine konkurrierende Transaktion gleichzeitig die Assertion besteht, wird nur eine der Transaktionen erfolgreich festgeschrieben. Die andere Transaktion schlägt mit einer OCC-Konfliktausnahme fehl.
Das folgende Codebeispiel zeigt, wie diese Eindeutigkeitsbeschränkungslogik implementiert wird.
```
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)
}
```
**Anmerkung**
In diesem Beispiel empfehlen wir, einen Index für das `GovId` Feld zu verwenden, um die Leistung zu optimieren. Ohne aktivierten `GovId` Index können Anweisungen eine längere Latenz haben und auch zu OCC-Konfliktausnahmen oder Transaktions-Timeouts führen.
## Arbeiten mit Amazon Ion
In den folgenden Abschnitten wird gezeigt, wie das Amazon Ion-Modul zur Verarbeitung von Ion-Daten verwendet wird.
**Contents**
+ [Das Ion-Modul importieren](#cookbook-golang.ion.import)
+ [Ion-Typen erstellen](#cookbook-golang.ion.creating-types)
+ [Binärdatei von Ion herunterladen](#cookbook-golang.ion.getting-binary)
+ [Ion-Text abrufen](#cookbook-golang.ion.getting-text)
### Das Ion-Modul importieren
```
import "github.com/amzn/ion-go/ion"
```
### Ion-Typen erstellen
Die Ion-Bibliothek für Go unterstützt derzeit das Document Object Model (DOM) nicht, sodass Sie keine Ion-Datentypen erstellen können. Aber Sie können zwischen systemeigenen Go-Typen und Ion-Binärdateien hin- und herschalten, wenn Sie mit QLDB arbeiten.
### Binärdatei von Ion herunterladen
```
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]
```
### Ion-Text abrufen
```
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"}
```
Weitere Informationen zu Ion finden Sie in der [Amazon Ion-Dokumentation](http://amzn.github.io/ion-docs/) unter GitHub. Weitere Codebeispiele für die Arbeit mit Ion in QLDB finden Sie unter. [Arbeiten mit Amazon Ion-Datentypen in Amazon QLDB](driver-working-with-ion.md)