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

# Transazioni Gremlin in Neptune
<a name="access-graph-gremlin-transactions"></a>

Esistono diversi contesti in cui vengono eseguite le [transazioni](transactions.md) Gremlin. Quando si lavora con Gremlin è importante comprendere il contesto in cui si lavora e quali sono le relative implicazioni:
+ **`Script-based`**: le richieste vengono effettuate utilizzando stringhe Gremlin basate su testo, come queste:
  + Utilizzando il driver Java e `Client.submit(string)`.
  + Utilizzando la console Gremlin e `:remote connect`.
  + Utilizzando l'API HTTP.
+ **`Bytecode-based`**: le richieste vengono effettuate utilizzando il bytecode Gremlin serializzato tipico delle [varianti del linguaggio Gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) (GLV).

  Ad esempio, utilizzando il driver Java, `g = traversal().withRemote(...)`.

Per entrambi i contesti sopra descritti, esiste il contesto aggiuntivo della richiesta inviata come senza sessione o come associata a una sessione.

**Nota**  
 Le transazioni Gremlin devono sempre essere sottoposte a commit o rollback, in modo che le risorse lato server possano essere rilasciate. In caso di errore durante la transazione, è importante ripetere l'intera transazione e non solo la richiesta specifica non riuscita. 

## Richieste senza sessione
<a name="access-graph-gremlin-transactions-sessionless"></a>

 Quando è senza sessione, una richiesta equivale a una singola transazione.

Per gli script, l'implicazione è che una o più istruzioni Gremlin inviate in una singola richiesta verranno sottoposte a commit o rollback come singola transazione. Esempio:

```
Cluster cluster = Cluster.open();
Client client = cluster.connect(); // sessionless
// 3 vertex additions in one request/transaction:
client.submit("g.addV();g.addV();g.addV()").all().get();
```

Per il bytecode, viene effettuata una richiesta senza sessione per ogni attraversamento generato ed eseguito da `g`:

```
GraphTraversalSource g = traversal().withRemote(...);

// 3 vertex additions in three individual requests/transactions:
g.addV().iterate();
g.addV().iterate();
g.addV().iterate();

// 3 vertex additions in one single request/transaction:
g.addV().addV().addV().iterate();
```

## Richieste associate a una sessione
<a name="access-graph-gremlin-transactions-session-bound"></a>

Se associate a una sessione, è possibile applicare più richieste nel contesto di una singola transazione.

Per gli script, l'implicazione è che non è necessario concatenare tutte le operazioni del grafo in un unico valore di stringa incorporato:

```
Cluster cluster = Cluster.open();
Client client = cluster.connect(sessionName); // session
try {
    // 3 vertex additions in one request/transaction:
    client.submit("g.addV();g.addV();g.addV()").all().get();
} finally {
    client.close();
}

try {
    // 3 vertex additions in three requests, but one transaction:
    client.submit("g.addV()").all().get(); // starts a new transaction with the same sessionName
    client.submit("g.addV()").all().get();
    client.submit("g.addV()").all().get();
} finally {
    client.close();
}
```

Per quanto riguarda il bytecode, in seguito TinkerPop `3.5.x`, la transazione può essere controllata in modo esplicito e la sessione gestita in modo trasparente. Le varianti del linguaggio Gremlin (GLV) supportano la sintassi `tx()` di Gremlin per eseguire le operazioni di `commit()` o `rollback()` su una transazione come segue:

```
GraphTraversalSource g = traversal().withRemote(conn);

Transaction tx = g.tx();

// Spawn a GraphTraversalSource from the Transaction.
// Traversals spawned from gtx are executed within a single transaction.
GraphTraversalSource gtx = tx.begin();
try {
    gtx.addV('person').iterate();
    gtx.addV('software').iterate();

    tx.commit();
} finally {
    if (tx.isOpen()) {
        tx.rollback();
    }
}
```

Sebbene l'esempio precedente sia scritto in Java, è possibile utilizzare questa sintassi `tx()` anche in Python, Javascript e .NET.

**avvertimento**  
Le query di sola lettura senza sessione vengono eseguite con isolamento [SNAPSHOT](transactions-isolation-levels.md), mentre le query di sola lettura eseguite all'interno di una transazione esplicita vengono eseguite con isolamento [SERIALIZABLE](transactions-isolation-levels.md). Le query di sola lettura eseguite con isolamento `SERIALIZABLE` comportano un sovraccarico maggiore e possono bloccarsi o essere bloccate da scritture simultanee, a differenza di quelle eseguite con isolamento `SNAPSHOT`.