As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Transações do Gremlin no Neptune
<a name="access-graph-gremlin-transactions"></a>

Existem vários contextos nos quais as [transações](transactions.md) do Gremlin são executadas. Ao trabalhar com o Gremlin, é importante entender o contexto em que você está trabalhando e quais são suas implicações:
+ **`Script-based`**: as solicitações são feitas usando strings do Gremlin baseadas em texto, como esta:
  + Usar o driver Java e `Client.submit(string)`.
  + Usar o console do Gremlin e `:remote connect`.
  + Usar a API HTTP.
+ **`Bytecode-based`**: as solicitações são feitas usando o bytecode do Gremlin serializado típico das [Variantes da linguagem Gremlin](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) (GLV).

  Por exemplo, usando o driver Java, `g = traversal().withRemote(...)`.

Para qualquer um dos contextos acima, há o contexto adicional da solicitação sendo enviada sem sessão ou vinculada a uma sessão.

**nota**  
 As transações do Gremlin sempre devem ser confirmadas ou revertidas, para que os recursos do lado do servidor possam ser liberados. No caso de erros durante a transação, é importante repetir toda a transação e não somente a solicitação específica que falhou. 

## Solicitações sem sessão
<a name="access-graph-gremlin-transactions-sessionless"></a>

 Quando não há sessão, uma solicitação equivale a uma única transação.

Para scripts, a implicação é que uma ou mais declarações do Gremlin enviadas em uma única solicitação serão confirmadas ou revertidas como uma única transação. Por exemplo:

```
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();
```

Para bytecode, uma solicitação sem sessão é feita para cada percurso gerado e executado a partir de `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();
```

## Solicitações vinculadas a uma sessão
<a name="access-graph-gremlin-transactions-session-bound"></a>

Quando vinculadas a uma sessão, várias solicitações podem ser aplicadas no contexto de uma única transação.

Para scripts, a implicação é que não há necessidade de concatenar todas as operações do grafo em um único valor de string incorporado:

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

Para o bytecode, depois TinkerPop `3.5.x`, a transação pode ser controlada explicitamente e a sessão gerenciada de forma transparente. As Variantes da linguagem Gremlin (GLV) são compatíveis com a sintaxe `tx()` do Gremlin para `commit()` ou `rollback()` uma transação da seguinte forma:

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

Embora o exemplo acima esteja escrito em Java, você também pode usar essa sintaxe `tx()` em Python, Javascript e .NET.

**Atenção**  
As consultas somente leitura sem sessão são executadas em isolamento [SNAPSHOT](transactions-isolation-levels.md), mas as consultas somente leitura executadas em uma transação explícita são executadas em isolamento [SERIALIZABLE](transactions-isolation-levels.md). As consultas somente leitura executadas em isolamento `SERIALIZABLE` geram maior sobrecarga e podem bloquear ou bloqueadas por gravações simultâneas, ao contrário das executadas em isolamento `SNAPSHOT`.