Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Transaktionen in Neptune openCypher
<a name="access-graph-opencypher-transactions"></a>

Die openCypher-Implementierung in Amazon Neptune verwendet die [von Neptune definierte Transaktionssemantik](transactions-neptune.md). Die vom Bolt-Treiber bereitgestellten Isolationsstufen haben jedoch einige spezifische Auswirkungen auf die Bolt-Transaktionssemantik, wie in den folgenden Abschnitten beschrieben.

## Schreibgeschützte Bolt-Transaktionsabfragen
<a name="access-graph-opencypher-transactions-ro"></a>

Es gibt verschiedene Möglichkeiten für die Verarbeitung schreibgeschützter Abfragen mit verschiedenen Transaktionsmodellen und Isolationsstufen:

### Implizite schreibgeschützte Transaktionsabfragen
<a name="access-graph-opencypher-transactions-ro-implicit"></a>

Dies ist ein Beispiel für eine implizite schreibgeschützte Transaktion:

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

Da Read-Replicas nur schreibgeschützte Abfragen akzeptieren, werden alle Abfragen für Read-Replicas unabhängig vom in der Sitzungskonfiguration festgelegten Zugriffsmodus als leseimplizite Transaktionen ausgeführt. Neptune wertet leseimplizite Transaktionen als [schreibgeschützte Abfragen](transactions-neptune.md#transactions-neptune-read-only) unter isolierter `SNAPSHOT`-Semantik aus.

Bei einem Fehler werden leseimplizite Transaktionen standardmäßig wiederholt.

### Schreibgeschützte Autocommit-Transaktionsabfragen
<a name="access-graph-opencypher-transactions-ro-autocommit"></a>

Dies ist ein Beispiel für eine schreibgeschützte Autocommit-Transaktion:

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

Wenn der Zugriffsmodus in der Sitzungskonfiguration auf `READ` festgelegt ist, wertet Neptune Autocommit-Transaktionsabfragen als [schreibgeschützte Abfragen](transactions-neptune.md#transactions-neptune-read-only) unter `SNAPSHOT`-Isolationssemantik aus. Beachten Sie, dass Read-Replicas nur schreibgeschützte Abfragen akzeptieren.

Wenn Sie Autocommit-Abfragen nicht in einer Sitzungskonfiguration übergeben, werden sie standardmäßig mit Mutationsabfragenisolierung verarbeitet. Daher ist es wichtig, sie in einer Sitzungskonfiguration zu übergeben, die den Zugriffsmodus explizit auf `READ` festlegt.

Bei einem Fehler werden schreibgeschützte Autocommit-Abfragen nicht wiederholt.

### Explizite schreibgeschützte Transaktionsabfragen
<a name="access-graph-opencypher-transactions-ro-explicit"></a>

Dies ist ein Beispiel für eine explizite schreibgeschützte Transaktion:

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

Wenn der Zugriffsmodus in der Sitzungskonfiguration auf `READ` festgelegt ist, wertet Neptune explizite schreibgeschützte Transaktionen als [schreibgeschützte Abfragen](transactions-neptune.md#transactions-neptune-read-only) unter `SNAPSHOT`-Isolationssemantik aus. Beachten Sie, dass Read-Replicas nur schreibgeschützte Abfragen akzeptieren.

Wenn Sie explizite schreibgeschützte Transaktionen nicht in einer Sitzungskonfiguration übergeben, werden sie standardmäßig mit Mutationsabfragenisolierung verarbeitet. Daher ist es wichtig, sie in einer Sitzungskonfiguration zu übergeben, die den Zugriffsmodus explizit auf `READ` festlegt.

Bei einem Fehler werden explizite schreibgeschützte Abfragen standardmäßig wiederholt.

## Bolt-Mutationstransaktionsabfragen
<a name="access-graph-opencypher-transactions-wr"></a>

Wie bei schreibgeschützten Abfragen gibt es auch hier verschiedene Möglichkeiten für die Verarbeitung von Mutationsabfragen mit verschiedenen Transaktionsmodellen und Isolationsstufen:

### Implizite Mutationstransaktionsabfragen
<a name="access-graph-opencypher-transactions-wr-implicit"></a>

Dies ist ein Beispiel für eine implizite Mutationstransaktion:

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

Lesevorgänge als Teil von Mutationsabfragen werden unter `READ COMMITTED`-Isolation mit den üblichen Garantien für [Neptune-Mutationstransaktionen](transactions-neptune.md#transactions-neptune-mutation) ausgeführt.

Unabhängig davon, ob Sie die Transaktion ausdrücklich in einer Sitzungskonfiguration übergeben oder nicht, wird die Transaktion stets als Schreibtransaktion behandelt.

Informationen zu Konflikten finden Sie unter [Konfliktlösung mithilfe von Sperrwartezeitüberschreitungen](transactions-neptune.md#transactions-neptune-conflicts).

### Autocommit-Mutationstransaktionsabfragen
<a name="access-graph-opencypher-transactions-wr-autocommit"></a>

Autocommit-Mutationsabfragen erben dasselbe Verhalten wie implizite Mutationstransaktionen.

Wenn Sie die Transaktion nicht in einer Sitzungskonfiguration übergeben, wird die Transaktion standardmäßig als Schreibtransaktion behandelt.

Bei einem Fehler werden Autocommit-Mutationsabfragen nicht automatisch wiederholt.

### Explizite Mutationstransaktionsabfragen
<a name="access-graph-opencypher-transactions-wr-explicit"></a>

Dies ist ein Beispiel für eine explizite Mutationstransaktion:

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

Explizite Mutationsabfragen erben dasselbe Verhalten wie implizite Mutationstransaktionen.

Wenn Sie die Transaktion nicht in einer Sitzungskonfiguration übergeben, wird die Transaktion standardmäßig als Schreibtransaktion behandelt.

Informationen zu Konflikten finden Sie unter [Konfliktlösung mithilfe von Sperrwartezeitüberschreitungen](transactions-neptune.md#transactions-neptune-conflicts).