Voraussetzungen Schritt 1: Installieren des Treibers Schritt 2: Import der Pakete Schritt 3: Initialisieren des Treibers Schritt 4: Erstellen einer Tabelle und eines Index Schritt 5: Einfügen eines -Dokuments Schritt 6: Abfragen des -Dokuments Schritt 7: Aktualisieren des -Dokuments Schritt 8: Das aktualisierte Dokument abfragen Schritt 9: Löschen der Tabelle Ausführen der vollständigen Anwendung

Amazon QLDB-Treiber für Go — Schnellstart-Tutorial

In diesem Tutorial erfahren Sie, wie eine einfache Anwendung mit der neuesten Version des Amazon-QLDB-Treibers für Go geschehen. Dieses Handbuch enthält Schritte zum Installieren des Treibers und kurze Codebeispiele für grundlegende CRUD-Vorgänge (Create, Read, Update und Delete).

Themen

Voraussetzungen
Schritt 1: Installieren des Treibers
Schritt 2: Import der Pakete
Schritt 3: Initialisieren des Treibers
Schritt 4: Erstellen einer Tabelle und eines Index
Schritt 5: Einfügen eines -Dokuments
Schritt 6: Abfragen des -Dokuments
Schritt 7: Aktualisieren des -Dokuments
Schritt 8: Das aktualisierte Dokument abfragen
Schritt 9: Löschen der Tabelle
Ausführen der vollständigen Anwendung

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass die folgende Voraussetzung erfüllt ist:

Füllen des TreibersVoraussetzungen für den Go aus, falls noch geschehen geschehen geschehen geschehen geschehen. Dazu gehören die RegistrierungAWS, die Gewährung von programmatischem Zugriff für die Entwicklung und die Installation von Go.
Ledger mit dem Namen quick-start erstellen.

Informationen zum Erstellen eines Ledgers finden Sie unterGrundfunktionen für Amazon QLDB-Ledgers oderSchritt 1: Erstellen eines neuen Ledgers unter Erste Schritte mit der Konsole.

Schritt 1: Installieren des Treibers

Stellen Sie sicher, dass Ihr Projekt Go-Module verwendet, um Projektabhängigkeiten zu installieren.

Geben Sie in Ihrem Projektverzeichnis den folgendengo 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 for Gov2 und Amazon Ion.

Schritt 2: Import der Pakete

Importieren Sie die folgendenAWS 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 des Treibers

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 in diesem Codebeispiel us-east-1 durch den Ort,AWS-Region an dem Sie Ihr Ledger erstellt haben.

Schritt 4: Erstellen einer Tabelle und eines 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 NamenPeople und Indizes für dieage FelderfirstName und in dieser Tabelle. Indizes sind erforderlich, um die Abfrageleistung zu optimieren und dabei zu helfen, Konfliktausnahmen für Optimist Concurrency Control (OCC) zu begrenzen.

Schritt 5: Einfügen eines -Dokuments

Die folgenden Codebeispiele veranschaulichen, wie eineINSERT Anweisung ausgeführt wird. QLDB unterstützt die PartiQL-Abfragesprache (SQL-kompatibel) und das Amazon Ion-Datenformat (Superset von JSON).

Verwenden des literalen PartiQL

Der folgende Code fügt ein Dokument mithilfe einer partiQL-Anweisung im Zeichenkettenformat in diePeople 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)
}

Verwenden der Ionen-Datentypen

Ähnlich wie beim integrierten JSON-Paket von Go können Sie Go-Datentypen von und zu Ion marshalen und demarshalen.

Nehmen wir an, Sie haben die folgende Go-Struktur benanntPerson.


type Person struct {
    FirstName string `ion:"firstName"`
    LastName  string `ion:"lastName"`
    Age       int    `ion:"age"`
}

Erstellen Sie eine Instance von Person.
```
person := Person{"John", "Doe", 54}
```
Der Treiber stellt für Sie eine ionenkodierte Textdarstellung vonperson bereit.

Wichtig
Damit marshal und unmarshal ordnungsgemäß funktionieren, müssen die Feldnamen der Go-Datenstruktur exportiert werden (der erste Buchstabe wird großgeschrieben).
Übergeben Sie dieperson Instanz an dieExecute Methode der Transaktion.
```
_, 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 ionenkodierten Textwert übergeben.
Tipp
Um mehrere Dokumente mit einer einzigenINSERT Anweisung einzufügen, können Sie wie folgt einen Parameter vom Typ list an die Anweisung übergeben.
```
// people is a list
txn.Execute("INSERT INTO People ?", people)
```
Sie schließen den variablen Platzhalter (?) nicht in doppelte eckige Klammern (<<...>>) ein, wenn Sie eine Liste übergeben. In manuellen PartiQL-Anweisungen bezeichnen doppelte spitze Klammern eine ungeordnete Sammlung, die als Bag bezeichnet wird.

Schritt 6: Abfragen des -Dokuments

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 aus derPeople Tabelle abgefragt, es wird davon ausgegangen, dass die Ergebnismenge nicht leer ist, und gibt Ihr Dokument anhand des Ergebnisses zurück.

Schritt 7: Aktualisieren des -Dokuments

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: Das aktualisierte Dokument abfragen

Im folgenden Codebeispiel wird diePeople Tabelle vonfirstName abgefragt und alle Dokumente in der Ergebnismenge zurückgegeben.


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 der 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)
    }
}

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Wechseln Sie zum Fahrer.

Kochbuchreferenz

Amazon QLDB-Treiber für Go — Schnellstart-Tutorial

Themen

Voraussetzungen

Schritt 1: Installieren des Treibers

Schritt 2: Import der Pakete

Schritt 3: Initialisieren des Treibers

Anmerkung

Schritt 4: Erstellen einer Tabelle und eines Index

Schritt 5: Einfügen eines -Dokuments

Verwenden des literalen PartiQL

Verwenden der Ionen-Datentypen

Wichtig

Tipp

Schritt 6: Abfragen des -Dokuments

Schritt 7: Aktualisieren des -Dokuments

Schritt 8: Das aktualisierte Dokument abfragen

Schritt 9: Löschen der Tabelle

Ausführen der vollständigen Anwendung

Anmerkung