Prérequis Étape 1 : Installation du pilote Étape 2 : Importer les packages Étape 3 : Initialiser le pilote Étape 4 : Création d'une table et d'un index Étape 5 : Insertion d'un document Étape 6 : Interroger le document Étape 7 : mise à jour du document Étape 8 : Rechercher le document mis à jour Étape 9 : Suppression de la table Exécution de l'application complète

Pilote Amazon QLDB pour Go — Tutoriel de démarrage rapide

Dans ce tutoriel, vous apprendrez comment configurer une application simple à l'aide de la dernière version du pilote Amazon QLDB pour Go. Ce guide inclut les étapes d'installation du pilote et des exemples de code court des opérations de base de création, lecture, mise à jour et suppression (CRUD).

Rubriques

Prérequis
Étape 1 : Installation du pilote
Étape 2 : Importer les packages
Étape 3 : Initialiser le pilote
Étape 4 : Création d'une table et d'un index
Étape 5 : Insertion d'un document
Étape 6 : Interroger le document
Étape 7 : mise à jour du document
Étape 8 : Rechercher le document mis à jour
Étape 9 : Suppression de la table
Exécution de l'application complète

Prérequis

Avant de commencer, veillez à exécuter les actions suivantes :

Complétez le pilotePrérequis for the Go, si vous ne l'avez déjà fait. Cela inclut l'inscriptionAWS, l'octroi d'un accès programmatique pour le développement et l'installation de Go.
Créez un registre nomméquick-start.

Pour savoir comment créer un registre, consultezOpérations de base pour les registres Amazon QLDB ouÉtape 1 : Créer un nouveau registre dans Prise en main de la console.

Étape 1 : Installation du pilote

Assurez-vous que votre projet utilise des modules Go pour installer les dépendances du projet.

Dans le répertoire de votre projet, entrez lago get commande suivante.


$ go get -u github.com/awslabs/amazon-qldb-driver-go/v3/qldbdriver

L'installation du pilote installe également ses dépendances, notamment les packages AWS SDK for Gov2 et Amazon Ion.

Étape 2 : Importer les packages

Importez lesAWS packages suivants.


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"
)

Étape 3 : Initialiser le pilote

Initialisez une instance du pilote qui se connecte au registre nomméquick-start.


cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
  panic(err)
}

qldbSession := qldbsession.NewFromConfig(cfg, func(options *qldbsession.Options) {
    options.Region = "us-east-1"
})
driver, err := qldbdriver.New(
    "quick-start",
    qldbSession,
    func(options *qldbdriver.DriverOptions) {
        options.LoggerVerbosity = qldbdriver.LogInfo
    })
if err != nil {
    panic(err)
}

defer driver.Shutdown(context.Background())

Note

Dans cet exemple de code, remplacez us-east-1 par l'Région AWSendroit où vous avez créé votre registre.

Étape 4 : Création d'une table et d'un index

L'exemple de code suivant montre comment exécuterCREATE TABLE lesCREATE INDEX instructions.


_, 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)
}

Ce code crée une table nomméePeople et indexe lesage champsfirstName et de cette table. Les index sont nécessaires pour optimiser les performances des requêtes et contribuer à limiter les exceptions de conflit liées au contrôle optimiste de la concurrence (OCC).

Étape 5 : Insertion d'un document

Les exemples de code suivants montrent comment exécuter uneINSERT instruction. QLDB prend en charge le langage de requête PartiQL (compatible SQL) et le format de données Amazon Ion (surensemble de JSON).

Utilisation de PartiQL littéral

Le code suivant insère un document dans laPeople table à l'aide d'une instruction PartiQL littérale de chaîne.


_, 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)
}

Utilisation des types de données Ion

À l'instar du package JSON intégré de Go, vous pouvez regrouper et dégrouper les types de données Go vers et depuis Ion.

Supposons que vous avez la structure Go suivante nomméePerson.


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

Créez une instance de Person.
```
person := Person{"John", "Doe", 54}
```
Le pilote gèreperson pour vous une représentation textuelle codée par ions de.

Important
Pour que Marshal et Unmarshal fonctionnent correctement, les noms des champs de la structure de données Go doivent être exportés (première lettre en majuscule).
Transmettez l'personinstance à laExecute méthode de la transaction.
```
_, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    return txn.Execute("INSERT INTO People ?", person)
})
if err != nil {
    panic(err)
}
```
Cet exemple utilise un point d'interrogation (?) comme espace réservé variable pour transmettre les informations du document à l'instruction. Lorsque vous utilisez des espaces réservés, vous devez transmettre une valeur de texte codée par ions.
Astuce
Pour insérer plusieurs documents à l'aide d'une seuleINSERT instruction, vous pouvez transmettre un paramètre de type list à l'instruction comme suit.
```
// people is a list
txn.Execute("INSERT INTO People ?", people)
```
Vous ne placez pas l'espace réservé à la variable (?) entre crochets (<<...>>) lorsque vous transmettez une liste. Dans les instructions manuelles de PartiQL, les crochets doubles indiquent une collection non ordonnée appelée sac.

Étape 6 : Interroger le document

L'exemple de code suivant montre comment exécuter uneSELECT instruction.


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

Cet exemple interroge votre document à partir duPeople tableau, suppose que le jeu de résultats n'est pas vide et renvoie votre document à partir du résultat.

Étape 7 : mise à jour du document

L'exemple de code suivant montre comment exécuter uneUPDATE instruction.


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

Étape 8 : Rechercher le document mis à jour

L'exemple de code suivant interroge laPeople table parfirstName et renvoie tous les documents du jeu de résultats.


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

Étape 9 : Suppression de la table

L'exemple de code suivant montre comment exécuter uneDROP TABLE instruction.


_, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
    return txn.Execute("DROP TABLE People")
})
if err != nil {
    panic(err)
}

Exécution de l'application complète

L'exemple de code suivant représente la version complète de l'application. Au lieu de suivre les étapes précédentes individuellement, vous pouvez également copier et exécuter cet exemple de code du début à la fin. Cette application montre certaines opérations CRUD de base sur le registre nomméquick-start.

Note

Avant d'exécuter ce code, assurez-vous qu'aucune table active n'est déjà nomméePeople dans lequick-start registre.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Go Driver

Référence de livre de recettes

Pilote Amazon QLDB pour Go — Tutoriel de démarrage rapide

Rubriques

Prérequis

Étape 1 : Installation du pilote

Étape 2 : Importer les packages

Étape 3 : Initialiser le pilote

Note

Étape 4 : Création d'une table et d'un index

Étape 5 : Insertion d'un document

Utilisation de PartiQL littéral

Utilisation des types de données Ion

Important

Astuce

Étape 6 : Interroger le document

Étape 7 : mise à jour du document

Étape 8 : Rechercher le document mis à jour

Étape 9 : Suppression de la table

Exécution de l'application complète

Note