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 in Neptune openCypher
<a name="access-graph-opencypher-transactions"></a>

L'implementazione openCypher in Amazon Neptune utilizza la [semantica delle transazioni definita da Neptune](transactions-neptune.md). Tuttavia, i livelli di isolamento forniti dal driver Bolt hanno alcune implicazioni specifiche per la semantica delle transazioni Bolt, come descritto nelle sezioni seguenti.

## Query sulle transazioni Bolt di sola lettura
<a name="access-graph-opencypher-transactions-ro"></a>

Esistono vari modi in cui è possibile elaborare le query di sola lettura, con diversi modelli di transazione e livelli di isolamento, come segue:

### Query sulle transazioni implicite di sola lettura
<a name="access-graph-opencypher-transactions-ro-implicit"></a>

Di seguito è illustrato un esempio di transazione implicita di sola lettura:

```
public void executeReadImplicitTransaction()
{
  // end point
  final String END_POINT = "(End Point URL)";

  // read query
  final String READ_QUERY = "MATCH (n) RETURN n limit 10";

  // create the driver
  final Driver driver = GraphDatabase.driver(END_POINT, AuthTokens.none(),
          Config.builder().withEncryption()
                          .withTrustStrategy(TrustStrategy.trustSystemCertificates())
                          .build());

  // create the session config
  SessionConfig sessionConfig = SessionConfig.builder()
                                             .withFetchSize(1000)
                                             .withDefaultAccessMode(AccessMode.READ)
                                             .build();

  // run the query as access mode read
  driver.session(sessionConfig).readTransaction(new TransactionWork<String>()
    {
      final StringBuilder resultCollector = new StringBuilder();

      @Override
      public String execute(final Transaction tx)
      {
        // execute the query
        Result queryResult = tx.run(READ_QUERY);

        // Read the result
        for (Record record : queryResult.list())
        {
          for (String key : record.keys())
          {
            resultCollector.append(key)
                           .append(":")
                           .append(record.get(key).asNode().toString());
          }
        }
        return resultCollector.toString();
      }

    }
  );

  // close the driver.
  driver.close();
}
```

