Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Driver Amazon QLDB per Go — Tutorial di avvio rapido
<a name="driver-quickstart-golang"></a>

**Importante**  
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).

In questo tutorial, imparerai come configurare una semplice applicazione utilizzando l'ultima versione del driver Amazon QLDB per Go. Questa guida include i passaggi per l'installazione del driver e brevi esempi in codice delle operazioni di base di *creazione, lettura, aggiornamento ed eliminazione* (CRUD).

**Topics**
+ [Prerequisiti](#driver-quickstart-golang.prereqs)
+ [Passaggio 1: installare il driver](#driver-quickstart-golang.install)
+ [Fase 2: Importazione dei pacchetti](#driver-quickstart-golang.import)
+ [Fase 3: Inizializzare il driver](#driver-quickstart-golang.initialize)
+ [Fase 4: Creare una tabella e un indice](#driver-quickstart-golang.create-table-index)
+ [Fase 5: Inserimento di un documento](#driver-quickstart-golang.insert)
+ [Fase 6: Interrogare il documento](#driver-quickstart-golang.query)
+ [Fase 7: Aggiornare il documento](#driver-quickstart-golang.update)
+ [Fase 8: Interrogare il documento aggiornato](#driver-quickstart-golang.query-2)
+ [Fase 9: Eliminare la tabella](#driver-quickstart-golang.drop-table)
+ [Esecuzione dell'applicazione completa](#driver-quickstart-golang.complete)

## Prerequisiti
<a name="driver-quickstart-golang.prereqs"></a>

Prima di iniziare, assicuratevi di fare quanto segue:

1. Completa il driver [Prerequisiti](getting-started.golang.md#getting-started.golang.prereqs) for the Go, se non l'hai già fatto. Ciò include la registrazione AWS, la concessione dell'accesso programmatico per lo sviluppo e l'installazione di Go.

1. Crea un libro mastro denominato. `quick-start`

   Per informazioni su come creare un registro, consulta [Operazioni di base per i registri Amazon QLDB](ledger-management.basics.md) o [Fase 1: Creare un nuovo libro contabile](getting-started-step-1.md) in *Guida introduttiva alla console*.

## Passaggio 1: installare il driver
<a name="driver-quickstart-golang.install"></a>

Assicurati che il tuo progetto utilizzi i [moduli Go](https://blog.golang.org/using-go-modules) per installare le dipendenze del progetto.

Nella directory del progetto, inserisci il seguente `go get` comando.

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

L'installazione del driver installa anche le sue dipendenze, inclusi i pacchetti [AWS SDK per Go v2 e](https://github.com/aws/aws-sdk-go-v2) [Amazon](https://github.com/amzn/ion-go) Ion.

## Fase 2: Importazione dei pacchetti
<a name="driver-quickstart-golang.import"></a>

Importa i seguenti AWS pacchetti.

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

## Fase 3: Inizializzare il driver
<a name="driver-quickstart-golang.initialize"></a>

Inizializza un'istanza del driver che si connette al registro denominato. `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())
```

**Nota**  
In questo esempio di codice, sostituiscilo *us-east-1* con il Regione AWS punto in cui hai creato il registro.

## Fase 4: Creare una tabella e un indice
<a name="driver-quickstart-golang.create-table-index"></a>

Il seguente esempio di codice mostra come eseguire le `CREATE INDEX` istruzioni `CREATE TABLE` e le istruzioni.

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

Questo codice crea una tabella `People` denominata e gli indici per i `age` campi `firstName` e in quella tabella. [Gli indici](ql-reference.create-index.md) sono necessari per ottimizzare le prestazioni delle query e aiutano a limitare le eccezioni ai conflitti OCC ([Optimistic Concurrency Control](concurrency.md)).

## Fase 5: Inserimento di un documento
<a name="driver-quickstart-golang.insert"></a>

I seguenti esempi di codice mostrano come eseguire un'`INSERT`istruzione. QLDB supporta il linguaggio di interrogazione [PartiQL](ql-reference.md) (compatibile con SQL) e il formato dati [Amazon](ion.md) Ion (superset di JSON).

### Usare PartiQl letterale
<a name="driver-quickstart-golang.insert.partiql"></a>

Il codice seguente inserisce un documento nella `People` tabella utilizzando un'istruzione PartiQL letterale a stringa.

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

### Utilizzo dei tipi di dati Ion
<a name="driver-quickstart-golang.insert.ion"></a>

Analogamente al [pacchetto JSON](https://golang.org/pkg/encoding/json/) integrato di Go, puoi eseguire il marshal e il unmarshal dei tipi di dati Go da e verso Ion.

1. Supponiamo di avere la seguente struttura Go denominata. `Person`

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

1. Creare un'istanza di `Person`.

   ```
   person := Person{"John", "Doe", 54}
   ```

   Il driver mostra una rappresentazione testuale con codifica ION di for you. `person`
**Importante**  
Affinché marshal e unmarshal funzionino correttamente, i nomi dei campi della struttura dati Go devono essere esportati (con la prima lettera maiuscola).

1. Passa l'istanza al metodo della transazione. `person` `Execute`

   ```
   _, err = driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) {
       return txn.Execute("INSERT INTO People ?", person)
   })
   if err != nil {
       panic(err)
   }
   ```

   Questo esempio utilizza un punto interrogativo (`?`) come segnaposto variabile per passare le informazioni del documento all'istruzione. Quando si utilizzano i segnaposto, è necessario passare un valore di testo con codifica ION.
**Suggerimento**  
Per inserire più documenti utilizzando una sola [INSERT](ql-reference.insert.md) istruzione, è possibile passare un parametro di tipo [elenco](driver-working-with-ion.md#driver-ion-list) all'istruzione nel modo seguente.  

   ```
   // people is a list
   txn.Execute("INSERT INTO People ?", people)
   ```
Non racchiudete la variabile placeholder (`?`) tra parentesi angolari doppie (`<<...>>`) quando passate un elenco. *Nelle istruzioni PartiQL manuali, le parentesi doppie angolari indicano una raccolta non ordinata nota come borsa.*

## Fase 6: Interrogare il documento
<a name="driver-quickstart-golang.query"></a>

Il seguente esempio di codice mostra come eseguire un'`SELECT`istruzione.

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

Questo esempio esegue una query sul documento dalla `People` tabella, presuppone che il set di risultati non sia vuoto e restituisce il documento in base al risultato.

## Fase 7: Aggiornare il documento
<a name="driver-quickstart-golang.update"></a>

Il seguente esempio di codice mostra come eseguire un'`UPDATE`istruzione.

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

## Fase 8: Interrogare il documento aggiornato
<a name="driver-quickstart-golang.query-2"></a>

Il seguente esempio di codice esegue una query sulla `People` tabella `firstName` e restituisce tutti i documenti del set di risultati.

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

## Fase 9: Eliminare la tabella
<a name="driver-quickstart-golang.drop-table"></a>

Il seguente esempio di codice mostra come eseguire un'`DROP TABLE`istruzione.

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

## Esecuzione dell'applicazione completa
<a name="driver-quickstart-golang.complete"></a>

Il seguente esempio di codice è la versione completa dell'applicazione. Invece di eseguire i passaggi precedenti singolarmente, potete anche copiare ed eseguire questo esempio di codice dall'inizio alla fine. Questa applicazione dimostra alcune operazioni CRUD di base sul registro denominato. `quick-start`

**Nota**  
Prima di eseguire questo codice, assicuratevi di non avere già una tabella attiva denominata `People` nel registro. `quick-start`

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