Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Transaksi di Neptunus OpenCypher
<a name="access-graph-opencypher-transactions"></a>

Implementasi OpenCypher di Amazon Neptunus menggunakan [semantik transaksi yang ditentukan oleh Neptunus Namun, tingkat isolasi yang disediakan oleh driver Bolt memiliki beberapa implikasi](transactions-neptune.md) spesifik untuk semantik transaksi Bolt, seperti yang dijelaskan pada bagian di bawah ini.

## Read-only Permintaan transaksi Bolt
<a name="access-graph-opencypher-transactions-ro"></a>

Ada berbagai cara agar kueri hanya-baca dapat diproses, dengan model transaksi dan tingkat isolasi yang berbeda, sebagai berikut:

### Permintaan transaksi hanya-baca implisit
<a name="access-graph-opencypher-transactions-ro-implicit"></a>

Berikut adalah contoh transaksi implisit read-only:

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

Karena replika baca hanya menerima kueri hanya-baca, semua kueri terhadap replika baca dijalankan sebagai transaksi baca-implisit terlepas dari mode akses yang ditetapkan dalam konfigurasi sesi. [Neptunus mengevaluasi transaksi baca-implisit sebagai kueri hanya-baca di bawah semantik isolasi.](transactions-neptune.md#transactions-neptune-read-only) `SNAPSHOT`

Jika terjadi kegagalan, transaksi baca-implisit dicoba ulang secara default.

### Kueri transaksi hanya-baca otomatis
<a name="access-graph-opencypher-transactions-ro-autocommit"></a>

Berikut adalah contoh transaksi autocommit read-only:

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

[Jika mode akses diatur ke `READ` dalam konfigurasi sesi, Neptunus mengevaluasi kueri transaksi autocommit sebagai kueri hanya-baca di bawah semantik isolasi.](transactions-neptune.md#transactions-neptune-read-only) `SNAPSHOT` Perhatikan bahwa replika baca hanya menerima kueri hanya-baca.

Jika Anda tidak meneruskan konfigurasi sesi, kueri komit otomatis diproses secara default dengan isolasi kueri mutasi, jadi penting untuk meneruskan konfigurasi sesi yang secara eksplisit menyetel mode akses ke. `READ`

Jika terjadi kegagalan, kueri komit otomatis hanya-baca tidak dicoba ulang.

### Kueri transaksi hanya-baca eksplisit
<a name="access-graph-opencypher-transactions-ro-explicit"></a>

Berikut adalah contoh transaksi hanya-baca eksplisit:

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

[Jika mode akses diatur ke `READ` dalam konfigurasi sesi, Neptunus mengevaluasi transaksi hanya-baca eksplisit sebagai kueri hanya-baca di bawah semantik isolasi.](transactions-neptune.md#transactions-neptune-read-only) `SNAPSHOT` Perhatikan bahwa replika baca hanya menerima kueri hanya-baca.

Jika Anda tidak meneruskan konfigurasi sesi, transaksi hanya-baca eksplisit diproses secara default dengan isolasi kueri mutasi, jadi penting untuk meneruskan konfigurasi sesi yang secara eksplisit menyetel mode akses ke. `READ`

Jika terjadi kegagalan, kueri eksplisit hanya-baca akan dicoba ulang secara default.

## Kueri transaksi Mutasi Bolt
<a name="access-graph-opencypher-transactions-wr"></a>

Seperti halnya kueri hanya-baca, ada berbagai cara agar kueri mutasi dapat diproses, dengan model transaksi dan tingkat isolasi yang berbeda, sebagai berikut:

### Kueri transaksi mutasi implisit
<a name="access-graph-opencypher-transactions-wr-implicit"></a>

Berikut adalah contoh transaksi mutasi implisit:

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

[Pembacaan yang dibuat sebagai bagian dari kueri mutasi dijalankan secara `READ COMMITTED` terpisah dengan jaminan biasa untuk transaksi mutasi Neptunus.](transactions-neptune.md#transactions-neptune-mutation)

Apakah Anda secara khusus lulus dalam konfigurasi sesi, transaksi selalu diperlakukan sebagai transaksi tulis.

Untuk konflik, lihat[Resolusi Konflik Menggunakan Lock-Wait Timeout](transactions-neptune.md#transactions-neptune-conflicts).

### Kueri transaksi mutasi komit otomatis
<a name="access-graph-opencypher-transactions-wr-autocommit"></a>

Kueri autocommit mutasi mewarisi perilaku yang sama dengan transaksi implisit mutasi.

Jika Anda tidak lulus dalam konfigurasi sesi, transaksi diperlakukan sebagai transaksi tulis secara default.

Jika terjadi kegagalan, kueri komit otomatis mutasi tidak dicoba ulang secara otomatis.

### Kueri transaksi mutasi eksplisit
<a name="access-graph-opencypher-transactions-wr-explicit"></a>

Berikut adalah contoh transaksi mutasi eksplisit:

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

Kueri mutasi eksplisit mewarisi perilaku yang sama dengan transaksi mutasi implisit.

Jika Anda tidak lulus dalam konfigurasi sesi, transaksi diperlakukan sebagai transaksi tulis secara default.

Untuk konflik, lihat[Resolusi Konflik Menggunakan Lock-Wait Timeout](transactions-neptune.md#transactions-neptune-conflicts).