Poiché le repliche di lettura accettano solo query di sola lettura, tutte le query relative sulle repliche di lettura vengono eseguite come transazioni implicite di lettura indipendentemente dalla modalità di accesso impostata nella configurazione della sessione. Neptune valuta le transazioni implicite di lettura come [query di sola lettura](transactions-neptune.md#transactions-neptune-read-only) in base alla semantica di isolamento `SNAPSHOT`.

In caso di errore, le transazioni implicite di lettura vengono ripetute per impostazione predefinita.

### Query sulle transazioni di sola lettura con commit automatico
<a name="access-graph-opencypher-transactions-ro-autocommit"></a>

Di seguito è illustrato un esempio di transazione di sola lettura con commit automatico:

```
public void executeAutoCommitTransaction()
{
  // end point
  final String END_POINT = "(End Point URL)";

  // read query
  final String READ_QUERY = "MATCH (n) RETURN n limit 10";

  // Create the session config.
  final SessionConfig sessionConfig = SessionConfig
    .builder()
    .withFetchSize(1000)
    .withDefaultAccessMode(AccessMode.READ)
    .build();

  // create the driver
  final Driver driver = GraphDatabase.driver(END_POINT, AuthTokens.none(),
    Config.builder()
          .withEncryption()
          .withTrustStrategy(TrustStrategy.trustSystemCertificates())
          .build());

  // result collector
  final StringBuilder resultCollector = new StringBuilder();

  // create a session
  final Session session = driver.session(sessionConfig);

  // run the query
  final Result queryResult = session.run(READ_QUERY);
  for (final Record record : queryResult.list())
  {
    for (String key : record.keys())
    {
      resultCollector.append(key)
                     .append(":")
                     .append(record.get(key).asNode().toString());
    }
  }

  // close the session
  session.close();

  // close the driver
  driver.close();
}
```

Se la modalità di accesso è impostata su `READ` nella configurazione della sessione, Neptune valuta le query sulle transazioni con commit automatico come [query di sola lettura](transactions-neptune.md#transactions-neptune-read-only) in base alla semantica di isolamento `SNAPSHOT`. Notare che le repliche di lettura accettano solo query di sola lettura.

Se non si esegue una configurazione di sessione, le query con commit automatico vengono elaborate per impostazione predefinita con l'isolamento delle query di mutazione, quindi è importante eseguire una configurazione di sessione che imposti esplicitamente la modalità di accesso su `READ`.

In caso di errore, le query di sola lettura con commit automatico non vengono ripetute.

### Query sulle transazioni esplicite di sola lettura
<a name="access-graph-opencypher-transactions-ro-explicit"></a>

Di seguito è illustrato un esempio di transazione esplicita di sola lettura:

```
public void executeReadExplicitTransaction()
{
  // end point
  final String END_POINT = "(End Point URL)";

  // read query
  final String READ_QUERY = "MATCH (n) RETURN n limit 10";

  // Create the session config.
  final SessionConfig sessionConfig = SessionConfig
    .builder()
    .withFetchSize(1000)
    .withDefaultAccessMode(AccessMode.READ)
    .build();

  // create the driver
  final Driver driver = GraphDatabase.driver(END_POINT, AuthTokens.none(),
    Config.builder()
          .withEncryption()
          .withTrustStrategy(TrustStrategy.trustSystemCertificates())
          .build());

  // result collector
  final StringBuilder resultCollector = new StringBuilder();

  // create a session
  final Session session = driver.session(sessionConfig);

  // begin transaction
  final Transaction tx = session.beginTransaction();

  // run the query on transaction
  final List<Record> list = tx.run(READ_QUERY).list();

  // read the result
  for (final Record record : list)
  {
    for (String key : record.keys())
    {
      resultCollector
        .append(key)
        .append(":")
        .append(record.get(key).asNode().toString());
    }
  }

  // commit the transaction and for rollback we can use beginTransaction.rollback();
  tx.commit();

  // close the driver
  driver.close();
}
```

Se la modalità di accesso è impostata su `READ` nella configurazione della sessione, Neptune valuta le transazioni esplicite di sola lettura come [query di sola lettura](transactions-neptune.md#transactions-neptune-read-only) in base alla semantica di isolamento `SNAPSHOT`. Notare che le repliche di lettura accettano solo query di sola lettura.

Se non si esegue una configurazione di sessione, le transazioni esplicite di sola lettura vengono elaborate per impostazione predefinita con l'isolamento delle query di mutazione, quindi è importante eseguire una configurazione di sessione che imposti esplicitamente la modalità di accesso su `READ`.

In caso di errore, le query esplicite di sola lettura vengono ripetute per impostazione predefinita.

## Query sulle transazioni di mutazione Bolt
<a name="access-graph-opencypher-transactions-wr"></a>

Come per le query di sola lettura, esistono vari modi in cui è possibile elaborare le query di mutazione, con diversi modelli di transazione e livelli di isolamento, come segue:

### Query sulle transazioni di mutazione implicite
<a name="access-graph-opencypher-transactions-wr-implicit"></a>

Di seguito è illustrato un esempio di transazione di mutazione implicita:

```
public void executeWriteImplicitTransaction()
{
  // end point
  final String END_POINT = "(End Point URL)";

  // create node with label as label and properties.
  final String WRITE_QUERY = "CREATE (n:label {name : 'foo'})";

  // Read the vertex created with label as label.
  final String READ_QUERY = "MATCH (n:label) RETURN n";

  // create the driver
  final Driver driver = GraphDatabase.driver(END_POINT, AuthTokens.none(),
    Config.builder()
          .withEncryption()
          .withTrustStrategy(TrustStrategy.trustSystemCertificates())
          .build());

  // create the session config
  SessionConfig sessionConfig = SessionConfig
    .builder()
    .withFetchSize(1000)
    .withDefaultAccessMode(AccessMode.WRITE)
    .build();

  final StringBuilder resultCollector = new StringBuilder();

  // run the query as access mode write
  driver.session(sessionConfig).writeTransaction(new TransactionWork<String>()
  {
    @Override
    public String execute(final Transaction tx)
    {
      // execute the write query and consume the result.
      tx.run(WRITE_QUERY).consume();

      // read the vertex written in the same transaction
      final List<Record> list = tx.run(READ_QUERY).list();

      // read the result
      for (final Record record : list)
      {
        for (String key : record.keys())
        {
          resultCollector
            .append(key)
            .append(":")
            .append(record.get(key).asNode().toString());
        }
      }
      return resultCollector.toString();
    }
  }); // at the end, the transaction is automatically committed.

  // close the driver.
  driver.close();
}
```

Le letture effettuate come parte delle query di mutazione vengono eseguite in base all'isolamento `READ COMMITTED` con le consuete garanzie per le [transazioni di mutazione di Neptune](transactions-neptune.md#transactions-neptune-mutation).

Indipendentemente dal fatto che si esegua o meno specificamente una configurazione di sessione, la transazione viene sempre considerata come una transazione di scrittura.

Per i conflitti, consulta [Risoluzione dei conflitti tramite timeout di attesa di blocco](transactions-neptune.md#transactions-neptune-conflicts).

### Query sulle transazioni di mutazione con commit automatico
<a name="access-graph-opencypher-transactions-wr-autocommit"></a>

Le query di mutazione con commit automatico ereditano lo stesso comportamento delle transazioni di mutazione implicite.

Se non si esegue una configurazione di sessione, la transazione viene considerata come una transazione di scrittura per impostazione predefinita.

In caso di errore, le query di mutazione con commit automatico non vengono ripetute automaticamente.

### Query sulle transazioni di mutazione esplicite
<a name="access-graph-opencypher-transactions-wr-explicit"></a>

Di seguito è illustrato un esempio di transazione di mutazione esplicita:

```
public void executeWriteExplicitTransaction()
{
  // end point
  final String END_POINT = "(End Point URL)";

  // create node with label as label and properties.
  final String WRITE_QUERY = "CREATE (n:label {name : 'foo'})";

  // Read the vertex created with label as label.
  final String READ_QUERY = "MATCH (n:label) RETURN n";

  // create the driver
  final Driver driver = GraphDatabase.driver(END_POINT, AuthTokens.none(),
    Config.builder()
          .withEncryption()
          .withTrustStrategy(TrustStrategy.trustSystemCertificates())
          .build());

  // create the session config
  SessionConfig sessionConfig = SessionConfig
    .builder()
    .withFetchSize(1000)
    .withDefaultAccessMode(AccessMode.WRITE)
    .build();

  final StringBuilder resultCollector = new StringBuilder();

  final Session session = driver.session(sessionConfig);

  // run the query as access mode write
  final Transaction tx = driver.session(sessionConfig).beginTransaction();

  // execute the write query and consume the result.
  tx.run(WRITE_QUERY).consume();

  // read the result from the previous write query in a same transaction.
  final List<Record> list = tx.run(READ_QUERY).list();

  // read the result
  for (final Record record : list)
  {
    for (String key : record.keys())
    {
      resultCollector
        .append(key)
        .append(":")
        .append(record.get(key).asNode().toString());
    }
  }

  // commit the transaction and for rollback we can use tx.rollback();
  tx.commit();

  // close the session
  session.close();

  // close the driver.
  driver.close();
}
```

Le query di mutazione esplicita ereditano lo stesso comportamento delle transazioni di mutazione implicite.

Se non si esegue una configurazione di sessione, la transazione viene considerata come una transazione di scrittura per impostazione predefinita.

Per i conflitti, consulta [Risoluzione dei conflitti tramite timeout di attesa di blocco](transactions-neptune.md#transactions-neptune-conflicts).