diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/add-scalardb-to-your-build.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/add-scalardb-to-your-build.mdx
new file mode 100644
index 00000000..5c6fdca7
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/add-scalardb-to-your-build.mdx
@@ -0,0 +1,43 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ビルドに ScalarDB を追加する
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB ライブラリは、[Maven Central Repository](https://mvnrepository.com/artifact/com.scalar-labs/scalardb) で入手できます。Gradle または Maven を使用して、ライブラリをビルド依存関係としてアプリケーションに追加できます。
+
+## ビルドツールに基づいてアプリケーションを設定する
+
+ビルドツールを選択し、手順に従って ScalarDB のビルド依存関係をアプリケーションに追加します。
+
+
+
+ Gradle を使用して ScalarDB のビルド依存関係を追加するには、アプリケーションの `build.gradle` に次のコードを追加し、`` を使用する ScalarDB のバージョンに置き換えます。
+
+ ```gradle
+ dependencies {
+ implementation 'com.scalar-labs:scalardb:'
+ }
+ ```
+
+
+ Maven を使用して ScalarDB のビルド依存関係を追加するには、アプリケーションの `pom.xml` に次のコードを追加し、`` を使用する ScalarDB のバージョンに置き換えます。
+
+ ```xml
+
+ com.scalar-labs
+ scalardb
+
+
+ ```
+
+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/api-guide.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/api-guide.mdx
new file mode 100644
index 00000000..75c9f6d0
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/api-guide.mdx
@@ -0,0 +1,1621 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Java API ガイド
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Java API は、主に管理 API とトランザクション API で設定されています。このガイドでは、どのような種類の API が存在するのか、それらの使用方法、例外の処理方法などの関連トピックについて簡単に説明します。
+
+## Administrative API
+
+このセクションでは、ScalarDB の管理 API を使用してプログラムで管理操作を実行する方法について説明します。
+
+:::note
+
+管理操作を実行する別の方法は、[Schema Loader](schema-loader.mdx) を使用することです。
+
+:::
+
+### `DistributedTransactionAdmin` インスタンスを取得する
+
+管理操作を実行するには、まず `DistributedTransactionAdmin` インスタンスを取得する必要があります。
+
+`DistributedTransactionAdmin` インスタンスを取得するには、次のように `TransactionFactory` を使用します。
+
+```java
+TransactionFactory transactionFactory = TransactionFactory.create("");
+DistributedTransactionAdmin admin = transactionFactory.getTransactionAdmin();
+```
+
+設定の詳細については、[ScalarDB 設定](configurations.mdx)を参照してください。
+
+すべての管理操作を実行したら、次のように `DistributedTransactionAdmin` インスタンスを閉じる必要があります。
+
+```java
+admin.close();
+```
+
+### 名前空間を作成する
+
+テーブルは 1 つの名前空間に属するため、テーブルを作成する前に名前空間を作成する必要があります。
+
+名前空間は次のように作成できます。
+
+```java
+// Create the namespace "ns". If the namespace already exists, an exception will be thrown.
+admin.createNamespace("ns");
+
+// Create the namespace only if it does not already exist.
+boolean ifNotExists = true;
+admin.createNamespace("ns", ifNotExists);
+
+// Create the namespace with options.
+Map options = ...;
+admin.createNamespace("ns", options);
+```
+
+#### 作成オプション
+
+名前空間の作成やテーブルの作成などの作成操作では、オプション名と値のマップであるオプション (`Map`) を指定できます。オプションを使用すると、ストレージアダプタ固有の設定ができます。
+
+データベースを選択して、使用可能なオプションを確認します。
+
+
+
+ JDBC データベースには使用できるオプションはありません。
+
+
+ | 名前 | 説明 | デフォルト |
+ |------------|-------------------------------------------------|------------|
+ | no-scaling | DynamoDB の自動スケーリングを無効にします。 | false |
+ | no-backup | DynamoDB の継続的なバックアップを無効にします。 | false |
+ | ru | 基本リソース単位。 | 10 |
+
+
+ | 名前 | 説明 | デフォルト |
+ |------------|--------------------------------------------------------|------------|
+ | ru | 基本リソース単位。 | 400 |
+ | no-scaling | Cosmos DB for NoSQL の自動スケーリングを無効にします。 | false |
+
+
+ | 名前 | 説明 | デフォルト |
+ |----------------------|----------------------------------------------------------------------------------------------------------|-------------------|
+ | replication-strategy | Cassandra レプリケーション戦略。`SimpleStrategy` または `NetworkTopologyStrategy` である必要があります。 | `SimpleStrategy` |
+ | compaction-strategy | Cassandra 圧縮戦略。`LCS`、`STCS`、または `TWCS` である必要があります。 | `STCS` |
+ | replication-factor | Cassandra の複製係数。 | 3 |
+
+
+
+### テーブルを作成する
+
+テーブルを作成するときは、テーブルメタデータを定義してからテーブルを作成する必要があります。
+
+テーブルメタデータを定義するには、`TableMetadata` を使用できます。次の図は、テーブルの列、パーティションキー、クラスタリングキー (クラスタリング順序を含む)、およびセカンダリインデックスを定義する方法を示しています。
+
+```java
+// Define the table metadata.
+TableMetadata tableMetadata =
+ TableMetadata.newBuilder()
+ .addColumn("c1", DataType.INT)
+ .addColumn("c2", DataType.TEXT)
+ .addColumn("c3", DataType.BIGINT)
+ .addColumn("c4", DataType.FLOAT)
+ .addColumn("c5", DataType.DOUBLE)
+ .addPartitionKey("c1")
+ .addClusteringKey("c2", Scan.Ordering.Order.DESC)
+ .addClusteringKey("c3", Scan.Ordering.Order.ASC)
+ .addSecondaryIndex("c4")
+ .build();
+```
+
+ScalarDB のデータモデルの詳細については、[データモデル](design.mdx#データモデル)を参照してください。
+
+次に、次のようにテーブルを作成します。
+
+```java
+// Create the table "ns.tbl". If the table already exists, an exception will be thrown.
+admin.createTable("ns", "tbl", tableMetadata);
+
+// Create the table only if it does not already exist.
+boolean ifNotExists = true;
+admin.createTable("ns", "tbl", tableMetadata, ifNotExists);
+
+// Create the table with options.
+Map options = ...;
+admin.createTable("ns", "tbl", tableMetadata, options);
+```
+
+### セカンダリインデックスを作成する
+
+セカンダリインデックスは次のように作成できます。
+
+```java
+// Create a secondary index on column "c5" for table "ns.tbl". If a secondary index already exists, an exception will be thrown.
+admin.createIndex("ns", "tbl", "c5");
+
+// Create the secondary index only if it does not already exist.
+boolean ifNotExists = true;
+admin.createIndex("ns", "tbl", "c5", ifNotExists);
+
+// Create the secondary index with options.
+Map options = ...;
+admin.createIndex("ns", "tbl", "c5", options);
+```
+
+### テーブルに新しい列を追加する
+
+次のように、テーブルに新しい非パーティションキー列を追加できます。
+
+```java
+// Add a new column "c6" with the INT data type to the table "ns.tbl".
+admin.addNewColumnToTable("ns", "tbl", "c6", DataType.INT)
+```
+
+:::warning
+
+テーブルに新しい列を追加する場合は、基盤となるストレージによって実行時間が大きく異なる可能性があるため、慎重に検討する必要があります。それに応じて計画を立て、特にデータベースが本番環境で実行されている場合は、次の点を考慮してください。
+
+- **Cosmos DB for NoSQL および DynamoDB の場合:** テーブルスキーマは変更されないため、列の追加はほぼ瞬時に行われます。別のテーブルに格納されているテーブルメタデータのみが更新されます。
+- **Cassandra の場合:** 列を追加すると、スキーマメタデータのみが更新され、既存のスキーマレコードは変更されません。クラスタートポロジが実行時間の主な要因です。スキーマメタデータの変更は、ゴシッププロトコルを介して各クラスターノードに共有されます。このため、クラスターが大きいほど、すべてのノードが更新されるまでの時間が長くなります。
+- **リレーショナルデータベース (MySQL、Oracle など) の場合:** 列の追加は実行にそれほど時間がかかりません。
+
+:::
+
+### テーブルを切り捨てる
+
+テーブルを切り捨てるには、次のようにします。
+
+```java
+// Truncate the table "ns.tbl".
+admin.truncateTable("ns", "tbl");
+```
+
+### セカンダリインデックスを削除する
+
+セカンダリインデックスは次のように削除できます。
+
+```java
+// Drop the secondary index on column "c5" from table "ns.tbl". If the secondary index does not exist, an exception will be thrown.
+admin.dropIndex("ns", "tbl", "c5");
+
+// Drop the secondary index only if it exists.
+boolean ifExists = true;
+admin.dropIndex("ns", "tbl", "c5", ifExists);
+```
+
+### テーブルを削除する
+
+テーブルを削除するには、次のようにします。
+
+```java
+// Drop the table "ns.tbl". If the table does not exist, an exception will be thrown.
+admin.dropTable("ns", "tbl");
+
+// Drop the table only if it exists.
+boolean ifExists = true;
+admin.dropTable("ns", "tbl", ifExists);
+```
+
+### 名前空間を削除する
+
+名前空間を削除するには、次のようにします。
+
+```java
+// Drop the namespace "ns". If the namespace does not exist, an exception will be thrown.
+admin.dropNamespace("ns");
+
+// Drop the namespace only if it exists.
+boolean ifExists = true;
+admin.dropNamespace("ns", ifExists);
+```
+
+### 既存の名前空間を取得する
+
+既存の名前空間は次のように取得できます。
+
+```java
+Set namespaces = admin.getNamespaceNames();
+```
+
+### 名前空間のテーブルを取得する
+
+名前空間のテーブルは次のように取得できます。
+
+```java
+// Get the tables of the namespace "ns".
+Set tables = admin.getNamespaceTableNames("ns");
+```
+
+### テーブルメタデータを取得する
+
+テーブルメタデータは次のように取得できます。
+
+```java
+// Get the table metadata for "ns.tbl".
+TableMetadata tableMetadata = admin.getTableMetadata("ns", "tbl");
+```
+
+### 名前空間を修復する
+
+名前空間が不明な状態の場合 (たとえば、名前空間が基盤となるストレージに存在するが ScalarDB メタデータが存在しない、またはその逆)、このメソッドは必要に応じて名前空間とそのメタデータを再作成します。
+
+名前空間は次のように修復できます。
+
+```java
+// Repair the namespace "ns" with options.
+Map options = ...;
+admin.repairNamespace("ns", options);
+```
+
+### テーブルを修復する
+
+テーブルが不明な状態の場合 (テーブルは基盤となるストレージに存在するが ScalarDB メタデータは存在しない、またはその逆)、このメソッドは必要に応じてテーブル、そのセカンダリインデックス、およびそのメタデータを再作成します。
+
+テーブルは次のように修復できます。
+
+```java
+// Repair the table "ns.tbl" with options.
+TableMetadata tableMetadata =
+ TableMetadata.newBuilder()
+ ...
+ .build();
+Map options = ...;
+admin.repairTable("ns", "tbl", tableMetadata, options);
+```
+
+### 最新の ScalarDB API をサポートするように環境をアップグレードする
+
+ScalarDB API の最新バージョンをサポートするように ScalarDB 環境をアップグレードできます。通常、リリースノートに記載されているように、アプリケーション環境が使用する ScalarDB バージョンを更新した後、このメソッドを実行する必要があります。
+
+```java
+// Upgrade the ScalarDB environment.
+Map options = ...;
+admin.upgrade(options);
+```
+
+### Coordinator テーブルの操作を指定する
+
+Coordinator テーブルは、[Transactional API](#transactional-api) によってトランザクションのステータスを追跡するために使用されます。
+
+トランザクションマネージャーを使用する場合は、トランザクションを実行するために Coordinator テーブルを作成する必要があります。テーブルの作成に加えて、Coordinator テーブルを切り捨てたり削除したりすることもできます。
+
+#### Coordinator テーブルを作成する
+
+Coordinator テーブルは次のように作成できます。
+
+```java
+// Create the Coordinator table.
+admin.createCoordinatorTables();
+
+// Create the Coordinator table only if one does not already exist.
+boolean ifNotExist = true;
+admin.createCoordinatorTables(ifNotExist);
+
+// Create the Coordinator table with options.
+Map options = ...;
+admin.createCoordinatorTables(options);
+```
+
+#### Coordinator テーブルを切り捨てる
+
+Coordinator テーブルは次のように切り捨てることができます。
+
+```java
+// Truncate the Coordinator table.
+admin.truncateCoordinatorTables();
+```
+
+#### Coordinator テーブルを削除する
+
+Coordinator テーブルは次のように削除できます。
+
+```java
+// Drop the Coordinator table.
+admin.dropCoordinatorTables();
+
+// Drop the Coordinator table if one exist.
+boolean ifExist = true;
+admin.dropCoordinatorTables(ifExist);
+```
+
+### テーブルをインポートする
+
+既存のテーブルを ScalarDB にインポートするには、次のようにします。
+
+```java
+// Import the table "ns.tbl". If the table is already managed by ScalarDB, the target table does not
+// exist, or the table does not meet the requirements of the ScalarDB table, an exception will be thrown.
+admin.importTable("ns", "tbl", options);
+```
+
+:::warning
+
+運用環境で ScalarDB にテーブルをインポートする場合は、データベーステーブルと ScalarDB メタデータテーブルにトランザクションメタデータ列が追加されるため、慎重に計画する必要があります。この場合、データベースと ScalarDB の間にはいくつかの違いがあり、いくつかの制限もあります。詳細については、[ScalarDB Schema Loader を使用して既存のテーブルを ScalarDB にインポートする](./schema-loader-import.mdx)を参照してください。
+
+:::
+
+## Transactional API
+
+このセクションでは、ScalarDB の Transactional API を使用してトランザクション操作を実行する方法について説明します。
+
+### `DistributedTransactionManager` インスタンスを取得する
+
+トランザクション操作を実行するには、まず `DistributedTransactionManager` インスタンスを取得する必要があります。
+
+`DistributedTransactionManager` インスタンスを取得するには、次のように `TransactionFactory` を使用します。
+
+```java
+TransactionFactory transactionFactory = TransactionFactory.create("");
+DistributedTransactionManager transactionManager = transactionFactory.getTransactionManager();
+```
+
+すべてのトランザクション操作を実行した後、次のように `DistributedTransactionManager` インスタンスを閉じる必要があります。
+
+```java
+transactionManager.close();
+```
+
+### トランザクションを実行する
+
+このサブセクションでは、複数の CRUD 操作でトランザクションを実行する方法について説明します。
+
+#### トランザクションを開始する
+
+トランザクション CRUD 操作を実行する前に、トランザクションを開始する必要があります。
+
+トランザクションは次のように開始できます。
+
+```java
+// Begin a transaction.
+DistributedTransaction transaction = transactionManager.begin();
+```
+
+または、次のようにトランザクションを開始することもできます。
+
+```java
+// Start a transaction.
+DistributedTransaction transaction = transactionManager.start();
+```
+
+あるいは、次のようにトランザクション ID を指定して、トランザクションに `begin` メソッドを使用することもできます。
+
+```java
+// Begin a transaction with specifying a transaction ID.
+DistributedTransaction transaction = transactionManager.begin("");
+```
+
+または、次のようにトランザクション ID を指定して、トランザクションに `start` メソッドを使用することもできます。
+
+```java
+// Start a transaction with specifying a transaction ID.
+DistributedTransaction transaction = transactionManager.start("");
+```
+
+:::note
+
+トランザクション ID を指定すると、外部システムを ScalarDB にリンクする場合に便利です。それ以外の場合は、`begin()` メソッドまたは `start()` メソッドを使用する必要があります。
+
+トランザクション ID を指定する場合は、ScalarDB の正確性はトランザクション ID の一意性に依存するため、システム全体で一意の ID (UUID v4 など) を指定してください。
+
+:::
+
+#### トランザクションに参加する
+
+トランザクションに参加することは、トランザクションが複数のクライアントリクエストにまたがるステートフルアプリケーションで特に便利です。このようなシナリオでは、アプリケーションは最初のクライアントリクエスト中にトランザクションを開始できます。その後、後続のクライアントリクエストで、アプリケーションは `join()` メソッドを使用して進行中のトランザクションに参加できます。
+
+次のようにトランザクション ID を指定すると、すでに開始されている進行中のトランザクションに参加できます。
+
+```java
+// Join a transaction.
+DistributedTransaction transaction = transactionManager.join("");
+```
+
+:::note
+
+`getId()` を使用してトランザクション ID を取得するには、次のように指定します。
+
+```java
+tx.getId();
+```
+
+:::
+
+#### トランザクションを再開する
+
+トランザクションの再開は、トランザクションが複数のクライアントリクエストにまたがるステートフルアプリケーションで特に役立ちます。このようなシナリオでは、アプリケーションは最初のクライアントリクエスト中にトランザクションを開始できます。その後、後続のクライアントリクエストで、アプリケーションは `resume()` メソッドを使用して進行中のトランザクションを再開できます。
+
+次のようにトランザクション ID を指定すると、すでに開始した進行中のトランザクションを再開できます。
+
+```java
+// Resume a transaction.
+DistributedTransaction transaction = transactionManager.resume("");
+```
+
+:::note
+
+`getId()` を使用してトランザクション ID を取得するには、次のように指定します。
+
+```java
+tx.getId();
+```
+
+:::
+
+#### CRUD 操作を実装する
+
+次のセクションでは、キーの構築と CRUD 操作について説明します。
+
+:::note
+
+CRUD 操作のすべてのビルダーは `consistency()` メソッドを使用して一貫性を指定できますが、これらのメソッドは無視されます。代わりに、トランザクションでは常に `LINEARIZABLE` 一貫性レベルが使用されます。
+
+:::
+
+##### キーの構築
+
+ほとんどの CRUD 操作では、`Key` オブジェクト (パーティションキー、クラスタリングキーなど) を指定する必要があります。そのため、CRUD 操作に進む前に、`Key` オブジェクトの構築方法を次に説明します。
+
+単一の列キーの場合、次のように `Key.of()` メソッドを使用してキーを構築できます。
+
+```java
+// For a key that consists of a single column of INT.
+Key key1 = Key.ofInt("col1", 1);
+
+// For a key that consists of a single column of BIGINT.
+Key key2 = Key.ofBigInt("col1", 100L);
+
+// For a key that consists of a single column of DOUBLE.
+Key key3 = Key.ofDouble("col1", 1.3d);
+
+// For a key that consists of a single column of TEXT.
+Key key4 = Key.ofText("col1", "value");
+```
+
+2~5 列で設定されるキーの場合は、`Key.of()` メソッドを使用して次のようにキーを構築できます。Guava の `ImmutableMap.of()` と同様に、列名と値を順番に指定する必要があります。
+
+```java
+// For a key that consists of two to five columns.
+Key key1 = Key.of("col1", 1, "col2", 100L);
+Key key2 = Key.of("col1", 1, "col2", 100L, "col3", 1.3d);
+Key key3 = Key.of("col1", 1, "col2", 100L, "col3", 1.3d, "col4", "value");
+Key key4 = Key.of("col1", 1, "col2", 100L, "col3", 1.3d, "col4", "value", "col5", false);
+```
+
+5 列を超えるキーの場合は、ビルダーを使用して次のようにキーを構築できます。
+
+```java
+// For a key that consists of more than five columns.
+Key key = Key.newBuilder()
+ .addInt("col1", 1)
+ .addBigInt("col2", 100L)
+ .addDouble("col3", 1.3d)
+ .addText("col4", "value")
+ .addBoolean("col5", false)
+ .addInt("col6", 100)
+ .build();
+```
+
+##### `Get` 操作
+
+`Get` は、プライマリーキーで指定された単一のレコードを取得する操作です。
+
+まず `Get` オブジェクトを作成し、次に次のように `transaction.get()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Get` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .projections("c1", "c2", "c3", "c4")
+ .where(ConditionBuilder.column("c1").isNotEqualToInt(10))
+ .build();
+
+// Execute the `Get` operation.
+Optional result = transaction.get(get);
+```
+
+射影を指定して、返される列を選択できます。
+
+###### `WHERE` 句を使用する
+
+`where()` メソッドを使用して任意の条件を指定することもできます。取得したレコードが `where()` メソッドで指定された条件と一致しない場合は、`Option.empty()` が返されます。`where()` メソッドの引数として、条件、AND 条件セット、または OR 条件セットを指定できます。`where()` メソッドを呼び出した後、次のように `and()` メソッドまたは `or()` メソッドを使用して、さらに条件または条件セットを追加できます。
+
+```java
+// Create a `Get` operation with condition sets.
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .where(
+ ConditionSetBuilder.condition(ConditionBuilder.column("c1").isLessThanInt(10))
+ .or(ConditionBuilder.column("c1").isGreaterThanInt(20))
+ .build())
+ .and(
+ ConditionSetBuilder.condition(ConditionBuilder.column("c2").isLikeText("a%"))
+ .or(ConditionBuilder.column("c2").isLikeText("b%"))
+ .build())
+ .build();
+```
+
+:::note
+
+`where()` 条件メソッドチェーンでは、条件は上記の例のように `ConditionalExpression` または `OrConditionSet` の AND 結合 (結合正規形と呼ばれる)、または `ConditionalExpression` または `AndConditionSet` の OR 結合 (分離正規形と呼ばれる) である必要があります。
+
+:::
+
+使用可能な条件と条件セットの詳細については、使用している ScalarDB バージョンの [Javadoc](https://javadoc.io/doc/com.scalar-labs/scalardb/latest/index.html) の `ConditionBuilder` および `ConditionSetBuilder` ページを参照してください。
+
+###### `Result` オブジェクトの処理
+
+`Get` 操作と `Scan` 操作は `Result` オブジェクトを返します。次に、`Result` オブジェクトの処理方法を示します。
+
+次のように `get("")` メソッドを使用して、結果の列値を取得できます。
+
+```java
+// Get the BOOLEAN value of a column.
+boolean booleanValue = result.getBoolean("");
+
+// Get the INT value of a column.
+int intValue = result.getInt("");
+
+// Get the BIGINT value of a column.
+long bigIntValue = result.getBigInt("");
+
+// Get the FLOAT value of a column.
+float floatValue = result.getFloat("");
+
+// Get the DOUBLE value of a column.
+double doubleValue = result.getDouble("");
+
+// Get the TEXT value of a column.
+String textValue = result.getText("");
+
+// Get the BLOB value of a column as a `ByteBuffer`.
+ByteBuffer blobValue = result.getBlob("");
+
+// Get the BLOB value of a column as a `byte` array.
+byte[] blobValueAsBytes = result.getBlobAsBytes("");
+```
+
+列の値が null かどうかを確認する必要がある場合は、`isNull("")` メソッドを使用できます。
+
+``` java
+// Check if a value of a column is null.
+boolean isNull = result.isNull("");
+```
+
+詳細については、使用している ScalarDB のバージョンの [Javadoc](https://javadoc.io/doc/com.scalar-labs/scalardb/3.13.1/index.html) の `Result` ページを参照してください。
+
+###### セカンダリインデックスを使用して `Get` を実行する
+
+セカンダリインデックスを使用して `Get` 操作を実行できます。
+
+パーティションキーを指定する代わりに、次のようにインデックスキー (インデックス付き列) を指定してセカンダリインデックスを使用できます。
+
+```java
+// Create a `Get` operation by using a secondary index.
+Key indexKey = Key.ofFloat("c4", 1.23F);
+
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .indexKey(indexKey)
+ .projections("c1", "c2", "c3", "c4")
+ .where(ConditionBuilder.column("c1").isNotEqualToInt(10))
+ .build();
+
+// Execute the `Get` operation.
+Optional result = transaction.get(get);
+```
+
+`where()` メソッドを使用して任意の条件を指定することもできます。詳細については、[`WHERE` 句を使用する](#where-句を使用する)を参照してください。
+
+:::note
+
+結果に複数のレコードがある場合、`transaction.get()` は例外をスローします。複数の結果を処理する場合は、[セカンダリインデックスを使用して `Scan` を実行する](#セカンダリインデックスを使用して-scan-を実行する)を参照してください。
+
+:::
+
+##### `Scan` 操作
+
+`Scan` は、パーティション内の複数のレコードを取得する操作です。`Scan` 操作では、クラスタリングキーの境界とクラスタリングキー列の順序を指定できます。
+
+まず `Scan` オブジェクトを作成し、次に次のように `transaction.scan()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Scan` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key startClusteringKey = Key.of("c2", "aaa", "c3", 100L);
+Key endClusteringKey = Key.of("c2", "aaa", "c3", 300L);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .start(startClusteringKey, true) // Include startClusteringKey
+ .end(endClusteringKey, false) // Exclude endClusteringKey
+ .projections("c1", "c2", "c3", "c4")
+ .orderings(Scan.Ordering.desc("c2"), Scan.Ordering.asc("c3"))
+ .where(ConditionBuilder.column("c1").isNotEqualToInt(10))
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+List results = transaction.scan(scan);
+```
+
+クラスタリングキー境界を省略するか、`start` 境界または `end` 境界のいずれかを指定できます。`orderings` を指定しない場合は、テーブルの作成時に定義したクラスタリング順序で結果が並べられます。
+
+さらに、`projections` を指定して返される列を選択し、`limit` を使用して `Scan` 操作で返されるレコードの数を指定できます。
+
+###### `WHERE` 句を使用する
+
+`where()` メソッドを使用してスキャンされたレコードをフィルタリングすることで、任意の条件を指定することもできます。`where()` メソッドの引数として、条件、AND 条件セット、または OR 条件セットを指定できます。`where()` メソッドを呼び出した後、次のように `and()` メソッドまたは `or()` メソッドを使用して、さらに条件または条件セットを追加できます。
+
+```java
+// Create a `Scan` operation with condition sets.
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .where(
+ ConditionSetBuilder.condition(ConditionBuilder.column("c1").isLessThanInt(10))
+ .or(ConditionBuilder.column("c1").isGreaterThanInt(20))
+ .build())
+ .and(
+ ConditionSetBuilder.condition(ConditionBuilder.column("c2").isLikeText("a%"))
+ .or(ConditionBuilder.column("c2").isLikeText("b%"))
+ .build())
+ .limit(10)
+ .build();
+```
+
+:::note
+
+`where()` 条件メソッドチェーンでは、条件は上記の例のように `ConditionalExpression` または `OrConditionSet` の AND 結合 (結合正規形と呼ばれる)、または `ConditionalExpression` または `AndConditionSet` の OR 結合 (分離正規形と呼ばれる) である必要があります。
+
+:::
+
+使用可能な条件と条件セットの詳細については、使用している ScalarDB のバージョンの [Javadoc](https://javadoc.io/doc/com.scalar-labs/scalardb/latest/index.html) の `ConditionBuilder` および `ConditionSetBuilder` ページを参照してください。
+
+###### セカンダリインデックスを使用して `Scan` を実行する
+
+セカンダリインデックスを使用して、`Scan` 操作を実行できます。
+
+パーティションキーを指定する代わりに、次のようにインデックスキー (インデックス付き列) を指定してセカンダリインデックスを使用できます。
+
+```java
+// Create a `Scan` operation by using a secondary index.
+Key indexKey = Key.ofFloat("c4", 1.23F);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .indexKey(indexKey)
+ .projections("c1", "c2", "c3", "c4")
+ .where(ConditionBuilder.column("c1").isNotEqualToInt(10))
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+List results = transaction.scan(scan);
+```
+
+`where()` メソッドを使用して任意の条件を指定することもできます。詳細については、[`WHERE` 句を使用する](#where-句を使用する)を参照してください。
+
+:::note
+
+セカンダリインデックスを使用して、`Scan` でクラスタリングキーの境界と順序を指定することはできません。
+
+:::
+
+###### パーティションキーを指定せずにクロスパーティション `Scan` を実行し、テーブルのすべてのレコードを取得します
+
+ScalarDB プロパティファイルで次の設定を有効にすると、パーティションキーを指定せずに、すべてのパーティションにわたって `Scan` 操作 (クロスパーティションスキャン* と呼びます) を実行できます。
+
+```properties
+scalar.db.cross_partition_scan.enabled=true
+```
+
+:::warning
+
+非 JDBC データベースの場合、`SERIALIZABLE` 分離レベルでクロスパーティションスキャンを有効にした場合でも、トランザクションは読み取りコミットスナップショット分離 (`SNAPSHOT`) で実行される可能性があります。これは、より低い分離レベルです。非 JDBC データベースを使用する場合は、トランザクションの一貫性が重要でない場合にのみ、クロスパーティションスキャンを使用してください。
+
+:::
+
+ビルダーで `partitionKey()` メソッドを呼び出す代わりに、次のように `all()` メソッドを呼び出して、パーティションキーを指定せずにテーブルをスキャンできます。
+
+```java
+// Create a `Scan` operation without specifying a partition key.
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .projections("c1", "c2", "c3", "c4")
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+List results = transaction.scan(scan);
+```
+
+:::note
+
+非 JDBC データベースを使用する場合、クロスパーティション `Scan` で順序を指定することはできません。フィルタリングまたは順序付けを指定したクロスパーティション `Scan` の使用方法の詳細については、[フィルタリングと順序付けを使用してパーティション間の `Scan` を実行する](#フィルタリングと順序付けを使用してパーティション間の-scan-を実行する)を参照してください。
+
+:::
+
+###### フィルタリングと順序付けを使用してパーティション間の `Scan` を実行する
+
+次のようにフィルタリングと順序付けによるクロスパーティションスキャンオプションを有効にすると、柔軟な条件と順序付けでクロスパーティション `Scan` 操作を実行できます。
+
+```properties
+scalar.db.cross_partition_scan.enabled=true
+scalar.db.cross_partition_scan.filtering.enabled=true
+scalar.db.cross_partition_scan.ordering.enabled=true
+```
+
+:::note
+
+非 JDBC データベースでは `scalar.db.cross_partition_scan.ordering` を有効にすることはできません。
+
+:::
+
+次のように、`all()` メソッドを呼び出した後に `where()` メソッドと `ordering()` メソッドを呼び出して、任意の条件と順序を指定できます。
+
+```java
+// Create a `Scan` operation with arbitrary conditions and orderings.
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .where(ConditionBuilder.column("c1").isNotEqualToInt(10))
+ .projections("c1", "c2", "c3", "c4")
+ .orderings(Scan.Ordering.desc("c3"), Scan.Ordering.asc("c4"))
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+List results = transaction.scan(scan);
+```
+
+`WHERE` 句の詳細については、[`WHERE` 句を使用する](#where-句を使用する)を参照してください。
+
+##### `Put` 操作
+
+:::note
+
+`Put` 操作は ScalarDB 3.13 以降では非推奨となり、将来のリリースでは削除される予定です。`Put` 操作の代わりに、`Insert` 操作、`Upsert` 操作、または `Update` 操作を使用してください。
+
+:::
+
+`Put` は、プライマリーキーで指定されたレコードを配置する操作です。この操作はレコードの upsert 操作として動作し、レコードが存在する場合はレコードを更新し、レコードが存在しない場合はレコードを挿入します。
+
+:::note
+
+既存のレコードを更新する場合、`Put` 操作を使用する前に `Get` または `Scan` を使用してレコードを読み取る必要があります。そうしないと、競合により操作が失敗します。これは、トランザクションを適切に管理するための ScalarDB の仕様により発生します。レコードを明示的に読み取る代わりに、暗黙的な事前読み取りを有効にできます。詳細については、[`Put` 操作の暗黙的な事前読み取りを有効にする](#put-操作の暗黙的な事前読み取りを有効にする)を参照してください。
+
+:::
+
+まず `Put` オブジェクトを作成し、次に次のように `transaction.put()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Put` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Put` operation.
+transaction.put(put);
+```
+
+次のように `null` 値を持つレコードを配置することもできます。
+
+```java
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", null)
+ .doubleValue("c5", null)
+ .build();
+```
+
+###### `Put` 操作の暗黙的な事前読み取りを有効にする
+
+Consensus Commit では、レコードが存在する場合、レコードの最新の状態を取得するために、アプリケーションは `Put` および `Delete` 操作でレコードを変更する前にレコードを読み取る必要があります。レコードを明示的に読み取る代わりに、*暗黙的な事前読み取り* を有効にすることができます。暗黙的な事前読み取りを有効にすると、アプリケーションがトランザクションでレコードを明示的に読み取らない場合は、ScalarDB がトランザクションをコミットする前にアプリケーションに代わってレコードを読み取ります。
+
+`Put` 操作の暗黙的な事前読み取りを有効にするには、次のように `Put` 操作ビルダーで `enableImplicitPreRead()` を指定します。
+
+```java
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .enableImplicitPreRead()
+ .build();
+```
+
+:::note
+
+変更しようとしているレコードが存在しないことが確実な場合は、パフォーマンスを向上させるために、`Put` 操作の暗黙的な事前読み取りを有効にしないでください。たとえば、初期データをロードする場合は、暗黙的な事前読み取りを有効にしないでください。暗黙的な事前読み取りのない `Put` 操作は、暗黙的な事前読み取りのある `Put` 操作よりも高速です。これは、操作によって不要な読み取りがスキップされるためです。
+
+:::
+
+##### `Insert` 操作
+
+`Insert` は、トランザクションを通じて基礎となるストレージにエントリを挿入する操作です。エントリがすでに存在する場合は、競合エラーが発生します。
+
+まず `Insert` オブジェクトを作成し、次に次のように `transaction.insert()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Insert` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Insert insert =
+ Insert.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Insert` operation.
+transaction.insert(insert);
+```
+
+##### `Upsert` 操作
+
+`Upsert` は、トランザクションを通じて基礎となるストレージにエントリを挿入したり、エントリを更新したりする操作です。エントリがすでに存在する場合は更新され、そうでない場合はエントリが挿入されます。
+
+まず `Upsert` オブジェクトを作成し、次に次のように `transaction.upsert()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Upsert` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Upsert upsert =
+ Upsert.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Upsert` operation.
+transaction.upsert(upsert);
+```
+
+##### `Update` 操作
+
+`Update` は、トランザクションを通じて基礎となるストレージ内のエントリを更新する操作です。エントリが存在しない場合、操作によって変更は行われません。
+
+まず `Update` オブジェクトを作成し、次に次のように `transaction.update()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Update` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Update update =
+ Update.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Update` operation.
+transaction.update(update);
+```
+
+##### `Delete` 操作
+
+`Delete` は、プライマリーキーで指定されたレコードを削除する操作です。
+
+:::note
+
+レコードを削除する場合、`Delete` 操作では暗黙的な事前読み取りが常に有効になっているため、事前にレコードを読み取る必要はありません。
+
+:::
+
+まず `Delete` オブジェクトを作成し、次に次のように `transaction.delete()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Delete` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .build();
+
+// Execute the `Delete` operation.
+transaction.delete(delete);
+```
+
+##### 条件付きの `Put`、`Delete`、`Update`
+
+トランザクション内で条件をチェックするロジックを実装することで、コミット前にトランザクションが満たす必要のある任意の条件 (たとえば、銀行口座の残高が 0 以上である必要がある) を記述できます。または、`Put`、`Delete`、`Update` などのミューテーション操作で単純な条件を記述することもできます。
+
+`Put`、`Delete`、`Update` 操作に条件が含まれている場合、指定された条件が満たされた場合にのみ操作が実行されます。操作の実行時に条件が満たされていない場合は、`UnsatisfiedConditionException` という例外がスローされます。
+
+:::note
+
+`Put` 操作で条件を指定する場合は、事前にレコードを読み取るか、暗黙的な事前読み取りを有効にする必要があります。
+
+:::
+
+###### `Put` の条件
+
+`Put` 操作では、次のように条件を指定できます。
+
+```java
+// Build a condition.
+MutationCondition condition =
+ ConditionBuilder.putIf(ConditionBuilder.column("c4").isEqualToFloat(0.0F))
+ .and(ConditionBuilder.column("c5").isEqualToDouble(0.0))
+ .build();
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .condition(condition) // condition
+ .build();
+
+// Execute the `Put` operation.
+transaction.put(put);
+```
+
+`putIf` 条件を使用するだけでなく、次のように `putIfExists` 条件と `putIfNotExists` 条件を指定することもできます。
+
+```java
+// Build a `putIfExists` condition.
+MutationCondition putIfExistsCondition = ConditionBuilder.putIfExists();
+
+// Build a `putIfNotExists` condition.
+MutationCondition putIfNotExistsCondition = ConditionBuilder.putIfNotExists();
+```
+
+###### `Delete` の条件
+
+`Delete` 操作では、次のように条件を指定できます。
+
+```java
+// Build a condition.
+MutationCondition condition =
+ ConditionBuilder.deleteIf(ConditionBuilder.column("c4").isEqualToFloat(0.0F))
+ .and(ConditionBuilder.column("c5").isEqualToDouble(0.0))
+ .build();
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .condition(condition) // condition
+ .build();
+
+// Execute the `Delete` operation.
+transaction.delete(delete);
+```
+
+`deleteIf` 条件を使用するだけでなく、次のように `deleteIfExists` 条件を指定することもできます。
+
+```java
+// Build a `deleteIfExists` condition.
+MutationCondition deleteIfExistsCondition = ConditionBuilder.deleteIfExists();
+```
+
+###### `Update` の条件
+
+`Update` 操作では、次のように条件を指定できます。
+
+```java
+// Build a condition.
+MutationCondition condition =
+ ConditionBuilder.updateIf(ConditionBuilder.column("c4").isEqualToFloat(0.0F))
+ .and(ConditionBuilder.column("c5").isEqualToDouble(0.0))
+ .build();
+
+Update update =
+ Update.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .condition(condition) // condition
+ .build();
+
+// Execute the `Update` operation.
+transaction.update(update);
+```
+
+`updateIf` 条件を使用するだけでなく、次のように `updateIfExists` 条件を指定することもできます。
+
+```java
+// Build a `updateIfExists` condition.
+MutationCondition updateIfExistsCondition = ConditionBuilder.updateIfExists();
+```
+
+##### Mutate 操作
+
+Mutate は、`Put`、`Insert`、`Upsert`、`Update`、`Delete` の複数の操作を実行する操作です。
+
+まず Mutate オブジェクトを作成し、次に次のように `transaction.mutate()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create `Put` and `Delete` operations.
+Key partitionKey = Key.ofInt("c1", 10);
+
+Key clusteringKeyForPut = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForPut)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+Key clusteringKeyForDelete = Key.of("c2", "bbb", "c3", 200L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForDelete)
+ .build();
+
+// Execute the operations.
+transaction.mutate(Arrays.asList(put, delete));
+```
+
+##### CRUD 操作のデフォルト名前空間
+
+すべての CRUD 操作のデフォルト名前空間は、ScalarDB 設定のプロパティを使用して設定できます。
+
+```properties
+scalar.db.default_namespace_name=
+```
+
+名前空間を指定しない操作では、設定されたデフォルトの名前空間が使用されます。
+
+```java
+// This operation will target the default namespace.
+Scan scanUsingDefaultNamespace =
+ Scan.newBuilder()
+ .table("tbl")
+ .all()
+ .build();
+// This operation will target the "ns" namespace.
+Scan scanUsingSpecifiedNamespace =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .build();
+```
+
+#### トランザクションをコミットする
+
+CRUD 操作を実行した後、トランザクションをコミットして終了する必要があります。
+
+トランザクションは次のようにコミットできます。
+
+```java
+// Commit a transaction.
+transaction.commit();
+```
+
+#### トランザクションをロールバックまたはアボートする
+
+トランザクションの実行中にエラーが発生した場合は、トランザクションをロールバックまたはアボートできます。
+
+トランザクションは次のようにロールバックできます。
+
+```java
+// Roll back a transaction.
+transaction.rollback();
+```
+
+または、次のようにトランザクションをアボートすることもできます。
+
+```java
+// Abort a transaction.
+transaction.abort();
+```
+
+ScalarDB で例外を処理する方法の詳細については、[例外の処理方法](#例外の処理方法)を参照してください。
+
+### トランザクションを開始せずにトランザクションを実行する
+
+トランザクションを開始せずにトランザクション操作を実行できます。この場合、ScalarDB は操作を実行する前に自動的にトランザクションを開始し、操作の実行後にトランザクションをコミットします。このセクションでは、トランザクションを開始せずにトランザクションを実行する方法について説明します。
+
+#### `Get` 操作を実行する
+
+`Get` は、プライマリーキーで指定された単一のレコードを取得する操作です。
+
+最初に `Get` オブジェクトを作成し、次に次のように `transactionManager.get()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Get` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .projections("c1", "c2", "c3", "c4")
+ .build();
+
+// Execute the `Get` operation.
+Optional result = transactionManager.get(get);
+```
+
+`Get` 操作の詳細については、[`Get` 操作](#get-操作)を参照してください。
+
+#### `Scan` 操作の実行
+
+`Scan` は、パーティション内の複数のレコードを取得する操作です。`Scan` 操作では、クラスタリングキーの境界とクラスタリングキー列の順序を指定できます。
+
+まず `Scan` オブジェクトを作成し、次に次のように `transactionManager.scan()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Scan` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key startClusteringKey = Key.of("c2", "aaa", "c3", 100L);
+Key endClusteringKey = Key.of("c2", "aaa", "c3", 300L);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .start(startClusteringKey, true) // Include startClusteringKey
+ .end(endClusteringKey, false) // Exclude endClusteringKey
+ .projections("c1", "c2", "c3", "c4")
+ .orderings(Scan.Ordering.desc("c2"), Scan.Ordering.asc("c3"))
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+List results = transactionManager.scan(scan);
+```
+
+`Scan` 操作の詳細については、[`Scan` 操作](#scan-操作)を参照してください。
+
+#### `Put` 操作を実行します
+
+:::note
+
+`Put` 操作は ScalarDB 3.13 以降では非推奨となり、将来のリリースでは削除される予定です。`Put` 操作の代わりに、`Insert` 操作、`Upsert` 操作、または `Update` 操作を使用してください。
+
+:::
+
+まず `Put` オブジェクトを作成し、次に次のように `transactionManager.put()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Put` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Put` operation.
+transactionManager.put(put);
+```
+
+`Put` 操作の詳細については、[`Put` 操作](#put-操作)を参照してください。
+
+#### `Insert` 操作の実行
+
+`Insert` は、トランザクションを通じて基礎となるストレージにエントリを挿入する操作です。エントリがすでに存在する場合は、競合エラーが発生します。
+
+まず `Insert` オブジェクトを作成し、次に次のように `transactionManager.insert()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Insert` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Insert insert =
+ Insert.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Insert` operation.
+transactionManager.insert(insert);
+```
+
+`Insert` 操作の詳細については、[`Insert` 操作](#insert-操作)を参照してください。
+
+#### `Upsert` 操作を実行する
+
+`Upsert` は、トランザクションを通じて基礎となるストレージにエントリを挿入するか、エントリを更新する操作です。エントリがすでに存在する場合は更新され、そうでない場合はエントリが挿入されます。
+
+まず `Upsert` オブジェクトを作成し、次に次のように `transactionManager.upsert()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Upsert` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Upsert upsert =
+ Upsert.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Upsert` operation.
+transactionManager.upsert(upsert);
+```
+
+`Insert` 操作の詳細については、[`Upsert` 操作](#upsert-操作)を参照してください。
+
+#### `Update` 操作の実行
+
+`Update` は、トランザクションを通じて基礎となるストレージ内のエントリを更新する操作です。エントリが存在しない場合、操作によって変更は行われません。
+
+まず `Update` オブジェクトを作成し、次に次のように `transactionManager.update()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create an `Update` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Update update =
+ Update.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Update` operation.
+transactionManager.update(update);
+```
+
+`Update` 操作の詳細については、[`Update` 操作](#update-操作)を参照してください。
+
+#### `Delete` 操作を実行する
+
+`Delete` は、プライマリーキーで指定されたレコードを削除する操作です。
+
+まず `Delete` オブジェクトを作成し、次に次のように `transaction.delete()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Delete` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .build();
+
+// Execute the `Delete` operation.
+transactionManager.delete(delete);
+```
+
+`Delete` 操作の詳細については、[`Delete` 操作](#delete-操作)を参照してください。
+
+#### Mutate 操作の実行
+
+Mutate は、複数のミューテーション (`Put`、`Insert`、`Upsert`、`Update`、および `Delete` 操作) を実行する操作です。
+
+まずミューテーションオブジェクトを作成し、次に次のように `transactionManager.mutate()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create `Put` and `Delete` operations.
+Key partitionKey = Key.ofInt("c1", 10);
+
+Key clusteringKeyForPut = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForPut)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+Key clusteringKeyForDelete = Key.of("c2", "bbb", "c3", 200L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForDelete)
+ .build();
+
+// Execute the operations.
+transactionManager.mutate(Arrays.asList(put, delete));
+```
+
+Mutate 操作の詳細については、[Mutate 操作](#mutate-操作)を参照してください。
+
+また、ScalarDB での例外の処理方法の詳細については、[例外の処理方法](#例外の処理方法)を参照してください。
+
+## 例外の処理方法
+
+トランザクションを実行するときは、例外も適切に処理する必要があります。
+
+:::warning
+
+例外を適切に処理しないと、異常やデータの不整合が発生する可能性があります。
+
+:::
+
+次のサンプルコードは、例外を処理する方法を示しています。
+
+```java
+public class Sample {
+ public static void main(String[] args) throws Exception {
+ TransactionFactory factory = TransactionFactory.create("");
+ DistributedTransactionManager transactionManager = factory.getTransactionManager();
+
+ int retryCount = 0;
+ TransactionException lastException = null;
+
+ while (true) {
+ if (retryCount++ > 0) {
+ // Retry the transaction three times maximum.
+ if (retryCount >= 3) {
+ // Throw the last exception if the number of retries exceeds the maximum.
+ throw lastException;
+ }
+
+ // Sleep 100 milliseconds before retrying the transaction.
+ TimeUnit.MILLISECONDS.sleep(100);
+ }
+
+ DistributedTransaction transaction = null;
+ try {
+ // Begin a transaction.
+ transaction = transactionManager.begin();
+
+ // Execute CRUD operations in the transaction.
+ Optional result = transaction.get(...);
+ List results = transaction.scan(...);
+ transaction.put(...);
+ transaction.delete(...);
+
+ // Commit the transaction.
+ transaction.commit();
+ } catch (UnsatisfiedConditionException e) {
+ // You need to handle `UnsatisfiedConditionException` only if a mutation operation specifies a condition.
+ // This exception indicates the condition for the mutation operation is not met.
+
+ try {
+ transaction.rollback();
+ } catch (RollbackException ex) {
+ // Rolling back the transaction failed. Since the transaction should eventually recover,
+ // you don't need to do anything further. You can simply log the occurrence here.
+ }
+
+ // You can handle the exception here, according to your application requirements.
+
+ return;
+ } catch (UnknownTransactionStatusException e) {
+ // If you catch `UnknownTransactionStatusException` when committing the transaction,
+ // it indicates that the status of the transaction, whether it was successful or not, is unknown.
+ // In such a case, you need to check if the transaction is committed successfully or not and
+ // retry the transaction if it failed. How to identify a transaction status is delegated to users.
+ return;
+ } catch (TransactionException e) {
+ // For other exceptions, you can try retrying the transaction.
+
+ // For `CrudConflictException`, `CommitConflictException`, and `TransactionNotFoundException`,
+ // you can basically retry the transaction. However, for the other exceptions, the transaction
+ // will still fail if the cause of the exception is non-transient. In such a case, you will
+ // exhaust the number of retries and throw the last exception.
+
+ if (transaction != null) {
+ try {
+ transaction.rollback();
+ } catch (RollbackException ex) {
+ // Rolling back the transaction failed. The transaction should eventually recover,
+ // so you don't need to do anything further. You can simply log the occurrence here.
+ }
+ }
+
+ lastException = e;
+ }
+ }
+ }
+}
+```
+
+### `TransactionException` および `TransactionNotFoundException`
+
+`begin()` API は `TransactionException` または `TransactionNotFoundException` をスローする可能性があります:
+
+- `TransactionException` をキャッチした場合、この例外は、一時的または非一時的障害が原因でトランザクションを開始できなかったことを示します。トランザクションを再試行することはできますが、非一時的障害が原因でトランザクションを開始できない可能性があります。
+- `TransactionNotFoundException` をキャッチした場合、この例外は、一時的障害が原因でトランザクションを開始できなかったことを示します。この場合、トランザクションを再試行できます。
+
+`join()` API も `TransactionNotFoundException` をスローする可能性があります。この例外は、`begin()` API の例外を処理するのと同じ方法で処理できます。
+
+### `CrudException` および `CrudConflictException`
+
+CRUD 操作の API (`get()`、`scan()`、`put()`、`delete()`、および `mutate()`) は、`CrudException` または `CrudConflictException` をスローする可能性があります:
+
+- `CrudException` をキャッチした場合、この例外は、一時的または非一時的障害が原因でトランザクション CRUD 操作が失敗したことを示します。トランザクションを最初から再試行できますが、原因が非一時的である場合は、トランザクションが失敗する可能性があります。
+- `CrudConflictException` をキャッチした場合、この例外は、一時的な障害 (競合エラーなど) が原因でトランザクション CRUD 操作が失敗したことを示します。この場合、トランザクションを最初から再試行できます。
+
+### `UnsatisfiedConditionException`
+
+ミューテーション操作の API (`put()`、`delete()`、および `mutate()`) も `UnsatisfiedConditionException` をスローする可能性があります。
+
+`UnsatisfiedConditionException` をキャッチした場合、この例外はミューテーション操作の条件が満たされていないことを示します。この例外は、アプリケーションの要件に従って処理できます。
+
+### `CommitException`、`CommitConflictException`、および `UnknownTransactionStatusException`
+
+`commit()` API は `CommitException`、`CommitConflictException`、または `UnknownTransactionStatusException` をスローする可能性があります。
+
+- `CommitException` をキャッチした場合、この例外は、一時的または非一時的障害が原因でトランザクションのコミットが失敗したことを示します。トランザクションを最初から再試行できますが、原因が非一時的である場合はトランザクションが失敗する可能性があります。
+- `CommitConflictException` をキャッチした場合、この例外は、一時的な障害 (競合エラーなど) が原因でトランザクションのコミットが失敗したことを示します。この場合、トランザクションを最初から再試行できます。
+- `UnknownTransactionStatusException` をキャッチした場合、この例外は、トランザクションのステータス (成功したかどうか) が不明であることを示します。この場合、トランザクションが正常にコミットされたかどうかを確認し、失敗した場合はトランザクションを再試行する必要があります。
+
+トランザクションステータスを識別する方法は、ユーザーに委任されています。トランザクションステータステーブルを作成し、他のアプリケーションデータを使用してトランザクション的に更新して、ステータステーブルからトランザクションのステータスを取得できるようにすることができます。
+
+### 一部の例外に関する注意
+
+サンプルコードには示されていませんが、`resume()` API は `TransactionNotFoundException` をスローする可能性もあります。この例外は、指定された ID に関連付けられたトランザクションが見つからなかったか、トランザクションの有効期限が切れた可能性があることを示します。いずれの場合も、この例外の原因は基本的に一時的なものであるため、トランザクションを最初から再試行できます。
+
+サンプルコードでは、`UnknownTransactionStatusException` の場合、重複操作の可能性を回避するためにアプリケーションがトランザクションが成功したかどうかを確認する必要があるため、トランザクションは再試行されません。その他の例外の場合、例外の原因が一時的または非一時的であるため、トランザクションは再試行されます。例外の原因が一時的な場合、再試行するとトランザクションが成功する可能性があります。ただし、例外の原因が非一時的である場合、再試行してもトランザクションは失敗します。このような場合、再試行回数を使い果たします。
+
+:::note
+
+サンプルコードでは、トランザクションは最大 3 回再試行され、再試行される前に 100 ミリ秒間スリープします。ただし、アプリケーションの要件に応じて、指数バックオフなどの再試行ポリシーを選択できます。
+
+:::
+
+## Coordinator テーブルのグループコミット
+
+Consensus Commit トランザクションに使用される Coordinator テーブルは重要なデータストアであり、堅牢なストレージを使用することをお勧めします。ただし、内部でマルチ AZ またはマルチリージョンレプリケーションを活用するなど、より堅牢なストレージオプションを使用すると、ストレージにレコードを書き込むときにレイテンシが増加し、スループットパフォーマンスが低下する可能性があります。
+
+ScalarDB は、Coordinator テーブルにグループコミット機能を提供します。この機能は、複数のレコードの書き込みを 1 つの書き込み操作にグループ化し、書き込みスループットを向上させます。この場合、基盤となるデータベースとワークロードに応じて、レイテンシが増加または減少する可能性があります。
+
+グループコミット機能を有効にするには、次の設定を追加します。
+
+```properties
+# By default, this configuration is set to `false`.
+scalar.db.consensus_commit.coordinator.group_commit.enabled=true
+
+# These properties are for tuning the performance of the group commit feature.
+# scalar.db.consensus_commit.coordinator.group_commit.group_size_fix_timeout_millis=40
+# scalar.db.consensus_commit.coordinator.group_commit.delayed_slot_move_timeout_millis=800
+# scalar.db.consensus_commit.coordinator.group_commit.old_group_abort_timeout_millis=30000
+# scalar.db.consensus_commit.coordinator.group_commit.timeout_check_interval_millis=10
+# scalar.db.consensus_commit.coordinator.group_commit.metrics_monitor_log_enabled=true
+```
+
+### 制限事項
+
+このセクションでは、グループコミット機能の制限事項について説明します。
+
+#### ユーザーが渡したカスタムトランザクション ID
+
+グループコミット機能は、内部値を暗黙的に生成し、それをトランザクション ID の一部として使用します。したがって、ユーザーが `com.scalar.db.transaction.consensuscommit.ConsensusCommitManager.begin(String txId)` または `com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitManager.begin(String txId)` を介して手動で渡したカスタムトランザクション ID は、その後の API 呼び出しでそのまま使用することはできません。代わりに、`com.scalar.db.transaction.consensuscommit.ConsensusCommit.getId()` または `com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommit.getId()` から返されたトランザクション ID を使用する必要があります。
+
+```java
+ // This custom transaction ID needs to be used for ScalarDB transactions.
+ String myTxId = UUID.randomUUID().toString();
+
+ ...
+
+ DistributedTransaction transaction = manager.begin(myTxId);
+
+ ...
+
+ // When the group commit feature is enabled, a custom transaction ID passed by users can't be used as is.
+ // logger.info("The transaction state: {}", manager.getState(myTxId));
+ logger.info("The transaction state: {}", manager.getState(transaction.getId()));
+```
+
+#### 2 フェーズコミットインターフェースでの使用の禁止
+
+グループコミット機能は、進行中のすべてのトランザクションをメモリ内で管理します。この機能が 2 フェーズコミットインターフェースで有効になっている場合、Coordinator テーブルへの参加者サービスの一貫性のない書き込みによって生じる競合 (グループ間で異なるトランザクション分散が含まれる場合があります) を防ぐために、情報は Coordinator サービスによってのみ維持される必要があります。
+
+この制限により、アプリケーション開発に関連する複雑さと柔軟性が損なわれます。したがって、グループコミット機能と 2 フェーズコミットインターフェースを組み合わせて使用することは現在禁止されています。
+
+## Consensus Commit トランザクションマネージャーエラーの調査
+
+Consensus Commit トランザクションマネージャーの使用時にエラーを調査するには、トランザクションメタデータ列が追加されたテーブルメタデータを返す設定を有効にできます。これは、トランザクション関連の問題を調査するときに役立ちます。この設定は、Consensus Commit トランザクションマネージャーのトラブルシューティング時にのみ使用可能で、`DistributedTransactionAdmin.getTableMetadata()` メソッドを使用して、特定のテーブルのトランザクションメタデータ列の詳細を表示できます。
+
+次の設定を追加すると、`Get` および `Scan` 操作の結果に [トランザクションメタデータ](schema-loader.mdx#consensus-commit-の内部メタデータ)が含まれます。
+
+```properties
+# By default, this configuration is set to `false`.
+scalar.db.consensus_commit.include_metadata.enabled=true
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/backup-restore.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/backup-restore.mdx
new file mode 100644
index 00000000..f97ba2f6
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/backup-restore.mdx
@@ -0,0 +1,180 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB で使用されるデータベースのバックアップと復元方法
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB は非トランザクションデータベースまたはトランザクションデータベース上で非侵入的にトランザクション機能を提供するため、トランザクション的に一貫性のある方法でデータベースをバックアップおよび復元するには特別な注意が必要です。
+
+このガイドでは、ScalarDB がサポートするデータベースをバックアップおよび復元する方法について説明します。
+
+## バックアップを作成する
+
+バックアップの作成方法は、使用しているデータベースと、複数のデータベースを使用しているかどうかによって異なります。次の決定ツリーは、どのアプローチを取るべきかを示しています。
+
+```mermaid
+flowchart TD
+ A[ScalarDB で単一のデータベースを使用していますか?]
+ A -->|はい| B[データベースはトランザクションをサポートしていますか?]
+ B -->|はい| C[明示的に一時停止せずにバックアップを実行します]
+ B ---->|いいえ| D[明示的な一時停止を伴うバックアップを実行します]
+ A ---->|いいえ| D
+```
+
+### 明示的に一時停止せずにバックアップする
+
+トランザクションをサポートする単一のデータベースで ScalarDB を使用している場合は、ScalarDB がトランザクションを受け入れ続けている間でも、データベースのバックアップを作成できます。
+
+:::warning
+
+バックアップを作成する前に、データベースのトランザクション的に一貫性のあるバックアップを作成する最も安全な方法を検討し、バックアッププロセスに関連するリスクを理解する必要があります。
+
+:::
+
+ScalarDB でバックアップを作成するための要件の 1 つは、ScalarDB が管理するすべてのテーブル (Coordinator テーブルを含む) のバックアップがトランザクション的に一貫しているか、トランザクション的に一貫した状態に自動的に回復可能である必要があることです。つまり、すべてのテーブルを 1 回のトランザクションでダンプして、一貫性のあるバックアップを作成する必要があります。
+
+トランザクション的に一貫性のあるバックアップを作成する方法は、使用しているデータベースの種類によって異なります。データベースを選択して、ScalarDB のトランザクション的に一貫性のあるバックアップを作成する方法を確認してください。
+
+:::note
+
+以下にリストされているデータベース別のバックアップ方法は、ScalarDB がサポートするデータベースの一部の例にすぎません。
+
+:::
+
+
+
+ 自動バックアップ機能を使用すると、バックアップ保持期間内の任意の時点に復元できます。
+
+
+ `--single-transaction` オプションを指定した `mysqldump` コマンドを使用します。
+
+
+ `pg_dump` コマンドを使用します。
+
+
+ [Special commands to sqlite3 (dot-commands)](https://www.sqlite.org/cli.html#special_commands_to_sqlite3_dot_commands_) で指定されているように、`.backup` コマンドを `.timeout` コマンドとともに使用します。
+
+ 例については、[BASH: SQLite3 .backup command](https://stackoverflow.com/questions/23164445/bash-sqlite3-backup-command) を参照してください。
+
+
+ クラスターはバックアップポリシーに基づいて自動的にバックアップされ、これらのバックアップは特定の期間保持されます。オンデマンドバックアップを実行することもできます。バックアップの実行の詳細については、[YugabyteDB Managed: Back up and restore clusters](https://docs.yugabyte.com/preview/yugabyte-cloud/cloud-clusters/backup-clusters/)を参照してください。
+
+
+
+### 明示的に一時停止してバックアップする
+
+トランザクション的に一貫性のあるバックアップを作成する別の方法は、ScalarDB インスタンスのクラスターに未処理のトランザクションがないときにバックアップを作成することです。バックアップの作成は、次の条件によって異なります。
+
+- 基盤となるデータベースにポイントインタイムスナップショットまたはバックアップ機能がある場合は、未処理のトランザクションが存在しない期間にバックアップを作成できます。
+- 基盤となるデータベースにポイントインタイムリストアまたはリカバリ (PITR) 機能がある場合は、一時停止期間内の未処理のトランザクションが存在しない時間 (できれば中間時間) にリストアポイントを設定できます。
+
+:::note
+
+PITR 機能を使用する場合は、NTP などのクロック同期を使用して、クライアントとサーバー間のクロックのずれを最小限に抑える必要があります。そうしないと、一時停止期間として取得される時間が、一時停止が実際に行われた時間と大きく異なる可能性があり、バックアップが進行中のトランザクションが存在する時点に復元される可能性があります。
+
+また、クロック同期ではノード間のクロックを完全に同期できないため、十分な時間 (たとえば、5 秒) 一時停止し、一時停止期間の中間時間を復元ポイントとして使用する必要があります。
+
+:::
+
+ScalarDB が未処理のリクエストを排出し、新しいリクエストの受け入れを停止して一時停止期間を作成できるようにするには、ScalarDB を使用するアプリケーションで [Scalar Admin](https://github.com/scalar-labs/scalar-admin) インターフェースを適切に実装するか、Scalar Admin インターフェースを実装する [ScalarDB Cluster](scalardb-cluster/index.mdx) を使用する必要があります。
+
+[Scalar Admin クライアントツール](https://github.com/scalar-labs/scalar-admin/tree/main/java#scalar-admin-client-tool)を使用すると、進行中のトランザクションを失うことなく、Scalar Admin インターフェースを実装するノード、サーバー、またはアプリケーションを一時停止できます。
+
+トランザクション的に一貫性のあるバックアップを作成する方法は、使用しているデータベースの種類によって異なります。データベースを選択して、ScalarDB のトランザクション的に一貫性のあるバックアップを作成する方法を確認します。
+
+:::note
+
+以下にリストされているデータベース別のバックアップ方法は、ScalarDB がサポートするデータベースの一部の例にすぎません。
+
+:::
+
+
+
+ DynamoDB テーブルに対して PITR 機能を有効にする必要があります。[ScalarDB Schema Loader](schema-loader.mdx) を使用してスキーマを作成する場合、ツールはデフォルトでテーブルの PITR 機能を有効にします。
+
+ トランザクション的に一貫性のある復元ポイントを指定するには、[明示的な一時停止によるバックアップ](#明示的に一時停止してバックアップする)の説明に従って、ScalarDB を DynamoDB とともに使用しているアプリケーションを一時停止します。
+
+
+ PITR 機能が有効になっている継続的バックアップポリシーを使用して、Cosmos DB for NoSQL アカウントを作成する必要があります。この機能を有効にすると、バックアップが継続的に作成されます。
+
+ トランザクション的に一貫性のある復元ポイントを指定するには、[明示的に一時停止してバックアップする](#明示的に一時停止してバックアップする)の説明に従って、ScalarDB を Cosmos DB for NoSQL とともに使用しているアプリケーションを一時停止します。
+
+
+ Cassandra にはレプリケーション機能が組み込まれているため、必ずしもトランザクション的に一貫性のあるバックアップを作成する必要はありません。たとえば、レプリケーション係数が `3` に設定されていて、Cassandra クラスター内のノードの 1 つのデータのみが失われた場合、通常のトランザクション的に一貫性のないバックアップ (スナップショット) と修復機能を使用してノードを回復できるため、トランザクション的に一貫性のあるバックアップ (スナップショット) は必要ありません。
+
+ ただし、クラスターノードのクォーラムでデータが失われた場合は、クラスターを特定のトランザクション的に一貫性のあるポイントに復元するために、トランザクション的に一貫性のあるバックアップ (スナップショット) が必要になります。
+
+ トランザクション的に一貫性のあるクラスター全体のバックアップ (スナップショット) を作成するには、ScalarDB または [ScalarDB Cluster](scalardb-cluster/index.mdx) を使用しているアプリケーションを一時停止し、[明示的な一時停止によるバックアップ](#明示的に一時停止してバックアップする)の説明に従ってノードのバックアップ (スナップショット) を作成するか、Cassandra クラスターを停止してノード内のすべてのデータのコピーを作成し、クラスターを起動します。
+
+
+ 一時停止期間中にオンデマンドバックアップまたはスケジュールされたバックアップを実行できます。バックアップの実行の詳細については、[YugabyteDB Managed: Back up and restore clusters](https://docs.yugabyte.com/preview/yugabyte-cloud/cloud-clusters/backup-clusters/) を参照してください。
+
+
+
+## バックアップを復元する
+
+トランザクション的に一貫性のあるバックアップを復元する方法は、使用しているデータベースの種類によって異なります。データベースを選択して、ScalarDB のトランザクション的に一貫性のあるバックアップを作成する方法を確認してください。
+
+:::note
+
+以下にリストされているデータベース別の復元方法は、ScalarDB がサポートするデータベースの一部の例にすぎません。
+
+:::
+
+
+
+ 自動バックアップ機能を使用すると、バックアップ保持期間内の任意の時点に復元できます。
+
+
+ まず、Cassandra クラスターのすべてのノードを停止します。次に、`data`、`commitlog`、`hints` ディレクトリをクリーンアップし、各ノードにバックアップ (スナップショット) を配置します。
+
+ 各ノードにバックアップ (スナップショット) を配置したら、Cassandra クラスターのすべてのノードを起動します。
+
+
+ [Azure portal を使用してアカウントを復元する](https://docs.microsoft.com/ja-jp/azure/cosmos-db/restore-account-continuous-backup#restore-account-portal)については、Azure の公式ドキュメントに従ってください。バックアップを復元した後、復元されたデータベースの [既定の整合性レベルを構成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/how-to-manage-consistency#configure-the-default-consistency-level)を `STRONG` に設定します。さらに、前述のように、一時停止期間の中間時点を復元ポイントとして使用する必要があります。
+
+ ScalarDB は、ScalarDB Schema Loader を使用してスキーマを作成するときにインストールされるストアドプロシージャを使用して、Cosmos DB アダプターを実装します。ただし、Cosmos DB の PITR 機能では、ストアドプロシージャは復元されません。このため、復元後にすべてのテーブルに必要なストアドプロシージャを再インストールする必要があります。これは、ScalarDB Schema Loader を `--repair-all` オプションとともに使用することで実行できます。詳細については、[名前空間とテーブルを修復する](schema-loader.mdx#名前空間とテーブルを修復する)を参照してください。
+
+
+ [DynamoDB テーブルを特定の時点に復元](https://docs.aws.amazon.com/ja_jp/amazondynamodb/latest/developerguide/PointInTimeRecovery.Tutorial.html)については、公式の AWS ドキュメントに従ってください。ただし、テーブルはエイリアスを使用してのみ復元できることに注意してください。このため、エイリアスを使用してテーブルを復元し、元のテーブルを削除して、エイリアスを元の名前に変更し、同じ名前のテーブルを復元する必要があります。
+
+ この手順を実行するには、次の手順を実行します。
+
+ 1. バックアップを作成します。
+ 1. 一時停止期間の中間時点を復元ポイントとして選択します。
+ 2. テーブル A の PITR を使用してテーブル B に復元します。
+ 3. 復元されたテーブル B のバックアップを作成します (バックアップの名前がバックアップ B であると仮定します)。
+ 4. テーブル B を削除します。
+ 2. バックアップを復元します。
+ 1. テーブル A を削除します。
+ 2. バックアップ B を使用して A という名前のテーブルを作成します。
+
+:::note
+
+* テーブルは一度に 1 つしか復元できないため、上記の手順はテーブルごとに実行する必要があります。
+* 復元されたテーブルでは、PITR や自動スケーリングポリシーなどの設定がデフォルト値にリセットされるため、必要な設定を手動で行う必要があります。詳細については、公式 AWS ドキュメントの [DynamoDB を使用した DynamoDB テーブルのバックアップと復元の仕組み](https://docs.aws.amazon.com/ja_jp/amazondynamodb/latest/developerguide/CreateBackup.html#CreateBackup_HowItWorks-restore)を参照してください。
+
+:::
+
+
+ `mysqldump` を使用してバックアップファイルを作成した場合は、[Reloading SQL-Format Backups](https://dev.mysql.com/doc/mysql-backup-excerpt/8.0/en/reloading-sql-format-dumps.html) で指定されているように、`mysql` コマンドを使用してバックアップを復元します。
+
+
+ `pg_dump` を使用してバックアップファイルを作成した場合は、[Restoring the Dump](https://www.postgresql.org/docs/current/backup-dump.html#BACKUP-DUMP-RESTORE) で指定されているように、`psql` コマンドを使用してバックアップを復元します。
+
+
+ [Special commands to sqlite3 (dot-commands)](https://www.sqlite.org/cli.html#special_commands_to_sqlite3_dot_commands_) で指定されているように、`.restore` コマンドを使用します。
+
+
+ バックアップ保持期間内であれば、スケジュールされたバックアップまたはオンデマンドバックアップから復元できます。バックアップの実行の詳細については、[YugabyteDB Managed: Back up and restore clusters](https://docs.yugabyte.com/preview/yugabyte-cloud/cloud-clusters/backup-clusters/) を参照してください。
+
+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/configurations.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/configurations.mdx
new file mode 100644
index 00000000..e9b77de6
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/configurations.mdx
@@ -0,0 +1,293 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB の設定
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このページでは、ScalarDB で使用可能な設定について説明します。
+
+## ScalarDB クライアントの設定
+
+このセクションでは、ScalarDB クライアントの設定について説明します。ScalarDB は、Consensus Commit を使用してトランザクションを実行する方法、非トランザクションストレージ操作を実行する方法、および ScalarDB Cluster を介してトランザクションを実行する方法を提供します。
+
+### Consensus Commit を使用してトランザクションを実行する
+
+ScalarDB は、Consensus Commit と呼ばれる独自のトランザクションプロトコルを提供します。これは、ScalarDB のデフォルトのトランザクションマネージャータイプです。Consensus Commit トランザクションマネージャーを使用するには、ScalarDB プロパティファイルに次の内容を追加します。
+
+```properties
+scalar.db.transaction_manager=consensus-commit
+```
+
+:::note
+
+`scalar.db.transaction_manager` プロパティを指定しない場合は、`consensus-commit` がデフォルト値になります。
+
+:::
+
+#### 基本設定
+
+Consensus Commit トランザクションマネージャーでは、次の基本設定が利用可能です。
+
+| 名前 | 説明 | デフォルト |
+|-------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------|
+| `scalar.db.transaction_manager` | `consensus-commit` を指定する必要があります。 | - |
+| `scalar.db.consensus_commit.isolation_level` | Consensus Commit に使用される分離レベル。`SNAPSHOT` または `SERIALIZABLE` のいずれかを指定できます。 | `SNAPSHOT` |
+| `scalar.db.consensus_commit.serializable_strategy` | Consensus Commit に使用されるシリアル化可能な戦略。`EXTRA_READ` または `EXTRA_WRITE` のいずれかを指定できます。`scalar.db.consensus_commit.isolation_level` プロパティで `SNAPSHOT` が指定されている場合、この設定は無視されます。 | `EXTRA_READ` |
+| `scalar.db.consensus_commit.coordinator.namespace` | Coordinator テーブルの名前空間名。 | `coordinator` |
+| `scalar.db.consensus_commit.include_metadata.enabled` | `true` に設定すると、`Get` および `Scan` 操作の結果にトランザクションメタデータが含まれます。特定のテーブルのトランザクションメタデータ列の詳細を表示するには、`DistributedTransactionAdmin.getTableMetadata()` メソッドを使用します。このメソッドは、トランザクションメタデータ列が追加されたテーブルメタデータを返します。この設定を使用すると、トランザクション関連の問題を調査するのに役立ちます。 | `false` |
+
+#### パフォーマンス関連の設定
+
+Consensus Commit トランザクションマネージャーでは、次のパフォーマンス関連の設定が利用できます。
+
+| 名前 | 説明 | デフォルト |
+|----------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
+| `scalar.db.consensus_commit.parallel_executor_count` | 並列実行のためのエグゼキュータ(スレッド)の数。 | `128` |
+| `scalar.db.consensus_commit.parallel_preparation.enabled` | 準備フェーズが並行して実行されるかどうか。 | `true` |
+| `scalar.db.consensus_commit.parallel_validation.enabled` | 検証フェーズ (`EXTRA_READ` 内) が並列で実行されるかどうか。 | `scalar.db.consensus_commit.parallel_commit.enabled` の値 |
+| `scalar.db.consensus_commit.parallel_commit.enabled` | コミットフェーズが並列で実行されるかどうか。 | `true` |
+| `scalar.db.consensus_commit.parallel_rollback.enabled` | ロールバックフェーズが並列で実行されるかどうか。 | `scalar.db.consensus_commit.parallel_commit.enabled` の値 |
+| `scalar.db.consensus_commit.async_commit.enabled` | コミットフェーズが非同期で実行されるかどうか。 | `false` |
+| `scalar.db.consensus_commit.async_rollback.enabled` | ロールバックフェーズが非同期に実行されるかどうか。 | `scalar.db.consensus_commit.async_commit.enabled` の値 |
+| `scalar.db.consensus_commit.parallel_implicit_pre_read.enabled` | 暗黙的な事前読み取りが並列で実行されるかどうか。 | `true` |
+| `scalar.db.consensus_commit.coordinator.group_commit.enabled` | トランザクション状態のコミットがバッチモードで実行されるかどうか。この機能は、2 フェーズコミットインターフェイスでは使用できません。 | `false` |
+| `scalar.db.consensus_commit.coordinator.group_commit.slot_capacity` | グループコミット機能のグループ内のスロットの最大数。値が大きいとグループコミットの効率は向上しますが、待ち時間が増加し、トランザクションの競合が発生する可能性も高くなります。[^1] | `20` |
+| `scalar.db.consensus_commit.coordinator.group_commit.group_size_fix_timeout_millis` | グループ内のスロットのサイズを固定するためのタイムアウト。値が大きいとグループコミットの効率が向上しますが、待ち時間が増加し、トランザクションの競合が発生する可能性も高くなります。[^1] | `40` |
+| `scalar.db.consensus_commit.coordinator.group_commit.delayed_slot_move_timeout_millis` | 遅延スロットをグループから別の分離グループに移動して、元のグループが遅延トランザクションの影響を受けないようにするためのタイムアウト。値が大きいとグループコミットの効率が向上しますが、待ち時間が増加し、トランザクションの競合が発生する可能性も高くなります。[^1] | `1200` |
+| `scalar.db.consensus_commit.coordinator.group_commit.old_group_abort_timeout_millis` | 進行中の古いグループをアボートするためのタイムアウト。値が小さいと、積極的なアボートによってリソースの消費量が減りますが、長時間実行されるトランザクションで不要なアボートが発生する可能性も高くなります。 | `60000` |
+| `scalar.db.consensus_commit.coordinator.group_commit.timeout_check_interval_millis` | グループコミット関連のタイムアウトをチェックする間隔。 | `20` |
+| `scalar.db.consensus_commit.coordinator.group_commit.metrics_monitor_log_enabled` | グループコミットのメトリックが定期的にログに記録されるかどうか。 | `false` |
+
+#### 基盤となるストレージまたはデータベースの設定
+
+Consensus Commit にはストレージ抽象化レイヤーがあり、複数の基盤となるストレージをサポートしています。`scalar.db.storage` プロパティを使用してストレージ実装を指定できます。
+
+データベースを選択して、各ストレージで使用可能な設定を確認します。
+
+
+
+ JDBC データベースでは次の設定を使用できます。
+
+ | 名前 | 説明 | デフォルト |
+ |-----------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|------------------|
+ | `scalar.db.storage` | `jdbc` を指定する必要があります。 | - |
+ | `scalar.db.contact_points` | JDBC 接続 URL。 | |
+ | `scalar.db.username` | データベースにアクセスするためのユーザー名。 | |
+ | `scalar.db.password` | データベースにアクセスするためのパスワード。 | |
+ | `scalar.db.jdbc.connection_pool.min_idle` | 接続プール内のアイドル接続の最小数。 | `20` |
+ | `scalar.db.jdbc.connection_pool.max_idle` | 接続プール内でアイドル状態のままにできる接続の最大数。 | `50` |
+ | `scalar.db.jdbc.connection_pool.max_total` | 接続プールで同時にアクティブにできるアイドル接続と借用接続の最大合計数。制限がない場合は負の値を使用します。 | `100` |
+ | `scalar.db.jdbc.prepared_statements_pool.enabled` | このプロパティを `true` に設定すると、準備済みステートメントプーリングが有効になります。 | `false` |
+ | `scalar.db.jdbc.prepared_statements_pool.max_open` | ステートメントプールから同時に割り当てることができるオープンステートメントの最大数。制限がない場合は負の値を使用します。 | `-1` |
+ | `scalar.db.jdbc.isolation_level` | JDBC の分離レベル。`READ_UNCOMMITTED`、`READ_COMMITTED`、`REPEATABLE_READ`、または `SERIALIZABLE` を指定できます。 | 基盤データベース固有 |
+ | `scalar.db.jdbc.table_metadata.connection_pool.min_idle` | テーブルメタデータの接続プール内のアイドル接続の最小数。 | `5` |
+ | `scalar.db.jdbc.table_metadata.connection_pool.max_idle` | テーブルメタデータの接続プール内でアイドル状態のままにできる接続の最大数。 | `10` |
+ | `scalar.db.jdbc.table_metadata.connection_pool.max_total` | テーブルメタデータの接続プールで同時にアクティブにできるアイドル接続と借用接続の最大合計数。制限がない場合は負の値を使用します。 | `25` |
+ | `scalar.db.jdbc.admin.connection_pool.min_idle` | 管理者の接続プール内のアイドル接続の最小数。 | `5` |
+ | `scalar.db.jdbc.admin.connection_pool.max_idle` | 管理者の接続プール内でアイドル状態のままにできる接続の最大数。 | `10` |
+ | `scalar.db.jdbc.admin.connection_pool.max_total` | 管理者の接続プールで同時にアクティブにできるアイドル接続と借用接続の最大合計数。制限がない場合は負の値を使用します。 | `25` |
+
+:::note
+
+#### SQLite3
+
+SQLite3 を JDBC データベースとして使用している場合は、`scalar.db.contact_points` を次のように設定する必要があります。
+
+```properties
+scalar.db.contact_points=jdbc:sqlite:?busy_timeout=10000
+```
+
+他の JDBC データベースとは異なり、[SQLite3 doesn't fully support concurrent access](https://www.sqlite.org/lang_transaction.html)。[`SQLITE_BUSY`](https://www.sqlite.org/rescode.html#busy) によって内部的に頻繁に発生するエラーを回避するには、[`busy_timeout`](https://www.sqlite.org/c3ref/busy_timeout.html) パラメータを設定することをお勧めします。
+
+#### YugabyteDB
+
+YugabyteDB を JDBC データベースとして使用している場合は、次のように `scalar.db.contact_points` で複数のエンドポイントを指定できます。
+
+```properties
+scalar.db.contact_points=jdbc:yugabytedb://127.0.0.1:5433\\,127.0.0.2:5433\\,127.0.0.3:5433/?load-balance=true
+```
+
+複数のエンドポイントはエスケープされたコンマで区切る必要があります。
+
+YugabyteDB のスマートドライバーと負荷分散の詳細については、[YugabyteDB smart drivers for YSQL](https://docs.yugabyte.com/preview/drivers-orms/smart-drivers/) を参照してください。
+
+:::
+
+
+
+ DynamoDB では次の設定が利用可能です。
+
+ | 名前 | 説明 | デフォルト |
+ |--------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------|
+ | `scalar.db.storage` | `dynamo` を指定する必要があります。 | - |
+ | `scalar.db.contact_points` | ScalarDB が通信する AWS リージョン (例: `us-east-1`)。 | |
+ | `scalar.db.username` | AWS とやり取りするユーザーを識別するために使用される AWS アクセスキー。 | |
+ | `scalar.db.password` | AWS と対話するユーザーを認証するために使用される AWS シークレットアクセスキー。 | |
+ | `scalar.db.dynamo.endpoint_override` | ScalarDB が通信する Amazon DynamoDB エンドポイント。これは主に、AWS サービスではなくローカルインスタンスでのテストに使用されます。 | |
+ | `scalar.db.dynamo.namespace.prefix` | ユーザー名前空間とメタデータ名前空間名のプレフィックス。AWS では単一の AWS リージョン内で一意のテーブル名を持つ必要があるため、単一の AWS リージョン内で複数の ScalarDB 環境 (開発、本番など) を使用する場合に便利です。 | |
+
+
+ Cosmos DB for NoSQL では次の設定が利用可能です。
+
+ | 名前 | 説明 | デフォルト |
+ |--------------------------------------|------------------------------------------------------------------------------------------------------------|-----------|
+ | `scalar.db.storage` | `cosmos` を指定する必要があります。 | - |
+ | `scalar.db.contact_points` | ScalarDB が通信する NoSQL エンドポイント用の Azure Cosmos DB。 | |
+ | `scalar.db.password` | Azure Cosmos DB for NoSQL にアクセスするための認証を実行するために使用されるマスターキーまたは読み取り専用キーのいずれか。 | |
+ | `scalar.db.cosmos.consistency_level` | Cosmos DB 操作に使用される一貫性レベル。`STRONG` または `BOUNDED_STALENESS` を指定できます。 | `STRONG` |
+
+
+ Cassandra では次の設定が利用可能です。
+
+ | 名前 | 説明 | デフォルト |
+ |----------------------------|--------------------------------------|----------|
+ | `scalar.db.storage` | `cassandra` を指定する必要があります。 | - |
+ | `scalar.db.contact_points` | カンマで区切られた連絡先。 | |
+ | `scalar.db.contact_port` | すべての連絡先ポイントのポート番号。 | |
+ | `scalar.db.username` | データベースにアクセスするためのユーザー名。 | |
+ | `scalar.db.password` | データベースにアクセスするためのパスワード。 | |
+
+
+
+##### マルチストレージのサポート
+
+ScalarDB は、複数のストレージ実装の同時使用をサポートしています。`scalar.db.storage` プロパティの値として `multi-storage` を指定することで、複数のストレージを使用できます。
+
+複数のストレージの使用の詳細については、[マルチストレージトランザクション](multi-storage-transactions.mdx)を参照してください。
+
+##### クロスパーティションスキャン設定
+
+以下で説明するようにクロスパーティションスキャンオプションを有効にすると、`Scan` 操作でパーティション全体のすべてのレコードを取得できます。さらに、`cross_partition_scan.filtering` と `cross_partition_scan.ordering` をそれぞれ有効にすることで、クロスパーティション `Scan` 操作で任意の条件と順序を指定できます。現在、順序付けオプション付きのクロスパーティションスキャンは、JDBC データベースでのみ使用できます。フィルタリングと順序付けを有効にするには、`scalar.db.cross_partition_scan.enabled` を `true` に設定する必要があります。
+
+クロスパーティションスキャンの使用方法の詳細については、[`Scan` 操作](./api-guide.mdx#scan-操作)を参照してください。
+
+:::warning
+
+非 JDBC データベースの場合、`SERIALIZABLE` 分離レベルでクロスパーティションスキャンを有効にした場合でも、トランザクションは読み取りコミットスナップショット分離 (`SNAPSHOT`) で実行される可能性があります。これは、より低い分離レベルです。非 JDBC データベースを使用する場合は、トランザクションの一貫性が重要でない場合にのみ、クロスパーティションスキャンを使用してください。
+
+:::
+
+| 名前 | 説明 | デフォルト |
+|----------------------------------------------------|---------------------------------------------------|----------|
+| `scalar.db.cross_partition_scan.enabled` | パーティション間スキャンを有効にします。 | `false` |
+| `scalar.db.cross_partition_scan.filtering.enabled` | クロスパーティションスキャンでフィルタリングを有効にします。 | `false` |
+| `scalar.db.cross_partition_scan.ordering.enabled` | パーティション間スキャンでの順序付けを有効にします。 | `false` |
+
+### 非トランザクションストレージ操作を実行する
+
+非トランザクションストレージ操作を実行するには、`scalar.db.transaction_manager` プロパティを `single-crud-operation` に設定する必要があります。
+
+```properties
+scalar.db.transaction_manager=single-crud-operation
+```
+
+また、[基盤となるストレージまたはデータベースの設定](#基盤となるストレージまたはデータベースの設定)の説明に従って、基盤となるストレージまたはデータベースを設定する必要があります。
+
+### ScalarDB Cluster を介してトランザクションを実行する
+
+[ScalarDB Cluster](scalardb-cluster/index.mdx) は、ScalarDB に gRPC インターフェースを提供するコンポーネントです。
+
+クライアント設定の詳細については、[ScalarDB Cluster クライアント設定](scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx#クライアント設定)を参照してください。
+
+## その他の ScalarDB 設定
+
+ScalarDB で使用できる追加の設定は次のとおりです。
+
+| 名前 | 説明 | デフォルト |
+|------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------|
+| `scalar.db.metadata.cache_expiration_time_secs` | ScalarDB には、データベースへのリクエスト数を減らすためのメタデータキャッシュがあります。この設定では、キャッシュの有効期限を秒単位で指定します。`-1`を指定した場合は、キャッシュは期限切れになりません。 | `60` |
+| `scalar.db.active_transaction_management.expiration_time_millis` | ScalarDB は進行中のトランザクションを維持し、トランザクション ID を使用して再開できます。この設定は、このトランザクション管理機能の有効期限をミリ秒単位で指定します。 | `-1` (有効期限なし) |
+| `scalar.db.default_namespace_name` | 指定された名前空間名は、名前空間を指定していない操作によって使用されます。 | |
+| `scalar.db.system_namespace_name` | 指定された名前空間名は ScalarDB によって内部的に使用されます。 | `scalardb` |
+
+## プレースホルダーの使用
+
+値にプレースホルダーを使用できます。プレースホルダーは環境変数 (`${env:}`) またはシステムプロパティ (`${sys:}`) に置き換えられます。また、`${sys::-}` のようにプレースホルダーにデフォルト値を指定することもできます。
+
+以下は、プレースホルダーを使用する設定の例です。
+
+```properties
+scalar.db.username=${env::-admin}
+scalar.db.password=${env:}
+```
+
+この設定例では、ScalarDB は環境変数からユーザー名とパスワードを読み取ります。環境変数 `SCALAR_DB_USERNAME` が存在しない場合、ScalarDB はデフォルト値 `admin` を使用します。
+
+## 設定例
+
+このセクションでは、いくつかの設定例を示します。
+
+### 設定例 #1 - アプリとデータベース
+
+```mermaid
+flowchart LR
+ app["アプリ
(ScalarDB ライブラリと
Consensus Commit)"]
+ db[(基盤となるストレージまたはデータベース)]
+ app --> db
+```
+
+この例の設定では、アプリ (Consensus Commit を備えた ScalarDB ライブラリ) が、基盤となるストレージまたはデータベース (この場合は Cassandra) に直接接続します。
+
+:::warning
+
+この設定は開発目的のみに存在し、実稼働環境には適していません。これは、ScalarDB のトランザクション的に一貫性のあるバックアップを取得するために、アプリが [Scalar Admin](https://github.com/scalar-labs/scalar-admin) インターフェースを実装する必要があり、追加の設定が必要になるためです。
+
+:::
+
+以下は、ScalarDB を介してアプリを基盤となるデータベースに接続するための設定の例です。
+
+```properties
+# Transaction manager implementation.
+scalar.db.transaction_manager=consensus-commit
+
+# Storage implementation.
+scalar.db.storage=cassandra
+
+# Comma-separated contact points.
+scalar.db.contact_points=
+
+# Credential information to access the database.
+scalar.db.username=
+scalar.db.password=
+```
+
+### 設定例 #2 - アプリ、ScalarDB Cluster、データベース
+
+```mermaid
+flowchart LR
+ app["アプリ -
ScalarDB ライブラリと gRPC"]
+ cluster["ScalarDB Cluster -
(ScalarDB ライブラリと
Consensus Commit)"]
+ db[(基盤となるストレージまたはデータベース)]
+ app --> cluster --> db
+```
+
+この例の設定では、アプリ (gRPC を使用した ScalarDB ライブラリ) は、ScalarDB Enterprise エディションでのみ使用可能なコンポーネントである ScalarDB Cluster を介して、基盤となるストレージまたはデータベース (この場合は Cassandra) に接続します。
+
+:::note
+
+ScalarDB Cluster は [Scalar Admin](https://github.com/scalar-labs/scalar-admin) インターフェイスを実装しており、これにより ScalarDB Cluster を一時停止することで ScalarDB のトランザクション的に一貫性のあるバックアップを取得できるため、この設定は実稼働環境での使用に適しています。
+
+:::
+
+以下は、ScalarDB Cluster を介してアプリを基盤となるデータベースに接続するための設定の例です。
+
+```properties
+# Transaction manager implementation.
+scalar.db.transaction_manager=cluster
+
+# Contact point of the cluster.
+scalar.db.contact_points=indirect:
+```
+
+クライアント設定の詳細については、[ScalarDB Cluster クライアント設定](scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx#クライアント設定) を参照してください。
+
+[^1]: アプリケーションのアクセスパターンを考慮し、アプリケーションが使用する同じ基盤ストレージで、いくつかのバリエーション (たとえば、デフォルト値の 75% と 125%) でパフォーマンスをベンチマークして、最適な設定を決定することは価値があります。最適な設定は実際にはこれらの要因によって決まるためです。また、これらのパラメーターの組み合わせ (たとえば、1 番目に `slot_capacity:20` と `group_size_fix_timeout_millis:40`、2 番目に `slot_capacity:30` と `group_size_fix_timeout_millis:40`、3 番目に `slot_capacity:20` と `group_size_fix_timeout_millis:80`) をベンチマークして、最適な組み合わせを決定することも重要です。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/data-modeling.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/data-modeling.mdx
new file mode 100644
index 00000000..552a0fd1
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/data-modeling.mdx
@@ -0,0 +1,134 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# データをモデル化する
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+データモデリング (つまり、データベーススキーマの設計) とは、データへのアクセスに使用されるパターンと、ビジネスオペレーション内で実行されるクエリの種類を特定することで、データの保存方法と使用方法を概念化して視覚化するプロセスです。
+
+このページでは、まず ScalarDB データモデルについて説明し、次にデータモデルに基づいてデータベーススキーマを設計する方法について説明します。
+
+## ScalarDB データモデル
+
+ScalarDB のデータモデルは、Bigtable データモデルにヒントを得た拡張キー値モデルです。リレーショナルモデルに似ていますが、以下に示すようにいくつかの点で異なります。データモデルは、リレーショナルデータベース、NoSQL データベース、NewSQL データベースなど、さまざまなデータベースを抽象化するために選択されます。
+
+次の図は、それぞれがレコードのコレクションである ScalarDB テーブルの例を示しています。このセクションでは、まず、テーブルやレコードなどの ScalarDB が定義するオブジェクトについて説明し、次にレコードの検索方法について説明します。
+
+
+
+### ScalarDB のオブジェクト
+
+ScalarDB データモデルには、いくつかのオブジェクトがあります。
+
+#### 名前空間
+
+名前空間は、SQL 名前空間またはデータベースに類似したテーブルのコレクションです。
+
+#### テーブル
+
+テーブルはパーティションのコレクションです。名前空間には、通常、それぞれが名前で識別される 1 つ以上のテーブルが含まれます。
+
+#### パーティション
+
+パーティションはレコードのコレクションであり、論理ノードまたは物理ノードへの分散単位です。したがって、同じパーティション内のレコードは同じノードに配置されます。ScalarDB では、複数のパーティションがハッシュによって分散されていると想定しています。
+
+#### レコード / 行
+
+レコードまたは行は、他のすべてのレコード間で一意に識別できる列のセットです。
+
+#### 列
+
+列は基本的なデータ要素であり、これ以上細分化する必要はありません。各レコードは、1 つ以上の列で設定されます。各列にはデータ型があります。データ型の詳細については、[ScalarDB と他のデータベース間のデータ型マッピング](schema-loader.mdx#scalardb-と他のデータベース間のデータ型マッピング)を参照してください。
+
+#### セカンダリインデックス
+
+セカンダリインデックスは、単一の基本テーブル内の列のソートされたコピーです。各インデックスエントリは、対応するテーブルパーティションにリンクされています。ScalarDB は現在、複数列のインデックスをサポートしていないため、1 つの列のみでインデックスを作成できます。
+
+### レコードの検索方法
+
+このセクションでは、テーブルからレコードを検索する方法について説明します。
+
+#### プライマリーキー
+
+プライマリーキーは各レコードを一意に識別します。2 つのレコードが同じプライマリーキーを持つことはできません。したがって、プライマリーキーを指定してレコードを検索できます。プライマリーキーは、パーティションキーと、オプションでクラスタリングキーで設定されます。
+
+#### パーティションキー
+
+パーティションキーは、パーティションを一意に識別します。パーティションキーは、パーティションキー列と呼ばれる列のセットで設定されます。パーティションキーのみを指定すると、パーティションに属するレコードのセットを取得できます。
+
+#### クラスタリングキー
+
+クラスタリングキーは、パーティション内のレコードを一意に識別します。クラスタリングキー列と呼ばれる列のセットで設定されます。クラスタリングキーを指定する場合は、効率的な検索のためにパーティションキーを指定する必要があります。パーティションキーなしでクラスタリングキーを指定すると、すべてのパーティションをスキャンすることになります。すべてのパーティションをスキャンすると、特にデータ量が多い場合は時間がかかるため、自己判断でのみ実行してください。
+
+パーティション内のレコードは、クラスタリング順序として指定されたクラスタリングキー列でソートされていると想定されます。したがって、定義された順序でクラスタリングキー列の一部を指定して、返される結果を絞り込むことができます。
+
+#### インデックスキー
+
+インデックスキーは、インデックス内のキーを検索してレコードを識別します。インデックスキーの検索はすべてのパーティションにまたがるため、特に検索の選択性が低くない場合は、必ずしも効率的であるとは限りません。
+
+## データベーススキーマの設計方法
+
+データベーススキーマはリレーショナルモデルと同様に設計できますが、基本的な原則があり、従うべきベストプラクティスがいくつかあります。
+
+### クエリ駆動型データモデリング
+
+リレーショナルデータベースでは、データは正規化されたテーブルに整理され、外部キーを使用して他のテーブル内の関連データを参照します。アプリケーションが実行するクエリはテーブルによって構造化され、関連データはテーブル結合としてクエリされます。
+
+ScalarDB は ScalarDB SQL での結合操作をサポートしていますが、データモデリングは NoSQL データベースのように、よりクエリ駆動型である必要があります。データアクセスパターンとアプリケーションクエリによって、テーブルの構造と設定が決定されます。
+
+### ベストプラクティス
+
+このセクションでは、データベーススキーマを設計するためのベストプラクティスについて説明します。
+
+#### データ分散を考慮する
+
+パーティションキーとクラスタリングキーを適切に選択して、パーティションへの負荷を分散させることをお勧めします。
+
+たとえば、銀行アプリケーションでアカウント ID をパーティションキーとして選択すると、アカウントが属するパーティション内で特定のアカウントに対するすべてのアカウント操作を実行できます。したがって、異なるアカウント ID を操作すると、異なるパーティションにアクセスすることになります。
+
+一方、ブランチ ID をパーティションキーとして選択し、アカウント ID をクラスタリングキーとして選択すると、ブランチのアカウント ID へのアクセスはすべて同じパーティションに送られるため、負荷とデータサイズの不均衡が生じます。さらに、少数の大きなパーティションを作成すると負荷とデータサイズの不均衡が生じるため、パーティションキーにはカーディナリティの高い列を選択する必要があります。
+
+#### 単一のパーティションの読み取りを試みる
+
+データモデルの特性により、単一パーティション検索が最も効率的です。スキャンを発行したり、複数パーティションの検索やスキャンを必要とするリクエストを選択したりする必要がある場合は、[クロスパーティションスキャンで有効にする](configurations.mdx#クロスパーティションスキャン設定)ことができますが、独自の判断で実行し、可能であればスキーマの更新を検討してください。
+
+たとえば、銀行アプリケーションで、パーティションキーとして電子メールを選択し、クラスタリングキーとしてアカウント ID を選択し、アカウント ID を指定するクエリを発行すると、対応するパーティションを効率的に識別できないため、クエリはすべてのパーティションにまたがって実行されます。このような場合は、常にアカウント ID を使用してテーブルを検索する必要があります。
+
+:::note
+
+適切なインデックスを持つリレーショナルデータベース上の複数のパーティションを読み取る場合、クエリがデータベースにプッシュダウンされるため、クエリが効率的になる可能性があります。
+
+:::
+
+#### セカンダリインデックスの使用を避ける
+
+上記と同様に、セカンダリインデックスを使用するスキャンまたは選択リクエストを発行する必要がある場合、そのリクエストはテーブルのすべてのパーティションにまたがります。したがって、セカンダリインデックスの使用を避けるようにしてください。セカンダリインデックスを使用する必要がある場合は、小さな部分を検索する低選択性クエリを介して使用します。
+
+セカンダリインデックスの代わりに、ベーステーブルのクラスター化インデックスとして機能する別のテーブルを作成できます。
+
+たとえば、プライマリーキーが `A` である `table1(A, B, C)` という 3 つの列を持つテーブルがあるとします。次に、`C` をプライマリーキーとして `index-table1(C, A, B)` のようなテーブルを作成し、`C` の値を指定して単一のパーティションを検索できるようにします。このアプローチにより、読み取りクエリは高速化されますが、ScalarDB トランザクションを使用して 2 つのテーブルに書き込む必要があるため、書き込みクエリの負荷が増加する可能性があります。
+
+:::note
+
+将来的には、ScalarDB にテーブルベースのセカンダリインデックス機能が追加される予定です。
+
+:::
+
+#### データはハッシュによって分散されていると想定されていることを考慮する
+
+現在の ScalarDB データモデルでは、データはハッシュによって分散されていると想定されています。したがって、パーティションキーがないと範囲クエリを効率的に実行できません。
+
+範囲クエリを効率的に発行するには、パーティション内で実行する必要があります。ただし、このアプローチに従う場合は、パーティションキーを指定する必要があります。範囲クエリは常に同じパーティションに送信されるので、パーティションが過負荷になる可能性があり、スケーラビリティの問題が発生する可能性があります。この制限は ScalarDB に固有のものではなく、スケーラビリティのためにハッシュによってデータが分散されているデータベースに固有のものです。
+
+:::note
+
+適切なインデックスを持つリレーショナルデータベースで ScalarDB を実行すると、クエリがデータベースにプッシュダウンされるため、範囲クエリが効率的になる可能性があります。
+
+:::
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/database-configurations.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/database-configurations.mdx
new file mode 100644
index 00000000..3558209c
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/database-configurations.mdx
@@ -0,0 +1,122 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB の基盤となるデータベースの設定
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このドキュメントでは、ScalarDB を使用するアプリケーションが正しく効率的に動作するように、ScalarDB の基盤となるデータベースを設定する方法について説明します。
+
+## 基盤となるデータベースの一般的な要件
+
+ScalarDB では、基盤となる各データベースが、データベースでトランザクションと分析を実行するための特定の機能を提供する必要があります。このドキュメントでは、一般的な要件と、要件を満たすために各データベースを設定する方法について説明します。
+
+### トランザクション
+
+ScalarDB では、基盤となる各データベースが、データベースでトランザクションを実行するために少なくとも次の機能を提供する必要があります。
+
+- 単一のデータベースレコードに対する線形化可能な読み取りと条件付きミューテーション (書き込みと削除)。
+- 書き込まれたデータベースレコードの耐久性。
+- 各データベースレコードにアプリケーションデータのほかに任意のデータを保存できる機能。
+
+### 分析
+
+ScalarDB では、基盤となる各データベースが、データベースで分析を実行するために次の機能を提供する必要があります。
+
+- コミットされたレコードのみを返す機能。
+
+:::note
+
+ScalarDB は、CRUD 操作だけでなく、スキーマ、テーブル、インデックスの作成や変更などの操作を実行するために、基盤となるデータベース上で実行されるため、ScalarDB を介してデータベースにアクセスするのに十分な権限を持つデータベースアカウントが必要です。基本的に、ScalarDB では、基盤となるデータベースにアクセスするために完全な権限を持つアカウントが必要です。
+
+:::
+
+## 一般的な要件を満たすようにデータベースを設定する方法
+
+一般的な要件を満たすようにデータベースを設定する方法の詳細については、データベースを選択してください。
+
+
+
+ トランザクション
+
+ - すべての操作に単一のプライマリサーバーまたは同期された複数のプライマリサーバーを使用します (プライマリデータベースから非同期にレプリケートされた読み取りレプリカに対する読み取り操作はありません)。
+ - 読み取りコミットまたはより厳格な分離レベルを使用します。
+
+ 分析
+
+ - 読み取りコミットまたはより厳格な分離レベルを使用します。
+
+
+ トランザクション
+
+ - すべての操作に単一のプライマリリージョンを使用します。(プライマリリージョン以外のグローバルテーブルに対する読み取りおよび書き込み操作は実行できません。)
+ - DynamoDB にはプライマリリージョンの概念がないため、プライマリリージョンは自分で指定する必要があります。
+
+ 分析
+
+ - 該当なし。DynamoDB は常にコミットされたレコードを返すため、DynamoDB 固有の要件はありません。
+
+
+ トランザクション
+
+ - 「Strong」または「Bounded Staleness」の一貫性を持つすべての操作に単一のプライマリリージョンを使用します。
+
+ 分析
+
+ - 該当なし。Cosmos DB は常にコミットされたレコードを返すため、Cosmos DB 固有の要件はありません。
+
+
+ トランザクション
+
+ - すべての操作に単一のプライマリクラスターを使用します (プライマリ以外のクラスターでは読み取りまたは書き込み操作は行いません)。
+ - `commitlog_sync` には `batch` または `group` を使用します。
+ - Cassandra 互換データベースを使用している場合、それらのデータベースは軽量トランザクション (LWT) を適切にサポートしている必要があります。
+
+ 分析
+
+ - 該当なし。Cassandra は常にコミットされたレコードを返すため、Cassandra 固有の要件はありません。
+
+
+
+## 推奨事項
+
+ScalarDB の基盤となる各データベースを適切に設定して、高パフォーマンスと高可用性を実現することが推奨されます。次の推奨事項には、更新すべきいくつかのオプションが含まれています。
+
+:::note
+
+ScalarDB は基盤となるデータベースのアプリケーションと見なすことができるため、効率を向上させるためによく使用されるその他のオプションを更新してみることをお勧めします。
+
+:::
+
+
+
+ - パフォーマンスを向上させるには、読み取りコミット分離を使用します。
+ - 各データベースのパフォーマンス最適化のベストプラクティスに従います。たとえば、パフォーマンスを向上させるには、通常、バッファサイズ (PostgreSQL の `shared_buffers` など) を増やし、接続数 (PostgreSQL の `max_connections` など) を増やすことが推奨されます。
+
+
+ - 読み取り容量ユニット (RCU) と書き込み容量ユニット (WCU) の数を増やして、スループットを高めます。
+ - ポイントインタイムリカバリ (PITR) を有効にします。
+
+:::note
+
+DynamoDB はデフォルトで複数のアベイラビリティーゾーンにデータを保存するため、可用性を向上させるために設定を調整する必要はありません。
+
+:::
+
+
+ - 高いスループットを実現するために、リクエストユニット (RU) の数を増やします。
+ - ポイントインタイムリストア (PITR) を有効にします。
+ - 可用性ゾーンを有効にします。
+
+
+ - スループットを高めるために、`concurrent_reads` と `concurrent_writes` を増やします。詳細については、[`concurrent_writes`](https://cassandra.apache.org/doc/stable/cassandra/configuration/cass_yaml_file.html#concurrent_writes) に関する Cassandra の公式ドキュメントを参照してください。
+
+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/deploy-overview.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/deploy-overview.mdx
new file mode 100644
index 00000000..3a0d7e1b
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/deploy-overview.mdx
@@ -0,0 +1,22 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# デプロイの概要
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このカテゴリでは、ローカルおよびクラウドベースの Kubernetes 環境での ScalarDB、特に ScalarDB Cluster と ScalarDB Analytics のデプロイに慣れるためのガイドに従うことができます。
+
+## ローカル Kubernetes 環境に ScalarDB をデプロイする
+
+このサブカテゴリでは、ローカル Kubernetes 環境に ScalarDB をデプロイする方法を学習できます。このサブカテゴリの主な焦点は、Scalar Helm Charts の使用方法を学習することです。このため、わかりやすくするために特定のデータベース (PostgreSQL) が指定されています。
+
+## クラウドベースの Kubernetes 環境に ScalarDB をデプロイする
+
+このサブカテゴリでは、クラウドベースの Kubernetes 環境に ScalarDB をデプロイする方法を学習できます。このサブカテゴリでは、Scalar Helm Charts の使用方法と、クラウドベースの Kubernetes 環境で ScalarDB を実行するために必要なその他の手順について説明します。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/design.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/design.mdx
new file mode 100644
index 00000000..64fbd23f
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/design.mdx
@@ -0,0 +1,17 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB デザインドキュメント
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB の設計と実装の詳細については、VLDB 2023 カンファレンスで発表した次のドキュメントを参照してください。
+
+- **Speakerdeck プレゼンテーション:** [ScalarDB: Universal Transaction Manager for Polystores](https://speakerdeck.com/scalar/scalardb-universal-transaction-manager-for-polystores-vldb23)
+- **詳細な論文:** [ScalarDB: Universal Transaction Manager for Polystores](https://www.vldb.org/pvldb/vol16/p3768-yamada.pdf)
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/develop-overview.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/develop-overview.mdx
new file mode 100644
index 00000000..efb9a898
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/develop-overview.mdx
@@ -0,0 +1,32 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB を用いた開発について開発の概要
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このカテゴリでは、ScalarDB をよりよく理解するためのガイドに従うことができます。具体的には、トランザクション、分析クエリ、非トランザクションストレージ操作の実行方法です。
+
+## トランザクションの実行
+
+このサブカテゴリでは、ScalarDB データモデルに基づいてデータをモデル化し、スキーマを作成する方法を学習できます。次に、ScalarDB コアライブラリと、コアライブラリをラップする gRPC サーバーである ScalarDB Cluster を介してトランザクションを実行する方法を学習できます。
+
+また、正確で安全でパフォーマンスの高い ScalarDB ベースのアプリケーションを作成する方法も学習できます。
+
+## 分析クエリの実行
+
+このセクションでは、ScalarDB の分析コンポーネントである ScalarDB Analytics をセットアップおよび設定する方法を学習できます。次に、ScalarDB トランザクションを介して書き込んだデータベースに対して分析クエリを実行します。
+
+## 非トランザクションストレージ操作の実行
+
+ScalarDB は当初、さまざまなデータベースと、そのようなデータベース間のトランザクション間の統一された抽象化を提供するために設計されました。ただし、複数の、場合によっては多様なデータベースを使用するアプリケーションを簡素化するために、統合抽象化のみが必要な場合もあります。
+
+ScalarDB では、基盤となるデータベースとストレージで非トランザクション操作のみを実行できるよう、トランザクション機能なしで統合抽象化のみを提供するように設定することができます。ScalarDB は複数の操作にわたって ACID を保証しないため、より優れたパフォーマンスで操作を実行できます。
+
+このサブカテゴリでは、このような非トランザクションストレージ操作を実行する方法を学習できます。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb-by-using-kotlin.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb-by-using-kotlin.mdx
new file mode 100644
index 00000000..49608cf4
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb-by-using-kotlin.mdx
@@ -0,0 +1,418 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# Kotlin を使って ScalarDB をはじめよう
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+この入門チュートリアルでは、ScalarDB で好みのデータベースを設定し、Kotlin を使用して基本的な電子マネーアプリケーションをセットアップする方法について説明します。Kotlin は Java との相互運用性を備えているため、Kotlin から直接 ScalarDB を使用できます。
+
+:::warning
+
+電子マネーアプリケーションはこのチュートリアル用に簡略化されており、実稼働環境には適していません。
+
+:::
+
+## このサンプルアプリケーションの前提条件
+
+ScalarDB は Java で記述されているため、環境に次のいずれかの Java Development Kit (JDK) がインストールされている必要があります。
+
+- [Eclipse Temurin](https://adoptium.net/temurin/releases/) の OpenJDK LTS バージョン (8、11、17、または 21)
+- [Docker](https://www.docker.com/get-started/) 20.10 以降と [Docker Compose](https://docs.docker.com/compose/install/) V2 以降
+
+:::note
+
+このサンプルアプリケーションは、Eclipse Temurin の OpenJDK でテストされています。ただし、ScalarDB 自体は、さまざまなベンダーの JDK ディストリビューションでテストされています。互換性のある JDK ディストリビューションを含む ScalarDB の要件の詳細については、[要件](./requirements.mdx)を参照してください。
+
+:::
+
+## ScalarDB サンプルリポジトリのクローンを作成する
+
+**Terminal** を開き、次のコマンドを実行して ScalarDB サンプルリポジトリのクローンを作成します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples
+```
+
+次に、次のコマンドを実行して、サンプルアプリケーションが含まれているディレクトリに移動します。
+
+```console
+cd scalardb-samples/scalardb-kotlin-sample
+```
+
+## データベースをセットアップする
+
+データベースを選択し、指示に従って ScalarDB 用に設定します。
+
+ScalarDB がサポートするデータベースの一覧については、[データベース](requirements.mdx#データベース)を参照してください。
+
+
+
+ MySQLをローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で MySQL を実行できます。
+
+ MySQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d mysql
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の MySQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For MySQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:mysql://localhost:3306/
+ scalar.db.username=root
+ scalar.db.password=mysql
+ ```
+
+
+ PostgreSQL をローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で PostgreSQL を実行できます。
+
+ PostgreSQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d postgres
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の PostgreSQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For PostgreSQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:postgresql://localhost:5432/
+ scalar.db.username=postgres
+ scalar.db.password=postgres
+ ```
+
+
+ Oracle Database をローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Oracle Database を実行できます。
+
+ Oracle Database を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d oracle
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Oracle データベースのプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Oracle
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:oracle:thin:@//localhost:1521/FREEPDB1
+ scalar.db.username=SYSTEM
+ scalar.db.password=Oracle
+ ```
+
+
+ SQL Server をローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で SQL Server を実行できます。
+
+ SQL Server を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d sqlserver
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の SQL Server のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For SQL Server
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:sqlserver://localhost:1433;encrypt=true;trustServerCertificate=true
+ scalar.db.username=sa
+ scalar.db.password=SqlServer22
+ ```
+
+
+ Amazon DynamoDB をローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Amazon DynamoDB Local を実行できます。
+
+ Amazon DynamoDB Local を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d dynamodb
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Amazon DynamoDB Local のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For DynamoDB Local
+ scalar.db.storage=dynamo
+ scalar.db.contact_points=sample
+ scalar.db.username=sample
+ scalar.db.password=sample
+ scalar.db.dynamo.endpoint_override=http://localhost:8000
+ ```
+
+
+ Azure Cosmos DB for NoSQL を使用するには、Azure アカウントが必要です。Azure アカウントをお持ちでない場合は、[Azure Cosmos DB アカウントを作成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/quickstart-portal#create-account)にアクセスしてください。
+
+ Cosmos DB for NoSQL を設定する
+
+ [既定の整合性レベルを構成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/how-to-manage-consistency#configure-the-default-consistency-level)の公式ドキュメントに従って、**既定の整合性レベル**を**強力**に設定します。
+
+ ScalarDB を設定する
+
+ 以下の手順では、ローカル環境に JDK が適切にインストールおよび設定されており、Azure で Cosmos DB for NoSQL アカウントが適切に設定されていることを前提としています。
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。`scalar.db.contact_points` と `scalar.db.password` の値は、説明に従って必ず変更してください。
+
+ ```properties
+ # For Cosmos DB
+ scalar.db.storage=cosmos
+ scalar.db.contact_points=
+ scalar.db.password=
+ ```
+
+:::note
+
+Azure Cosmos DB アカウントのプライマリーキーまたはセカンダリキーを `scalar.db.password` の値として使用できます。
+
+:::
+
+
+ Cassandra をローカルで実行する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Apache Cassandra を実行できます。
+
+ Apache Cassandra を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d cassandra
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-kotlin-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Cassandra のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Cassandra
+ scalar.db.storage=cassandra
+ scalar.db.contact_points=localhost
+ scalar.db.username=cassandra
+ scalar.db.password=cassandra
+ ```
+
+
+
+## データベーススキーマをロードする
+
+アプリケーションでデータベーススキーマ (データを整理する方法) を定義する必要があります。サポートされているデータ型の詳細については、[ScalarDB と他のデータベース間のデータ型マッピング](schema-loader.mdx#scalardb-と他のデータベース間のデータ型マッピング)を参照してください。
+
+このチュートリアルでは、**schema.json** というファイルが `scalardb-samples/scalardb-kotlin-sample` ディレクトリに既に存在します。スキーマを適用するには、[`scalardb` Releases](https://github.com/scalar-labs/scalardb/releases) ページに移動し、使用している ScalarDB のバージョンに一致する ScalarDB Schema Loader を `scalardb-samples/scalardb-kotlin-sample` ディレクトリにダウンロードします。
+
+次に、データベースに基づいて、`` をダウンロードした ScalarDB Schema Loader のバージョンに置き換えて、次のコマンドを実行します。
+
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator --no-backup --no-scaling
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+また、Amazon DynamoDB Local は継続的なバックアップと自動スケーリングをサポートしていないため、`--no-backup` および `--no-scaling` オプションが指定されています。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator --replication-factor=1
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+また、`--replication-factor=1` オプションは Cassandra を使用する場合にのみ有効です。デフォルトのレプリケーション係数は `3` ですが、このチュートリアルではセットアップを容易にするために `1` が使用されているため、3 つのノードではなく 1 つのノードを持つクラスターを準備するだけで済みます。ただし、レプリケーション係数 `1` は本番環境には適していないことに注意してください。
+
+:::
+
+
+
+## 基本的な電子マネーアプリケーションでトランザクションを実行し、データを取得します
+
+スキーマをロードした後、クローンしたリポジトリに含まれる基本的な電子マネーアプリケーションでトランザクションを実行し、データを取得できます。
+
+アプリケーションは、次の種類のトランザクションをサポートしています:
+
+- アカウントを作成します。
+- アカウントに資金を追加します。
+- 2 つのアカウント間で資金を送信します。
+- アカウント残高を取得します。
+
+:::note
+
+初めて Gradle コマンドを実行すると、Gradle によって必要なライブラリが自動的にインストールされます。
+
+:::
+
+### 残高のあるアカウントを作成する
+
+アカウント間で資金を送金するには、残高のあるアカウントが必要です。
+
+**customer1** の残高が **500** のアカウントを作成するには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action charge -amount 500 -to customer1"
+```
+
+### 残高のないアカウントを作成する
+
+残高のあるアカウントを設定したら、資金を送金するための別のアカウントが必要です。
+
+残高が **0** の **merchant1** のアカウントを作成するには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action charge -amount 0 -to merchant1"
+```
+
+### アカウントに資金を追加する
+
+[残高のあるアカウントを作成する](#残高のあるアカウントを作成する)でアカウントを作成して資金を追加したのと同じ方法で、アカウントに資金を追加できます。
+
+**customer1** のアカウントに **500** を追加するには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action charge -amount 500 -to customer1"
+```
+
+**customer1** のアカウントの残高は **1000** になります。
+
+### 2 つのアカウント間で電子マネーを送金する
+
+これで 2 つのアカウントが作成され、少なくとも 1 つのアカウントに残高があるので、一方のアカウントからもう一方のアカウントに資金を送金できます。
+
+**customer1** が **merchant1** に **100** を支払うようにするには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action pay -amount 100 -from customer1 -to merchant1"
+```
+
+### アカウント残高を取得する
+
+あるアカウントから別のアカウントに資金を送金した後、各アカウントの残高を確認できます。
+
+**customer1** の残高を取得するには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action getBalance -id customer1"
+```
+
+次の出力が表示されます。
+
+```console
+...
+The balance for customer1 is 900
+...
+```
+
+**merchant1** の残高を取得するには、次のコマンドを実行します。
+
+```console
+./gradlew run --args="-action getBalance -id merchant1"
+```
+
+次の出力が表示されます。
+
+```console
+...
+The balance for merchant1 is 100
+...
+```
+
+## データベースを停止する
+
+データベースを停止するには、次のコマンドを実行して Docker コンテナを停止します。
+
+```console
+docker compose down
+```
+
+## 参照
+
+このチュートリアルで使用されている電子マネーアプリケーションのソースコードを確認するには、[`ElectronicMoney.kt`](https://github.com/scalar-labs/scalardb-samples/blob/main/getting-started-kotlin/src/main/kotlin/sample/ElectronicMoney.kt) を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb.mdx
new file mode 100644
index 00000000..fa3d9eba
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/getting-started-with-scalardb.mdx
@@ -0,0 +1,537 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB をはじめよう
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+この入門チュートリアルでは、ScalarDB でデータベースを設定する方法について説明し、ScalarDB を使用してクレジットカードでアイテムを注文して支払うことができるサンプルの電子商取引アプリケーションを作成するプロセスを示します。サンプルの電子商取引アプリケーションでは、ユーザーがクレジットラインを使用してアイテムを注文して支払う方法を示します。
+
+:::warning
+
+サンプルアプリケーションは ScalarDB の使用方法を示すことに重点を置いているため、アプリケーション固有のエラー処理、認証処理、および同様の機能はサンプルアプリケーションに含まれていません。ScalarDB での例外処理の詳細については、[例外の処理方法](api-guide.mdx#how-to-handle-exceptions)を参照してください。
+
+:::
+
+## このサンプルアプリケーションの前提条件
+
+ScalarDB は Java で記述されているため、環境に次のいずれかの Java Development Kit (JDK) がインストールされている必要があります。
+
+- [Eclipse Temurin](https://adoptium.net/temurin/releases/) の OpenJDK LTS バージョン (8、11、17、または 21)
+- [Docker](https://www.docker.com/get-started/) 20.10 以降と [Docker Compose](https://docs.docker.com/compose/install/) V2 以降
+
+:::note
+
+このサンプルアプリケーションは、Eclipse Temurin の OpenJDK でテストされています。ただし、ScalarDB 自体は、さまざまなベンダーの JDK ディストリビューションでテストされています。互換性のある JDK ディストリビューションを含む ScalarDB の要件の詳細については、[要件](./requirements.mdx)を参照してください。
+
+:::
+
+## ScalarDB サンプルリポジトリのクローンを作成する
+
+**Terminal** を開き、次のコマンドを実行して ScalarDB サンプルリポジトリのクローンを作成します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples
+```
+
+次に、次のコマンドを実行して、サンプルアプリケーションが含まれているディレクトリに移動します。
+
+```console
+cd scalardb-samples/scalardb-sample
+```
+
+## データベースをセットアップする
+
+データベースを選択し、指示に従って ScalarDB 用に設定します。
+
+ScalarDB がサポートするデータベースの一覧については、[データベース](requirements.mdx#データベース)を参照してください。
+
+
+
+ MySQLをローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で MySQL を実行できます。
+
+ MySQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d mysql
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の MySQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For MySQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:mysql://localhost:3306/
+ scalar.db.username=root
+ scalar.db.password=mysql
+ ```
+
+
+ PostgreSQL をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で PostgreSQL を実行できます。
+
+ PostgreSQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d postgres
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の PostgreSQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For PostgreSQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:postgresql://localhost:5432/
+ scalar.db.username=postgres
+ scalar.db.password=postgres
+ ```
+
+
+ Oracle Database をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Oracle Database を実行できます。
+
+ Oracle Database を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d oracle
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Oracle データベースのプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Oracle
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:oracle:thin:@//localhost:1521/FREEPDB1
+ scalar.db.username=SYSTEM
+ scalar.db.password=Oracle
+ ```
+
+
+ SQL Server をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で SQL Server を実行できます。
+
+ SQL Server を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d sqlserver
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の SQL Server のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For SQL Server
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:sqlserver://localhost:1433;encrypt=true;trustServerCertificate=true
+ scalar.db.username=sa
+ scalar.db.password=SqlServer22
+ ```
+
+
+ Amazon DynamoDB をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Amazon DynamoDB Local を実行できます。
+
+ Amazon DynamoDB Local を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d dynamodb
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Amazon DynamoDB Local のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For DynamoDB Local
+ scalar.db.storage=dynamo
+ scalar.db.contact_points=sample
+ scalar.db.username=sample
+ scalar.db.password=sample
+ scalar.db.dynamo.endpoint_override=http://localhost:8000
+ ```
+
+
+ Azure Cosmos DB for NoSQL を使用するには、Azure アカウントが必要です。Azure アカウントをお持ちでない場合は、[Azure Cosmos DB アカウントを作成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/quickstart-portal#create-account)にアクセスしてください。
+
+ Cosmos DB for NoSQL を設定する
+
+ [既定の整合性レベルを構成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/how-to-manage-consistency#configure-the-default-consistency-level)の公式ドキュメントに従って、**既定の整合性レベル**を**強力**に設定します。
+
+ ScalarDB を設定する
+
+ 以下の手順では、ローカル環境に JDK が適切にインストールおよび設定されており、Azure で Cosmos DB for NoSQL アカウントが適切に設定されていることを前提としています。
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。`scalar.db.contact_points` と `scalar.db.password` の値は、説明に従って必ず変更してください。
+
+ ```properties
+ # For Cosmos DB
+ scalar.db.storage=cosmos
+ scalar.db.contact_points=
+ scalar.db.password=
+ ```
+
+:::note
+
+Azure Cosmos DB アカウントのプライマリーキーまたはセカンダリキーを `scalar.db.password` の値として使用できます。
+
+:::
+
+
+ Cassandra をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Apache Cassandra を実行できます。
+
+ Apache Cassandra を起動するには、次のコマンドを実行します。
+ ```console
+ docker compose up -d cassandra
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Cassandra のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Cassandra
+ scalar.db.storage=cassandra
+ scalar.db.contact_points=localhost
+ scalar.db.username=cassandra
+ scalar.db.password=cassandra
+ ```
+
+
+
+## データベーススキーマをロードする
+
+アプリケーションでデータベーススキーマ (データを整理する方法) を定義する必要があります。サポートされているデータ型の詳細については、[ScalarDB と他のデータベース間のデータ型マッピング](schema-loader.mdx#scalardb-と他のデータベース間のデータ型マッピング)を参照してください。
+
+このチュートリアルでは、**schema.json** というファイルが `scalardb-samples/scalardb-sample` ディレクトリに既に存在します。スキーマを適用するには、[`scalardb` Releases](https://github.com/scalar-labs/scalardb/releases) ページに移動し、使用している ScalarDB のバージョンに一致する ScalarDB Schema Loader を `scalardb-samples/scalardb-sample` ディレクトリにダウンロードします。
+
+次に、データベースに基づいて、`` をダウンロードした ScalarDB Schema Loader のバージョンに置き換えて、次のコマンドを実行します。
+
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator --no-backup --no-scaling
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+また、Amazon DynamoDB Local は継続的なバックアップと自動スケーリングをサポートしていないため、`--no-backup` および `--no-scaling` オプションが指定されています。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+:::
+
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config database.properties --schema-file schema.json --coordinator --replication-factor=1
+ ```
+
+:::note
+
+`transaction` が `true` に設定されたテーブルがスキーマ内に存在するため、`--coordinator` オプションが指定されています。スキーマの設定とロードの詳細については、[ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+
+また、`--replication-factor=1` オプションは Cassandra を使用する場合にのみ有効です。デフォルトのレプリケーション係数は `3` ですが、このチュートリアルではセットアップを容易にするために `1` が使用されているため、3 つのノードではなく 1 つのノードを持つクラスターを準備するだけで済みます。ただし、レプリケーション係数 `1` は本番環境には適していないことに注意してください。
+
+:::
+
+
+
+### スキーマの詳細
+
+サンプルアプリケーションの [`schema.json`](https://github.com/scalar-labs/scalardb-samples/tree/main/scalardb-sample/schema.json) に示されているように、すべてのテーブルは `sample` 名前空間に作成されます。
+
+- `sample.customers`: 顧客情報を管理するテーブル
+ - `credit_limit`: 貸し手が顧客に信用枠から支出を許可する最大金額
+ - `credit_total`: 顧客が信用枠から支出した金額
+- `sample.orders`: 注文情報を管理するテーブル
+- `sample.statements`: 注文明細情報を管理するテーブル
+- `sample.items`: 注文するアイテムの情報を管理するテーブル
+
+スキーマのエンティティ関係図は次のとおりです。
+
+
+
+### 初期データをロードする
+
+サンプルアプリケーションを実行する前に、次のコマンドを実行して初期データをロードする必要があります。
+
+```console
+./gradlew run --args="LoadInitialData"
+```
+
+初期データがロードされた後、次のレコードがテーブルに保存される必要があります。
+
+**`sample.customers` テーブル**
+
+| customer_id | name | credit_limit | credit_total |
+|-------------|---------------|--------------|--------------|
+| 1 | Yamada Taro | 10000 | 0 |
+| 2 | Yamada Hanako | 10000 | 0 |
+| 3 | Suzuki Ichiro | 10000 | 0 |
+
+**`sample.items` テーブル**
+
+| item_id | name | price |
+|---------|--------|-------|
+| 1 | Apple | 1000 |
+| 2 | Orange | 2000 |
+| 3 | Grape | 2500 |
+| 4 | Mango | 5000 |
+| 5 | Melon | 3000 |
+
+## サンプルアプリケーションでトランザクションを実行し、データを取得する
+
+次のセクションでは、サンプル電子商取引アプリケーションでトランザクションを実行し、データを取得する方法について説明します。
+
+### 顧客情報を取得する
+
+まず、次のコマンドを実行して、ID が `1` である顧客に関する情報を取得します。
+
+```console
+./gradlew run --args="GetCustomerInfo 1"
+```
+
+次の出力が表示されます。
+
+```console
+...
+{"id": 1, "name": "Yamada Taro", "credit_limit": 10000, "credit_total": 0}
+...
+```
+
+### 注文する
+
+次に、次のコマンドを実行して、顧客 ID `1` にリンゴ 3 個とオレンジ 2 個を注文してもらいます。
+
+:::note
+
+このコマンドの注文形式は `./gradlew run --args="PlaceOrder :,:,..."` です。
+
+:::
+
+```console
+./gradlew run --args="PlaceOrder 1 1:3,2:2"
+```
+
+以下のように、`order_id` の UUID が異なる、注文が成功したことを示す類似の出力が表示されます。
+
+```console
+...
+{"order_id": "dea4964a-ff50-4ecf-9201-027981a1566e"}
+...
+```
+
+### 注文の詳細を確認する
+
+次のコマンドを実行して注文の詳細を確認します。`` は、前のコマンドを実行した後に表示される `order_id` の UUID に置き換えます。
+
+```console
+./gradlew run --args="GetOrder "
+```
+
+`order_id` と `timestamp` の UUID が異なる、以下のような出力が表示されます。
+
+```console
+...
+{"order": {"order_id": "dea4964a-ff50-4ecf-9201-027981a1566e","timestamp": 1650948340914,"customer_id": 1,"customer_name": "Yamada Taro","statement": [{"item_id": 1,"item_name": "Apple","price": 1000,"count": 3,"total": 3000},{"item_id": 2,"item_name": "Orange","price": 2000,"count": 2,"total": 4000}],"total": 7000}}
+...
+```
+
+### 別の注文をする
+
+次のコマンドを実行して、顧客 ID `1` の `credit_total` の残額を使用してメロン 1 個を注文します。
+
+```console
+./gradlew run --args="PlaceOrder 1 5:1"
+```
+
+以下のように、`order_id` の UUID が異なる、注文が成功したことを示す類似の出力が表示されます。
+
+```console
+...
+{"order_id": "bcc34150-91fa-4bea-83db-d2dbe6f0f30d"}
+...
+```
+
+### 注文履歴を確認する
+
+次のコマンドを実行して、顧客 ID `1` のすべての注文履歴を取得します。
+
+```console
+./gradlew run --args="GetOrders 1"
+```
+
+`order_id` と `timestamp` の UUID が異なる以下のような出力が表示されます。これは、顧客 ID `1` のすべての注文履歴をタイムスタンプの降順で表示します。
+
+```console
+...
+{"order": [{"order_id": "dea4964a-ff50-4ecf-9201-027981a1566e","timestamp": 1650948340914,"customer_id": 1,"customer_name": "Yamada Taro","statement": [{"item_id": 1,"item_name": "Apple","price": 1000,"count": 3,"total": 3000},{"item_id": 2,"item_name": "Orange","price": 2000,"count": 2,"total": 4000}],"total": 7000},{"order_id": "bcc34150-91fa-4bea-83db-d2dbe6f0f30d","timestamp": 1650948412766,"customer_id": 1,"customer_name": "Yamada Taro","statement": [{"item_id": 5,"item_name": "Melon","price": 3000,"count": 1,"total": 3000}],"total": 3000}]}
+...
+```
+
+### クレジット合計を確認する
+
+次のコマンドを実行して、顧客 ID `1` のクレジット合計を取得します。
+
+```console
+./gradlew run --args="GetCustomerInfo 1"
+```
+
+次の出力が表示されます。これは、顧客 ID `1` が `credit_total` の `credit_limit` に達しており、これ以上注文できないことを示しています。
+
+```console
+...
+{"id": 1, "name": "Yamada Taro", "credit_limit": 10000, "credit_total": 10000}
+...
+```
+
+次のコマンドを実行して、ブドウ 1 個とマンゴー 1 個を注文してみます。
+
+```console
+./gradlew run --args="PlaceOrder 1 3:1,4:1"
+```
+
+次の出力が表示されます。これは、`credit_total` 金額が `credit_limit` 金額を超えたために注文が失敗したことを示しています。
+
+```console
+...
+java.lang.RuntimeException: Credit limit exceeded
+ at sample.Sample.placeOrder(Sample.java:205)
+ at sample.command.PlaceOrderCommand.call(PlaceOrderCommand.java:33)
+ at sample.command.PlaceOrderCommand.call(PlaceOrderCommand.java:8)
+ at picocli.CommandLine.executeUserObject(CommandLine.java:1783)
+ at picocli.CommandLine.access$900(CommandLine.java:145)
+ at picocli.CommandLine$RunLast.handle(CommandLine.java:2141)
+ at picocli.CommandLine$RunLast.handle(CommandLine.java:2108)
+ at picocli.CommandLine$AbstractParseResultHandler.execute(CommandLine.java:1975)
+ at picocli.CommandLine.execute(CommandLine.java:1904)
+ at sample.command.SampleCommand.main(SampleCommand.java:35)
+...
+```
+
+### 支払いを行う
+
+注文を続行するには、顧客 ID `1` が支払いを行って `credit_total` の金額を減らす必要があります。
+
+次のコマンドを実行して支払いを行います。
+
+```console
+./gradlew run --args="Repayment 1 8000"
+```
+
+次に、次のコマンドを実行して、顧客 ID `1` の `credit_total` 金額を確認します。
+
+```console
+./gradlew run --args="GetCustomerInfo 1"
+```
+
+次の出力が表示されます。これは、顧客 ID `1` に支払いが適用され、`credit_total` の金額が減ったことを示しています。
+
+```console
+...
+{"id": 1, "name": "Yamada Taro", "credit_limit": 10000, "credit_total": 2000}
+...
+```
+
+顧客 ID `1` が支払いを済ませたので、次のコマンドを実行してブドウ 1 個とメロン 1 個を注文します。
+
+```console
+./gradlew run --args="PlaceOrder 1 3:1,4:1"
+```
+
+以下のように、`order_id` の UUID が異なる、注文が成功したことを示す類似の出力が表示されます。
+
+```console
+...
+{"order_id": "8911cab3-1c2b-4322-9386-adb1c024e078"}
+...
+```
+
+## データベースを停止する
+
+データベースを停止するには、次のコマンドを実行して Docker コンテナを停止します。
+
+```console
+docker compose down
+```
+
+## 参照
+
+このチュートリアルで使用される電子商取引アプリケーションのソースコードを確認するには、[`Sample.java`](https://github.com/scalar-labs/scalardb-samples/blob/main/scalardb-sample/src/main/java/sample/Sample.java) を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/data_model.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/data_model.png
new file mode 100644
index 00000000..15a0e4d4
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/data_model.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/getting-started-ERD.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/getting-started-ERD.png
new file mode 100644
index 00000000..1a6d13c5
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/getting-started-ERD.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb.png
new file mode 100644
index 00000000..658486cb
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb_data_model.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb_data_model.png
new file mode 100644
index 00000000..7a02fa23
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/scalardb_data_model.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/software_stack.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/software_stack.png
new file mode 100644
index 00000000..75fba6e6
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/software_stack.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_load_balancing.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_load_balancing.png
new file mode 100644
index 00000000..5cdc26f0
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_load_balancing.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_sequence_diagram.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_sequence_diagram.png
new file mode 100644
index 00000000..116ef635
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/images/two_phase_commit_sequence_diagram.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/manage-backup-and-restore.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/manage-backup-and-restore.mdx
new file mode 100644
index 00000000..7244e655
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/manage-backup-and-restore.mdx
@@ -0,0 +1,26 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# データベースのバックアップと復元
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このガイドでは、ScalarDB で使用されるデータベースのバックアップと復元の方法について説明します。
+
+## データベースのバックアップと復元の基本ガイドライン
+
+バックアップを実行する前に、[ScalarDB で使用されるデータベースのバックアップと復元方法](backup-restore.mdx)を必ずお読みください。
+
+## Kubernetes 環境で ScalarDB を使用する場合のデータベースのバックアップ
+
+Kubernetes 環境でデータベースをバックアップする方法の詳細については、[Kubernetes 環境で NoSQL データベースをバックアップする](scalar-kubernetes/BackupNoSQL.mdx)を参照してください。
+
+## Kubernetes 環境で ScalarDB を使用する場合のデータベースの復元
+
+Kubernetes 環境でデータベースを復元する方法の詳細については、[Kubernetes 環境でデータベースを復元する](scalar-kubernetes/RestoreDatabase.mdx)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/monitor-by-using-scalar-manager.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/monitor-by-using-scalar-manager.mdx
new file mode 100644
index 00000000..b119280e
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/monitor-by-using-scalar-manager.mdx
@@ -0,0 +1,24 @@
+---
+tags:
+ - Enterprise Option
+---
+
+# Scalar Manager を使用して ScalarDB を監視する
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+Scalar Manager は、Kubernetes クラスター環境内の ScalarDB の集中管理および監視ソリューションであり、次のことが可能になります。
+
+- ScalarDB の可用性を確認します。
+- ScalarDB が使用するデータベースでトランザクションの一貫性のある期間を作成する一時停止ジョブをスケジュールまたは実行します。
+- Grafana ダッシュボードを介して ScalarDB の時系列メトリックとログを確認します。
+
+Scalar Manager の詳細については、[Scalar Manager 概要](scalar-manager/overview.mdx)を参照してください。
+
+## Scalar Manager をデプロイする
+
+Helm Chart を使用して Scalar Manager をデプロイできます。
+
+Scalar Manager をデプロイする方法の詳細については、[Scalar Manager のデプロイする方法](helm-charts/how-to-deploy-scalar-manager.mdx)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/multi-storage-transactions.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/multi-storage-transactions.mdx
new file mode 100644
index 00000000..3065a4f6
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/multi-storage-transactions.mdx
@@ -0,0 +1,71 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# マルチストレージトランザクション
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB トランザクションは、*マルチストレージトランザクション* と呼ばれる機能を使用することで、ACID 準拠を維持しながら複数のストレージまたはデータベースにまたがることができます。
+
+このページでは、マルチストレージトランザクションの仕組みと、ScalarDB でこの機能を設定する方法について説明します。
+
+## ScalarDB でのマルチストレージトランザクションの仕組み
+
+ScalarDB では、`マルチストレージ` 実装は複数のストレージインスタンスを保持し、名前空間名から適切なストレージインスタンスへのマッピングを持っています。操作が実行されると、マルチストレージトランザクション機能は、名前空間ストレージマッピングを使用して指定された名前空間から適切なストレージインスタンスを選択し、そのストレージインスタンスを使用します。
+
+## マルチストレージトランザクションをサポートするように ScalarDB を設定する方法
+
+マルチストレージトランザクションを有効にするには、`scalar.db.transaction_manager` の値として `consensus-commit` を指定し、`scalar.db.storage` の値として `multi-storage` を指定し、ScalarDB プロパティファイルでデータベースを設定する必要があります。
+
+以下は、マルチストレージトランザクションの設定例です。
+
+```properties
+# Consensus Commit is required to support multi-storage transactions.
+scalar.db.transaction_manager=consensus-commit
+
+# Multi-storage implementation is used for Consensus Commit.
+scalar.db.storage=multi-storage
+
+# Define storage names by using a comma-separated format.
+# In this case, "cassandra" and "mysql" are used.
+scalar.db.multi_storage.storages=cassandra,mysql
+
+# Define the "cassandra" storage.
+# When setting storage properties, such as `storage`, `contact_points`, `username`, and `password`, for multi-storage transactions, the format is `scalar.db.multi_storage.storages..`.
+# For example, to configure the `scalar.db.contact_points` property for Cassandra, specify `scalar.db.multi_storage.storages.cassandra.contact_point`.
+scalar.db.multi_storage.storages.cassandra.storage=cassandra
+scalar.db.multi_storage.storages.cassandra.contact_points=localhost
+scalar.db.multi_storage.storages.cassandra.username=cassandra
+scalar.db.multi_storage.storages.cassandra.password=cassandra
+
+# Define the "mysql" storage.
+# When defining JDBC-specific configurations for multi-storage transactions, you can follow a similar format of `scalar.db.multi_storage.storages..`.
+# For example, to configure the `scalar.db.jdbc.connection_pool.min_idle` property for MySQL, specify `scalar.db.multi_storage.storages.mysql.jdbc.connection_pool.min_idle`.
+scalar.db.multi_storage.storages.mysql.storage=jdbc
+scalar.db.multi_storage.storages.mysql.contact_points=jdbc:mysql://localhost:3306/
+scalar.db.multi_storage.storages.mysql.username=root
+scalar.db.multi_storage.storages.mysql.password=mysql
+# Define the JDBC-specific configurations for the "mysql" storage.
+scalar.db.multi_storage.storages.mysql.jdbc.connection_pool.min_idle=5
+scalar.db.multi_storage.storages.mysql.jdbc.connection_pool.max_idle=10
+scalar.db.multi_storage.storages.mysql.jdbc.connection_pool.max_total=25
+
+# Define namespace mapping from a namespace name to a storage.
+# The format is ":,...".
+scalar.db.multi_storage.namespace_mapping=user:cassandra,coordinator:mysql
+
+# Define the default storage that's used if a specified table doesn't have any mapping.
+scalar.db.multi_storage.default_storage=cassandra
+```
+
+追加の設定については、[ScalarDB 設定](configurations.mdx)を参照してください。
+
+## 実践的なチュートリアル
+
+実践的なチュートリアルについては、[マルチストレージトランザクションをサポートするサンプルアプリケーションを作成する](scalardb-samples/multi-storage-transaction-sample/README.mdx)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/overview.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/overview.mdx
new file mode 100644
index 00000000..bd025d9a
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/overview.mdx
@@ -0,0 +1,81 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB の概要
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このページでは、ScalarDB の概要と主な使用例について説明します。
+
+## ScalarDB とは
+
+ScalarDB は、さまざまなデータベース向けのハイブリッドトランザクション/分析処理 (HTAP) エンジンです。データベース上でミドルウェアとして実行され、ACID トランザクションとリアルタイム分析を実現することでさまざまなデータベースを仮想的に統合し、複数のデータベースまたは単一のデータベースの複数のインスタンスの管理の複雑さを簡素化します。
+
+
+
+多用途のソリューションである ScalarDB は、次のようなさまざまなデータベースをサポートしています。
+
+- MariaDB、Microsoft SQL Server、MySQL、Oracle Database、PostgreSQL、SQLite などの JDBC をサポートするリレーショナルデータベース、および Amazon Aurora、Google AlloyDB、TiDB、YugabyteDB などの互換性のあるデータベース。
+- Amazon DynamoDB、Apache Cassandra、Azure Cosmos DB などの NoSQL データベース。
+
+ScalarDB がサポートするデータベースの詳細については、[データベース](requirements.mdx#データベース) を参照してください。
+
+## ScalarDB を選ぶ理由
+
+グローバルトランザクションマネージャー、データフェデレーションエンジン、HTAP システムなどのいくつかのソリューションは、同様の目標を持っていますが、次の観点で制限があります。
+
+- グローバルトランザクションマネージャー (Oracle MicroTx や Atomikos など) は、限られた異種データベースセット (XA 準拠のデータベースのみなど) でトランザクションを実行するように設計されています。
+- データフェデレーションエンジン (Denodo や Starburst など) は、異種データベースで分析クエリを実行するように設計されています。
+- HTAP システム (TiDB や SingleStore など) は、同種データベースでのみトランザクションと分析クエリの両方を実行します。
+
+言い換えれば、これらはデータベースを仮想的に統合しますが、制限があります。たとえば、データフェデレーションエンジンを使用すると、ユーザーは複数のデータベースにまたがる仮想ビューで読み取り専用の分析クエリを実行できます。ただし、多くの場合、データベースごとに更新クエリを個別に実行する必要があります。
+
+他のソリューションとは異なり、ScalarDB は、異種データベースでトランザクションクエリと分析クエリの両方を実行できる機能を備えているため、データベース管理を大幅に簡素化できます。
+
+次の表は、ScalarDB が他のソリューションとどのように異なるかをまとめたものです。
+
+| | 異種データベース間のトランザクション | 異種データベース間の分析 |
+| :--------------------------------------------------------------: | :----------------------------------------------------------------------------: | :--------------------------------: |
+| グローバルトランザクションマネージャー (Oracle MicroTx や Atomikos など) | はい(ただし、既存のソリューションでは限られたデータベースのセットしかサポートされていません) | いいえ |
+| データフェデレーションエンジン (Denodo や Starburst など) | いいえ | はい |
+| HTAP システム (TiDB や SingleStore など) | いいえ (同種のデータベースのみサポート) | いいえ (同種のデータベースのみサポート) |
+| **ScalarDB** | **はい (各種データベースに対応)** | **はい** |
+
+## ScalarDB の使用例
+
+ScalarDB はさまざまな用途で使用できます。ScalarDB の主な使用例を 3 つ紹介します。
+
+### サイロ化されたデータベースを簡単に管理
+
+多くの企業は、アジャイルなビジネスオペレーションをサポートするために複数の組織、部門、ビジネスユニットで構成されており、その結果、サイロ化された情報システムになることがよくあります。特に、異なる組織では、異なるデータベースを使用して異なるアプリケーションを管理する可能性があります。このようなサイロ化されたデータベースの管理は、アプリケーションが各データベースと個別に通信し、データベース間の違いを適切に処理する必要があるため、困難です。
+
+ScalarDB は、統一されたインターフェイスを使用してサイロ化されたデータベースの管理を簡素化し、ユーザーがデータベースを 1 つのデータベースのように扱えるようにします。たとえば、ユーザーは複数のデータベースに対して (分析的な) 結合クエリを、それぞれのデータベースとやり取りすることなく実行できます。
+
+### 複数のデータベース間の一貫性の管理
+
+マイクロサービスアーキテクチャなどの最新のアーキテクチャでは、システムでサービスとそのデータベースを小さなサブセットに分割して、システムのモジュール性と開発効率を高めることが推奨されています。しかし、多様なデータベース、特に異なる種類のデータベースを管理するのは困難です。なぜなら、Saga や TCC などのトランザクション管理パターンを使用しても、アプリケーションはそれらのデータベースの正しい状態 (言い換えれば一貫性) を保証する必要があるからです。
+
+ScalarDB は、正確性の保証 (言い換えれば、厳密なシリアル化可能性を備えた ACID) によって、このような多様なデータベースの管理を簡素化します。これにより、データベース間の一貫性の保証を気にすることなく、アプリケーション開発に集中できます。
+
+### データメッシュでのデータ管理の簡素化
+
+企業は、データ利用を合理化および拡張するために、[データメッシュ](https://martinfowler.com/articles/data-mesh-principles.html)の構築に時間を費やしてきました。ただし、データメッシュの構築は必ずしも簡単ではありません。たとえば、分散データの管理方法には多くの技術的な問題があります。
+
+ScalarDB は、データメッシュ内のすべてのデータベースに統一された API を提供することで、データメッシュ内の分散データベースの管理を簡素化し「データをプロダクトとして扱う(Data as a Product)」という原則に簡単に適合させます。
+
+### データベース移行のハードルを下げる
+
+アプリケーションは、データベースが提供する特定の機能のために、特定のデータベースを使用するようにロックされる傾向があります。このようなデータベースロックインにより、データベースのアップグレードや変更が妨げられます。アップグレードや変更を行うには、多くの場合、アプリケーションの書き直しが必要になるからです。
+
+ScalarDB は、多様なデータベースに統一されたインターフェイスを提供します。したがって、ScalarDB インターフェイスを使用してアプリケーションを作成すると、そのアプリケーションは移植可能になり、アプリケーションを書き直すことなくシームレスなデータベース移行を実現できます。
+
+## さらに読む
+
+- [ScalarDB Technical Overview](https://speakerdeck.com/scalar/scalar-db-universal-transaction-manager)
+- [ScalarDB Research Paper [VLDB'23]](https://dl.acm.org/doi/10.14778/3611540.3611563)
\ No newline at end of file
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/quick-start-overview.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/quick-start-overview.mdx
new file mode 100644
index 00000000..1188efaf
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/quick-start-overview.mdx
@@ -0,0 +1,39 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# クイックスタート
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このカテゴリでは、ScalarDB を介してトランザクションとクエリの実行を開始する方法についてのクイックスタートチュートリアルに従うことができます。
+
+## ScalarDB コアライブラリを介してトランザクションを実行してみる
+
+このサブカテゴリでは、Apache 2 ライセンスの下で公開されている ScalarDB コアライブラリを介して ACID トランザクションを実行する方法に関するチュートリアルに従うことができます。
+
+## ScalarDB Cluster を介してトランザクションを実行してみる
+
+このサブカテゴリでは、ScalarDB コアライブラリをラップする [gRPC](https://grpc.io/) サーバーである ScalarDB Cluster を介して ACID トランザクションを実行する方法に関するチュートリアルを参照できます。
+
+:::note
+
+ScalarDB Cluster は Enterprise エディションでのみ利用できます。
+
+:::
+
+## ScalarDB Analytics で分析クエリを実行してみる
+
+このサブカテゴリでは、ScalarDB Analytics というコンポーネントを使用して、ScalarDB で作成したデータベースに対して分析クエリを実行する方法に関するチュートリアルを参照できます。ScalarDB Analytics は現在、ScalarDB トランザクションで更新される ScalarDB 管理データベースのみを対象としていますが、将来的には ScalarDB 管理以外のデータベースも対象とする予定です。
+
+:::note
+
+- ScalarDB Analytics with PostgreSQL は Apache 2 ライセンスでのみ利用可能で、商用ライセンスは必要ありません。
+- ScalarDB Analytics with Spark はプライベートプレビュー中です。
+
+:::
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/requirements.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/requirements.mdx
new file mode 100644
index 00000000..43ce5f29
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/requirements.mdx
@@ -0,0 +1,246 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB の要件
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このページでは、ScalarDB を正しく使用するために必要なツールとそのバージョンについて説明します。
+
+## クライアント SDK
+
+ScalarDB は Java で記述されているため、ScalarDB を操作する最も簡単な方法は、Java Client SDK を使用することです。
+
+- [ScalarDB Core 用 SDK](add-scalardb-to-your-build.mdx)
+- [ScalarDB Cluster 用 SDK](scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx)
+
+### Java
+
+次の Java Software Development (JDK) が検証され、サポートされています。
+
+- **[Oracle JDK](https://www.oracle.com/java/):** 8、11、17、または 21 (LTS バージョン)
+- **[OpenJDK](https://openjdk.org/) ([Eclipse Temurin](https://adoptium.net/temurin/)、[Amazon Corretto](https://aws.amazon.com/corretto/)、または [Microsoft Build of OpenJDK](https://learn.microsoft.com/en-us/java/openjdk/)):** 8、11、17、または 21 (LTS バージョン)
+
+### .NET
+
+ScalarDB は、ScalarDB Cluster と呼ばれる gRPC サーバーとして提供され、proto ファイルから生成された .NET クライアントをラップする [.NET Client SDK](scalardb-cluster-dotnet-client-sdk/overview.mdx) も備えています。
+
+次の .NET バージョンが検証され、サポートされています。
+
+- [.NET 8.0](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)
+- [.NET 6.0](https://dotnet.microsoft.com/en-us/download/dotnet/6.0)
+
+### その他の言語
+
+ScalarDB Cluster は gRPC バージョン 1.65.0 を使用するため、好みの言語で生成されたクライアントを使用して独自のクライアントを作成できます。
+
+## データベース
+
+ScalarDB は、次のデータベースとそのバージョン上で実行されるミドルウェアです。
+
+### リレーショナルデータベース
+
+
+
+
+| バージョン | Oracle Database 23ai | Oracle Database 21c | Oracle Database 19c |
+|:------------------|:---------------------|:--------------------|:--------------------|
+| **ScalarDB 3.14** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ | ✅ |
+
+
+
+
+| バージョン | MySQL 8.1 | MySQL 8.0 | MySQL 5.7 |
+|:------------------|:----------|:----------|:----------|
+| **ScalarDB 3.14** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ | ✅ |
+
+
+
+
+| バージョン | PostgreSQL 15 | PostgreSQL 14 | PostgreSQL 13 | PostgreSQL 12 |
+|:------------------|:--------------|:--------------|:--------------|:--------------|
+| **ScalarDB 3.14** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ | ✅ | ✅ |
+
+
+
+
+| バージョン | Aurora MySQL 3 | Aurora MySQL 2 |
+|:------------------|:---------------|:---------------|
+| **ScalarDB 3.14** | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ |
+
+
+
+
+| バージョン | Aurora PostgreSQL 15 | Aurora PostgreSQL 14 | Aurora PostgreSQL 13 | Aurora PostgreSQL 12 |
+|:------------------|:---------------------|:---------------------|:---------------------|:---------------------|
+| **ScalarDB 3.14** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ | ✅ | ✅ |
+
+
+
+
+| バージョン | MariaDB 11.4 | MariaDB 10.11 |
+|:------------------|:-------------|:--------------|
+| **ScalarDB 3.14** | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ |
+
+
+
+
+| バージョン | SQL Server 2022 | SQL Server 2019 | SQL Server 2017 |
+|:------------------|:----------------|:----------------|:----------------|
+| **ScalarDB 3.14** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.13** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.12** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.11** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.10** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.9** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.8** | ✅ | ✅ | ✅ |
+| **ScalarDB 3.7** | ✅ | ✅ | ✅ |
+
+
+
+
+| バージョン | SQLite 3 |
+|:------------------|:---------|
+| **ScalarDB 3.14** | ✅ |
+| **ScalarDB 3.13** | ✅ |
+| **ScalarDB 3.12** | ✅ |
+| **ScalarDB 3.11** | ✅ |
+| **ScalarDB 3.10** | ✅ |
+| **ScalarDB 3.9** | ✅ |
+| **ScalarDB 3.8** | ❌ |
+| **ScalarDB 3.7** | ❌ |
+
+
+
+
+| バージョン | YugabyteDB 2 |
+|:------------------|:-------------|
+| **ScalarDB 3.14** | ✅ |
+| **ScalarDB 3.13** | ✅ |
+| **ScalarDB 3.12** | ❌ |
+| **ScalarDB 3.11** | ❌ |
+| **ScalarDB 3.10** | ❌ |
+| **ScalarDB 3.9** | ❌ |
+| **ScalarDB 3.8** | ❌ |
+| **ScalarDB 3.7** | ❌ |
+
+
+
+
+### NoSQL データベース
+
+
+
+
+| バージョン | DynamoDB |
+|:------------------|:---------|
+| **ScalarDB 3.14** | ✅ |
+| **ScalarDB 3.13** | ✅ |
+| **ScalarDB 3.12** | ✅ |
+| **ScalarDB 3.11** | ✅ |
+| **ScalarDB 3.10** | ✅ |
+| **ScalarDB 3.9** | ✅ |
+| **ScalarDB 3.8** | ✅ |
+| **ScalarDB 3.7** | ✅ |
+
+
+
+
+| バージョン | Cassandra 4.1 | Cassandra 4.0 | Cassandra 3.11 | Cassandra 3.0 |
+|:------------------|:--------------|:--------------|:---------------|:--------------|
+| **ScalarDB 3.14** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.13** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.12** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.11** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.10** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.9** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.8** | ❌ | ❌ | ✅ | ✅ |
+| **ScalarDB 3.7** | ❌ | ❌ | ✅ | ✅ |
+
+
+
+
+| バージョン | Cosmos DB for NoSQL |
+|:------------------|:--------------------|
+| **ScalarDB 3.14** | ✅ |
+| **ScalarDB 3.13** | ✅ |
+| **ScalarDB 3.12** | ✅ |
+| **ScalarDB 3.11** | ✅ |
+| **ScalarDB 3.10** | ✅ |
+| **ScalarDB 3.9** | ✅ |
+| **ScalarDB 3.8** | ✅ |
+| **ScalarDB 3.7** | ✅ |
+
+
+
+
+:::note
+
+各データベースの設定方法の詳細については、[ScalarDB の基盤となるデータベースの設定](./database-configurations.mdx) を参照してください。
+
+:::
+
+## Kubernetes
+
+ScalarDB は、本番環境では Kubernetes プラットフォーム上の Pod として提供されます。ScalarDB は次のプラットフォームとツールをサポートしています。
+
+### プラットフォーム
+
+- **[Kubernetes](https://kubernetes.io/):** 1.27 - 1.31
+ - **[Amazon Elastic Kubernetes Service (EKS)](https://aws.amazon.com/jp/eks/)**
+ - **[Azure Kubernetes Service (AKS)](https://azure.microsoft.com/ja-jp/products/kubernetes-service)**
+- **[Red Hat OpenShift](https://www.redhat.com/en/technologies/cloud-computing/openshift):** TBD
+
+### パッケージマネージャー
+
+- **[Helm](https://helm.sh/):** 3.5+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/roadmap.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/roadmap.mdx
new file mode 100644
index 00000000..11aeaab8
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/roadmap.mdx
@@ -0,0 +1,96 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB ロードマップ
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このロードマップは、ScalarDB の今後の計画の概要を示しています。このロードマップの目的は、今後どのような変更が行われる可能性があるかを把握できるようにし、進捗状況をより詳しく追跡し、主要なマイルストーンを把握し、開発中にフィードバックを提供することです。このロードマップは、ScalarDB の新しいバージョンがリリースされるたびに更新されます。
+
+:::warning
+
+開発の過程で、このロードマップはユーザーのニーズやフィードバックに基づいて変更される可能性があります。**このロードマップの内容に従ってリリース計画をスケジュールしないでください。**
+
+機能リクエストがある場合、または機能開発を優先したい場合は、[GitHub](https://github.com/scalar-labs/scalardb/issues) で問題を作成してください。
+
+:::
+
+### CY2024 Q4
+
+#### 新しい機能
+
+- **分析のためのデータ仮想化**
+ - ユーザーは、ScalarDB Analytics を介してさまざまなデータソースで読み取り専用の OLAP SQL クエリを実行できるようになります。ScalarDB Analytics は現在、ScalarDB 管理のデータストアのみをサポートしているため、この機能強化により、データソースが ScalarDB トランザクションによって管理されているかどうかに関係なく、リレーショナルデータベースや NoSQL データベースなどのさまざまなデータストアと、Amazon S3 などのクラウドオブジェクトストア内のファイルが仮想的に統合されます。
+- **ベクトルストアの抽象化**
+ - ユーザーは、ScalarDB の新しいベクトルストアインターフェイスを介して、ベクトルストアに埋め込み (ベクトル) を保存したり、ベクトルストアから埋め込みを検索したりできるようになります。この機能により、ユーザーは、既存の ScalarDB インターフェイスを介してデータベースからデータを読み取り、データから埋め込みを作成し、新しいインターフェイスを介してベクトルストアに埋め込みを保存したり、ベクトルストアから埋め込みを検索したりすることで、大規模言語モデル (LLM) を使用した検索拡張生成 (RAG) を実現するプロセスを簡素化できます。
+
+#### セキュリティ
+
+- **きめ細かなアクセス制御**
+ - ユーザーは、基盤となるデータベースへのアクセスをよりきめ細かに承認できるようになります。ScalarDB は、ユーザーが特定の操作を発行する権限を持っているかどうかを確認する現在の単純な承認に加えて、ユーザーが特定のレコードにアクセスできるかどうかも確認します。
+
+#### ユーザビリティ
+
+- **時間関連のデータ型の追加**
+ - ユーザーは時間関連のデータ型を使用できるようになり、既存のアプリケーションの移行が容易になります。
+- **追加書き込み戦略の削除**
+ - ユーザーは、トランザクションをシリアル化可能にするために追加書き込み戦略を使用できなくなります。ScalarDB は現在、トランザクションをシリアル化可能にするために追加読み取り戦略と追加書き込み戦略の 2 つの戦略を提供していますが、追加書き込み戦略にはいくつかの制限があります。たとえば、ユーザーは同じトランザクションで書き込み操作とスキャン操作を発行できません。したがって、この戦略は削除され、ユーザーはアプリケーションを作成するときにこのような制限を心配する必要がなくなります。
+
+#### パフォーマンス
+
+- **1 フェーズコミットの最適化**
+ - ユーザーは、単一のパーティションに書き込む単純なトランザクションの実行速度が速くなります。ScalarDB は、基礎となるデータベースの単一パーティション線形化可能な操作を利用して、トランザクションが 1 つのパーティションのみを更新する場合、正確さを犠牲にすることなく、レコード準備フェーズとコミット状態フェーズを省略します。
+- **ScalarDB メタデータの管理に必要なストレージ領域の削減**
+ - ユーザーは、ScalarDB を実行するために使用するストレージ領域が少なくなる可能性があります。ScalarDB は、コミットされたトランザクションがコミットされた後に、コミット前のイメージを削除します。ただし、コミットされたトランザクションが実際のストレージ領域に影響を与えるかどうかは、基礎となるデータベースによって異なります。
+- **読み取り専用トランザクションのコーディネータ書き込みの削除**
+ - 読み取り専用トランザクションのコーディネータ書き込みを削除することで、ユーザーは読み取り専用トランザクションの実行速度が向上します。
+
+#### クラウドサポート
+
+- **Azure Marketplace でのコンテナオファリング**
+ - ユーザーは、Azure コンテナオファリングを使用して ScalarDB Cluster をデプロイできるようになります。これにより、ユーザーは従量課金制のサブスクリプションモデルを利用できるようになります。
+- **Google Cloud Platform (GCP) のサポート**
+ - ユーザーは、GCP の Google Kubernetes Engine (GKE) に ScalarDB Cluster をデプロイできるようになります。
+
+### CY2025 Q1
+
+#### 新しい機能
+
+- **ネイティブセカンダリインデックス**
+ - ユーザーは柔軟なセカンダリインデックスを定義できるようになります。既存のセカンダリインデックスは、サポートされているデータベースのセカンダリインデックスの共通機能に基づいて実装されているため、制限があります。したがって、たとえば、複数列のインデックスを定義することはできません。新しいセカンダリインデックスは ScalarDB レイヤーで作成されるため、複数列のインデックスなど、より柔軟なインデックスを作成できます。
+
+#### ユーザビリティ
+
+- **集計用の SQL 操作の追加**
+ - ユーザーは ScalarDB SQL で集計操作を発行できるようになります。
+- **大規模なスキャンによるメモリ不足エラーの排除**
+ - ユーザーはメモリ不足エラーを経験することなく大規模なスキャンを発行できるようになります。
+- **一時停止期間中の読み取り操作の有効化**
+ - ユーザーは一時停止期間中でも読み取り操作を発行できるため、バックアップを取りながらデータを読み取ることができます。
+- **より多くのデータタイプの追加**
+ - ユーザーはより多くのデータタイプを使用できるようになるため、既存のアプリケーションの移行が容易になります。
+
+### CY2025 Q2 -
+
+#### ユーザビリティ
+
+- **ビュー**
+ - ユーザーはビューを定義して、複数の異なるデータベースをより簡単かつ簡素化された方法で管理できるようになります。
+
+#### スケーラビリティと可用性
+
+- **半同期レプリケーション**
+ - ユーザーは、災害復旧可能な方法で ScalarDB ベースのアプリケーションを提供できます。たとえば、東京でプライマリサービスを提供し、大阪でスタンバイサービスを提供するとします。東京で壊滅的な障害が発生した場合、プライマリサービスを大阪に切り替えることで、データ損失や長時間のダウンタイムなしにサービスを継続できます。
+
+#### クラウドサポート
+
+- **Red Hat OpenShift のサポート**
+ - ユーザーは、OpenShift 環境で ScalarDB Cluster 用の Red Hat 認定 Helm Charts を使用できるようになります。
+- **Google Cloud Marketplace でのコンテナの提供**
+ - ユーザーは、Google Cloud コンテナの提供を使用して ScalarDB Cluster をデプロイできるようになります。これにより、ユーザーは従量課金制のサブスクリプションモデルを利用できるようになります。
\ No newline at end of file
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-library.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-library.mdx
new file mode 100644
index 00000000..c8ff048e
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-library.mdx
@@ -0,0 +1,274 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# コアライブラリを通じて非トランザクションストレージ操作を実行する
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このガイドでは、ScalarDB コアライブラリを通じて非トランザクションストレージ操作を実行する方法について説明します。
+
+## 準備
+
+このガイドでは、ScalarDB サンプルリポジトリのサンプルを使用して、データベースと ScalarDB をセットアップします。
+
+### ScalarDB サンプルリポジトリのクローンを作成する
+
+**Terminal** を開き、次のコマンドを実行して ScalarDB サンプル リポジトリのクローンを作成します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples
+```
+
+次に、次のコマンドを実行して、必要なファイルが含まれているディレクトリに移動します。
+
+```console
+cd scalardb-samples/scalardb-sample
+```
+
+## データベースをセットアップする
+
+データベースを選択し、指示に従って ScalarDB 用に設定します。
+
+ScalarDB がサポートするデータベースの一覧については、[データベース](requirements.mdx#データベース)を参照してください。
+
+
+
+ MySQLをローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で MySQL を実行できます。
+
+ MySQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d mysql
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の MySQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For MySQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:mysql://localhost:3306/
+ scalar.db.username=root
+ scalar.db.password=mysql
+ ```
+
+
+ PostgreSQL をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で PostgreSQL を実行できます。
+
+ PostgreSQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d postgres
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の PostgreSQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For PostgreSQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:postgresql://localhost:5432/
+ scalar.db.username=postgres
+ scalar.db.password=postgres
+ ```
+
+
+ Oracle Database をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Oracle Database を実行できます。
+
+ Oracle Database を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d oracle
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Oracle データベースのプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Oracle
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:oracle:thin:@//localhost:1521/FREEPDB1
+ scalar.db.username=SYSTEM
+ scalar.db.password=Oracle
+ ```
+
+
+ SQL Server をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で SQL Server を実行できます。
+
+ SQL Server を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d sqlserver
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の SQL Server のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For SQL Server
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:sqlserver://localhost:1433;encrypt=true;trustServerCertificate=true
+ scalar.db.username=sa
+ scalar.db.password=SqlServer22
+ ```
+
+
+ Amazon DynamoDB をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Amazon DynamoDB Local を実行できます。
+
+ Amazon DynamoDB Local を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d dynamodb
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Amazon DynamoDB Local のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For DynamoDB Local
+ scalar.db.storage=dynamo
+ scalar.db.contact_points=sample
+ scalar.db.username=sample
+ scalar.db.password=sample
+ scalar.db.dynamo.endpoint_override=http://localhost:8000
+ ```
+
+
+ Azure Cosmos DB for NoSQL を使用するには、Azure アカウントが必要です。Azure アカウントをお持ちでない場合は、[Azure Cosmos DB アカウントを作成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/quickstart-portal#create-account)にアクセスしてください。
+
+ Cosmos DB for NoSQL を設定する
+
+ [既定の整合性レベルを設定する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/how-to-manage-consistency#configure-the-default-consistency-level)の公式ドキュメントに従って、**既定の整合性レベル**を**強力**に設定します。
+
+ ScalarDB を設定する
+
+ 以下の手順では、ローカル環境に JDK が適切にインストールおよび設定されており、Azure で Cosmos DB for NoSQL アカウントが適切に設定されていることを前提としています。
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。`scalar.db.contact_points` と `scalar.db.password` の値は、説明に従って必ず変更してください。
+
+ ```properties
+ # For Cosmos DB
+ scalar.db.storage=cosmos
+ scalar.db.contact_points=
+ scalar.db.password=
+ ```
+
+:::note
+
+Azure Cosmos DB アカウントのプライマリーキーまたはセカンダリキーを `scalar.db.password` の値として使用できます。
+
+:::
+
+
+ Cassandra をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Apache Cassandra を実行できます。
+
+ Apache Cassandra を起動するには、次のコマンドを実行します。
+ ```console
+ docker compose up -d cassandra
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Cassandra のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Cassandra
+ scalar.db.storage=cassandra
+ scalar.db.contact_points=localhost
+ scalar.db.username=cassandra
+ scalar.db.password=cassandra
+ ```
+
+
+
+ScalarDB の設定の包括的なリストについては、[ScalarDB 設定](configurations.mdx)を参照してください。
+
+## 非トランザクションストレージ操作を実行するようにScalarDBを設定する
+
+非トランザクションストレージ操作を実行するには、設定ファイル **database.properties** で `scalar.db.transaction_manager` プロパティを `single-crud-operation` に設定する必要があります。
+
+```properties
+scalar.db.transaction_manager=single-crud-operation
+```
+
+## スキーマを作成またはインポートする
+
+ScalarDB には、実装固有のデータモデルとスキーマにマップされる独自のデータモデルとスキーマがあります。
+
+- **データベーススキーマを作成する必要がありますか?** [ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+- **既存のデータベースをインポートする必要がありますか?** [ScalarDB Schema Loader を使用して既存のテーブルを ScalarDB にインポートする](schema-loader-import.mdx)を参照してください。
+
+## Java アプリケーションを作成する
+
+このセクションでは、ScalarDB コアライブラリをプロジェクトに追加する方法と、Java を使用して非トランザクションストレージ操作を実行するように設定する方法について説明します。
+
+### ScalarDB をプロジェクトに追加する
+
+ScalarDB ライブラリは、[Maven Central Repository](https://mvnrepository.com/artifact/com.scalar-labs/scalardb) で入手できます。Gradle または Maven を使用して、ライブラリをビルド依存関係としてアプリケーションに追加できます。
+
+ビルドツールを選択し、手順に従って ScalarDB のビルド依存関係をアプリケーションに追加します。
+
+
+
+ Gradle を使用して ScalarDB のビルド依存関係を追加するには、アプリケーションの `build.gradle` に以下を追加します。
+
+ ```gradle
+ dependencies {
+ implementation 'com.scalar-labs:scalardb:3.13.1'
+ }
+ ```
+
+
+ Maven を使用して ScalarDB のビルド依存関係を追加するには、アプリケーションの `pom.xml` に以下を追加します。
+
+ ```xml
+
+ com.scalar-labs
+ scalardb
+ 3.13.1
+
+ ```
+
+
+
+### Java API を使用する
+
+Java API の詳細については、[ScalarDB Java API ガイド](api-guide.mdx)を参照してください。
+
+:::note
+
+非トランザクションストレージ操作には、次の制限が適用されます:
+
+- トランザクションの開始はサポートされていません。詳細については、[トランザクションを開始せずにトランザクションを実行する](api-guide.mdx#トランザクションを開始せずにトランザクションを実行する)を参照してください。
+- 1 つのトランザクションで複数のミューテーションを実行することはサポートされていません。
+
+:::
+
+### 詳細はこちら
+
+- [Javadoc](https://javadoc.io/doc/com.scalar-labs/scalardb/3.13.1/index.html)
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-primitive-crud-interface.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-primitive-crud-interface.mdx
new file mode 100644
index 00000000..465278dd
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-non-transactional-storage-operations-through-primitive-crud-interface.mdx
@@ -0,0 +1,882 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# プリミティブ CRUD インターフェースを介して非トランザクションストレージ操作を実行する
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このページでは、プリミティブ CRUD インターフェース (Storage API とも呼ばれる) を通じて非トランザクションストレージ操作を実行する方法について説明します。このガイドでは、読者が ScalarDB について高度な知識を持っていることを前提としています。
+
+既存のストレージおよびデータベースシステム上でストレージに依存しない、またはデータベースに依存しない ACID トランザクションを実現するための鍵の 1 つは、ScalarDB が提供するストレージ抽象化機能です。ストレージ抽象化は、[データモデル](design.mdx#データモデル) と、データモデルに基づいて操作を発行する API (Storage API) を定義します。
+
+ほとんどの場合、[Transactional API](api-guide.mdx#transactional-api) を使用することになりますが、別のオプションとして Storage API を使用することもできます。
+
+Storage API を使用する利点は次のとおりです。
+
+- トランザクション API と同様に、基盤となるストレージ実装についてあまり気にせずにアプリケーションコードを作成できます。
+- アプリケーション内の一部のデータに対してトランザクションが必要ない場合は、Storage API を使用してトランザクションを部分的に回避し、実行を高速化できます。
+
+:::warning
+
+ストレージ API を直接使用したり、トランザクション API とストレージ API を混在させたりした場合、予期しない動作が発生する可能性があります。たとえば、ストレージ API はトランザクション機能を提供できないため、操作の実行時に障害が発生すると、API によって異常やデータの不整合が発生する可能性があります。
+
+したがって、ストレージ API の使用には *非常に* 注意し、何をしているのかを正確に理解している場合にのみ使用してください。
+
+:::
+
+## ストレージ API の例
+
+このセクションでは、基本的な電子マネーアプリケーションでストレージ API を使用する方法について説明します。
+
+:::warning
+
+この例では電子マネーアプリケーションが簡略化されており、実稼働環境には適していません。
+
+:::
+
+### ScalarDB の設定
+
+開始する前に、[ScalarDB をはじめよう](getting-started-with-scalardb.mdx) で説明されているのと同じ方法で ScalarDB を設定する必要があります。
+
+これを念頭に置いて、このストレージ API の例では、設定ファイル `scalardb.properties` が存在することを前提としています。
+
+### データベーススキーマの設定
+
+アプリケーションでデータベーススキーマ (データを整理する方法) を定義する必要があります。サポートされているデータ型の詳細については、[ScalarDB と他のデータベース間のデータ型マッピング](schema-loader.mdx#scalardb-と他のデータベース間のデータ型マッピング)を参照してください。
+
+この例では、`scalardb/docs/getting-started` ディレクトリに `emoney-storage.json` という名前のファイルを作成します。次に、次の JSON コードを追加してスキーマを定義します。
+
+:::note
+
+次の JSON では、`transaction` フィールドが `false` に設定されており、このテーブルを Storage API で使用する必要があることを示しています。
+
+:::
+
+```json
+{
+ "emoney.account": {
+ "transaction": false,
+ "partition-key": [
+ "id"
+ ],
+ "clustering-key": [],
+ "columns": {
+ "id": "TEXT",
+ "balance": "INT"
+ }
+ }
+}
+```
+
+スキーマを適用するには、[ScalarDB Releases](https://github.com/scalar-labs/scalardb/releases) ページに移動し、使用している ScalarDB のバージョンに一致する ScalarDB Schema Loader を `getting-started` フォルダーにダウンロードします。
+
+次に、`` をダウンロードした ScalarDB Schema Loader のバージョンに置き換えて、次のコマンドを実行します。
+
+```console
+java -jar scalardb-schema-loader-.jar --config scalardb.properties -f emoney-storage.json
+```
+
+### サンプルコード
+
+以下は、Storage API を使用する電子マネーアプリケーションのサンプルソースコードです。
+
+:::warning
+
+前述のとおり、Storage API はトランザクション機能を提供できないため、操作の実行中に障害が発生すると、API によって異常やデータの不整合が発生する可能性があります。したがって、Storage API の使用には十分注意し、何をしているのかを正確に理解している場合にのみ使用してください。
+
+:::
+
+```java
+public class ElectronicMoney {
+
+ private static final String SCALARDB_PROPERTIES =
+ System.getProperty("user.dir") + File.separator + "scalardb.properties";
+ private static final String NAMESPACE = "emoney";
+ private static final String TABLENAME = "account";
+ private static final String ID = "id";
+ private static final String BALANCE = "balance";
+
+ private final DistributedStorage storage;
+
+ public ElectronicMoney() throws IOException {
+ StorageFactory factory = StorageFactory.create(SCALARDB_PROPERTIES);
+ storage = factory.getStorage();
+ }
+
+ public void charge(String id, int amount) throws ExecutionException {
+ // Retrieve the current balance for id
+ Get get =
+ Get.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, id))
+ .build();
+ Optional result = storage.get(get);
+
+ // Calculate the balance
+ int balance = amount;
+ if (result.isPresent()) {
+ int current = result.get().getInt(BALANCE);
+ balance += current;
+ }
+
+ // Update the balance
+ Put put =
+ Put.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, id))
+ .intValue(BALANCE, balance)
+ .build();
+ storage.put(put);
+ }
+
+ public void pay(String fromId, String toId, int amount) throws ExecutionException {
+ // Retrieve the current balances for ids
+ Get fromGet =
+ Get.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, fromId))
+ .build();
+ Get toGet =
+ Get.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, toId))
+ .build();
+ Optional fromResult = storage.get(fromGet);
+ Optional toResult = storage.get(toGet);
+
+ // Calculate the balances (it assumes that both accounts exist)
+ int newFromBalance = fromResult.get().getInt(BALANCE) - amount;
+ int newToBalance = toResult.get().getInt(BALANCE) + amount;
+ if (newFromBalance < 0) {
+ throw new RuntimeException(fromId + " doesn't have enough balance.");
+ }
+
+ // Update the balances
+ Put fromPut =
+ Put.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, fromId))
+ .intValue(BALANCE, newFromBalance)
+ .build();
+ Put toPut =
+ Put.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, toId))
+ .intValue(BALANCE, newToBalance)
+ .build();
+ storage.put(fromPut);
+ storage.put(toPut);
+ }
+
+ public int getBalance(String id) throws ExecutionException {
+ // Retrieve the current balances for id
+ Get get =
+ Get.newBuilder()
+ .namespace(NAMESPACE)
+ .table(TABLENAME)
+ .partitionKey(Key.ofText(ID, id))
+ .build();
+ Optional result = storage.get(get);
+
+ int balance = -1;
+ if (result.isPresent()) {
+ balance = result.get().getInt(BALANCE);
+ }
+ return balance;
+ }
+
+ public void close() {
+ storage.close();
+ }
+}
+```
+
+## ストレージ API ガイド
+
+ストレージ API は、管理 API と CRUD API で設定されています。
+
+### 管理 API
+
+このセクションで説明するように、管理操作をプログラムで実行できます。
+
+:::note
+
+管理操作を実行するために使用できる別の方法は、[Schema Loader](schema-loader.mdx) を使用することです。
+
+:::
+
+#### `DistributedStorageAdmin` インスタンスを取得する
+
+管理操作を実行するには、まず `DistributedStorageAdmin` インスタンスを取得する必要があります。次のように `StorageFactory` から `DistributedStorageAdmin` インスタンスを取得できます。
+
+```java
+StorageFactory storageFactory = StorageFactory.create("");
+DistributedStorageAdmin admin = storageFactory.getStorageAdmin();
+```
+
+設定の詳細については、[ScalarDB 設定](configurations.mdx)を参照してください。
+
+すべての管理操作を実行したら、次のように `DistributedStorageAdmin` インスタンスを閉じる必要があります。
+
+```java
+admin.close();
+```
+
+#### 名前空間を作成する
+
+テーブルは 1 つの名前空間に属するため、テーブルを作成する前に名前空間を作成する必要があります。
+
+名前空間は次のように作成できます。
+
+```java
+// Create the namespace "ns". If the namespace already exists, an exception will be thrown.
+admin.createNamespace("ns");
+
+// Create the namespace only if it does not already exist.
+boolean ifNotExists = true;
+admin.createNamespace("ns", ifNotExists);
+
+// Create the namespace with options.
+Map options = ...;
+admin.createNamespace("ns", options);
+```
+
+作成オプションの詳細については、[作成オプション](api-guide.mdx#作成オプション)を参照してください。
+
+#### テーブルを作成する
+
+テーブルを作成するときは、テーブルメタデータを定義してからテーブルを作成する必要があります。
+
+テーブルメタデータを定義するには、`TableMetadata` を使用できます。次に、テーブルの列、パーティションキー、クラスタリングキー (クラスタリング順序を含む)、およびセカンダリインデックスを定義する方法を示します。
+
+```java
+// Define the table metadata.
+TableMetadata tableMetadata =
+ TableMetadata.newBuilder()
+ .addColumn("c1", DataType.INT)
+ .addColumn("c2", DataType.TEXT)
+ .addColumn("c3", DataType.BIGINT)
+ .addColumn("c4", DataType.FLOAT)
+ .addColumn("c5", DataType.DOUBLE)
+ .addPartitionKey("c1")
+ .addClusteringKey("c2", Scan.Ordering.Order.DESC)
+ .addClusteringKey("c3", Scan.Ordering.Order.ASC)
+ .addSecondaryIndex("c4")
+ .build();
+```
+
+ScalarDB のデータモデルの詳細については、[データモデル](design.mdx#データモデル)を参照してください。
+
+次に、次のようにテーブルを作成します。
+
+```java
+// Create the table "ns.tbl". If the table already exists, an exception will be thrown.
+admin.createTable("ns", "tbl", tableMetadata);
+
+// Create the table only if it does not already exist.
+boolean ifNotExists = true;
+admin.createTable("ns", "tbl", tableMetadata, ifNotExists);
+
+// Create the table with options.
+Map options = ...;
+admin.createTable("ns", "tbl", tableMetadata, options);
+```
+
+#### セカンダリインデックスを作成する
+
+セカンダリインデックスは次のように作成できます。
+
+```java
+// Create a secondary index on column "c5" for table "ns.tbl". If a secondary index already exists, an exception will be thrown.
+admin.createIndex("ns", "tbl", "c5");
+
+// Create the secondary index only if it does not already exist.
+boolean ifNotExists = true;
+admin.createIndex("ns", "tbl", "c5", ifNotExists);
+
+// Create the secondary index with options.
+Map options = ...;
+admin.createIndex("ns", "tbl", "c5", options);
+```
+
+#### テーブルに新しい列を追加する
+
+次のように、テーブルに新しい非パーティションキー列を追加できます。
+
+```java
+// Add a new column "c6" with the INT data type to the table "ns.tbl".
+admin.addNewColumnToTable("ns", "tbl", "c6", DataType.INT)
+```
+
+:::warning
+
+テーブルに新しい列を追加する場合は、基盤となるストレージによって実行時間が大きく異なる可能性があるため、慎重に検討する必要があります。それに応じて計画を立て、特にデータベースが本番環境で実行されている場合は、次の点を考慮してください。
+
+- **Cosmos DB for NoSQL および DynamoDB の場合:** テーブルスキーマは変更されないため、列の追加はほぼ瞬時に行われます。別のテーブルに格納されているテーブルメタデータのみが更新されます。
+- **Cassandra の場合:** 列を追加すると、スキーマメタデータのみが更新され、既存のスキーマレコードは変更されません。クラスタートポロジが実行時間の主な要因です。スキーマメタデータの変更は、ゴシッププロトコルを介して各クラスターノードに共有されます。このため、クラスターが大きいほど、すべてのノードが更新されるまでの時間が長くなります。
+- **リレーショナルデータベース (MySQL、Oracle など) の場合:** 列の追加は実行にそれほど時間がかかりません。
+
+:::
+
+#### テーブルを切り捨てる
+
+テーブルを切り捨てるには、次のようにします。
+
+```java
+// Truncate the table "ns.tbl".
+admin.truncateTable("ns", "tbl");
+```
+
+#### セカンダリインデックスを削除する
+
+セカンダリインデックスは次のように削除できます。
+
+```java
+// Drop the secondary index on column "c5" from table "ns.tbl". If the secondary index does not exist, an exception will be thrown.
+admin.dropIndex("ns", "tbl", "c5");
+
+// Drop the secondary index only if it exists.
+boolean ifExists = true;
+admin.dropIndex("ns", "tbl", "c5", ifExists);
+```
+
+#### テーブルを削除する
+
+テーブルを削除するには、次のようにします。
+
+```java
+// Drop the table "ns.tbl". If the table does not exist, an exception will be thrown.
+admin.dropTable("ns", "tbl");
+
+// Drop the table only if it exists.
+boolean ifExists = true;
+admin.dropTable("ns", "tbl", ifExists);
+```
+
+#### 名前空間を削除する
+
+名前空間を削除するには、次のようにします。
+
+```java
+// Drop the namespace "ns". If the namespace does not exist, an exception will be thrown.
+admin.dropNamespace("ns");
+
+// Drop the namespace only if it exists.
+boolean ifExists = true;
+admin.dropNamespace("ns", ifExists);
+```
+
+#### 既存の名前空間を取得する
+
+既存の名前空間は次のように取得できます。
+
+```java
+Set namespaces = admin.getNamespaceNames();
+```
+
+#### 名前空間のテーブルを取得する
+
+名前空間のテーブルは次のように取得できます。
+
+```java
+// Get the tables of the namespace "ns".
+Set tables = admin.getNamespaceTableNames("ns");
+```
+
+#### テーブルメタデータを取得する
+
+テーブルメタデータは次のように取得できます。
+
+```java
+// Get the table metadata for "ns.tbl".
+TableMetadata tableMetadata = admin.getTableMetadata("ns", "tbl");
+```
+
+#### 名前空間を修復する
+
+名前空間が不明な状態の場合 (名前空間が基盤となるストレージに存在するが ScalarDB メタデータが存在しない、またはその逆)、このメソッドは必要に応じて名前空間とそのメタデータを再作成します。
+
+名前空間は次のように修復できます。
+
+```java
+// Repair the namespace "ns" with options.
+Map options = ...;
+ admin.repairNamespace("ns", options);
+```
+
+#### テーブルを修復する
+
+テーブルが不明な状態の場合 (テーブルは基盤となるストレージに存在するが ScalarDB メタデータは存在しない、またはその逆)、このメソッドは必要に応じてテーブル、そのセカンダリインデックス、およびそのメタデータを再作成します。
+
+テーブルは次のように修復できます。
+
+```java
+// Repair the table "ns.tbl" with options.
+TableMetadata tableMetadata =
+ TableMetadata.newBuilder()
+ ...
+ .build();
+Map options = ...;
+admin.repairTable("ns", "tbl", tableMetadata, options);
+```
+
+#### 最新の ScalarDB API をサポートするように環境をアップグレードする
+
+ScalarDB API の最新バージョンをサポートするように ScalarDB 環境をアップグレードできます。通常、リリースノートに記載されているように、アプリケーション環境が使用する ScalarDB バージョンを更新した後、このメソッドを実行する必要があります。
+
+```java
+// Upgrade the ScalarDB environment.
+Map options = ...;
+admin.upgrade(options);
+```
+
+### CRUD 操作を実装する
+
+次のセクションでは、CRUD 操作について説明します。
+
+#### `DistributedStorage` インスタンスを取得する
+
+Storage API で CRUD 操作を実行するには、`DistributedStorage` インスタンスを取得する必要があります。
+
+インスタンスは次のように取得できます。
+
+```java
+StorageFactory storageFactory = StorageFactory.create("");
+DistributedStorage storage = storageFactory.getStorage();
+```
+
+すべての CRUD 操作を実行したら、次のように `DistributedStorage` インスタンスを閉じる必要があります。
+
+```java
+storage.close();
+```
+
+#### `Get` 操作
+
+`Get` は、プライマリーキーで指定された単一のレコードを取得する操作です。
+
+まず `Get` オブジェクトを作成し、次に次のように `storage.get()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Get` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .projections("c1", "c2", "c3", "c4")
+ .build();
+
+// Execute the `Get` operation.
+Optional result = storage.get(get);
+```
+
+また、投影を指定して、返される列を選択することもできます。
+
+`Key` オブジェクトの構築方法の詳細については、[キーの構築](api-guide.mdx#キーの構築)を参照してください。また、`Result` オブジェクトの処理方法の詳細については、[Result オブジェクトの処理](api-guide.mdx#result-オブジェクトの処理)を参照してください。
+
+##### 一貫性レベルを指定する
+
+Storage API の各操作 (`Get`、`Scan`、`Put`、`Delete`) で一貫性レベルを次のように指定できます。
+
+```java
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .consistency(Consistency.LINEARIZABLE) // Consistency level
+ .build();
+```
+
+次の表は、3 つの一貫性レベルについて説明しています。
+
+| 一貫性レベル | 説明 |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `SEQUENTIAL` | 順次一貫性は、基礎となるストレージ実装によってすべての操作が何らかの順次順序で実行されるようにされ、各プロセスの操作がこの順序で実行されることを前提としています。 |
+| `EVENTUAL` | 結果一貫性は、基礎となるストレージ実装によってすべての操作が最終的に実行されることを前提としています。 |
+| `LINEARIZABLE` | 線形化可能な一貫性は、基礎となるストレージ実装によって各操作が呼び出しから完了までの間のある時点でアトミックに実行されるようにされることを前提としています。 |
+
+##### セカンダリインデックスを使用して `Get` を実行する
+
+セカンダリインデックスを使用して `Get` 操作を実行できます。
+
+パーティションキーを指定する代わりに、次のようにインデックスキー (インデックス付き列) を指定してセカンダリインデックスを使用できます。
+
+```java
+// Create a `Get` operation by using a secondary index.
+Key indexKey = Key.ofFloat("c4", 1.23F);
+
+Get get =
+ Get.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .indexKey(indexKey)
+ .projections("c1", "c2", "c3", "c4")
+ .build();
+
+// Execute the `Get` operation.
+Optional result = storage.get(get);
+```
+
+:::note
+
+結果に複数のレコードがある場合、`storage.get()` は例外をスローします。
+
+:::
+
+#### `Scan` 操作
+
+`Scan` は、パーティション内の複数のレコードを取得する操作です。`Scan` 操作では、クラスタリングキーの境界とクラスタリングキー列の順序を指定できます。
+
+まず `Scan` オブジェクトを作成し、次に次のように `storage.scan()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Scan` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key startClusteringKey = Key.of("c2", "aaa", "c3", 100L);
+Key endClusteringKey = Key.of("c2", "aaa", "c3", 300L);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .start(startClusteringKey, true) // Include startClusteringKey
+ .end(endClusteringKey, false) // Exclude endClusteringKey
+ .projections("c1", "c2", "c3", "c4")
+ .orderings(Scan.Ordering.desc("c2"), Scan.Ordering.asc("c3"))
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+Scanner scanner = storage.scan(scan);
+```
+
+クラスタリングキー境界を省略するか、`start` 境界または `end` 境界のいずれかを指定できます。`orderings` を指定しない場合は、テーブルの作成時に定義したクラスタリング順序で結果が並べられます。
+
+さらに、`projections` を指定して返される列を選択し、`limit` を使用して `Scan` 操作で返されるレコードの数を指定できます。
+
+##### `Scanner` オブジェクトの処理
+
+Storage API の `Scan` 操作は `Scanner` オブジェクトを返します。
+
+`Scanner` オブジェクトから結果を 1 つずつ取得する場合は、次のように `one()` メソッドを使用できます。
+
+```java
+Optional result = scanner.one();
+```
+
+または、すべての結果のリストを取得する場合は、次のように `all()` メソッドを使用できます。
+
+```java
+List results = scanner.all();
+```
+
+さらに、`Scanner` は `Iterable` を実装しているので、次のように for-each ループ内で `Scanner` を使用できます。
+
+```java
+for (Result result : scanner) {
+ ...
+}
+```
+
+結果を取得した後は、`Scanner` オブジェクトを閉じることを忘れないでください。
+
+```java
+scanner.close();
+```
+
+または、次のように `try`-with-resources を使用することもできます。
+
+```java
+try (Scanner scanner = storage.scan(scan)) {
+ ...
+}
+```
+
+##### セカンダリインデックスを使用して `Scan` を実行する
+
+セカンダリインデックスを使用して `Scan` 操作を実行できます。
+
+パーティションキーを指定する代わりに、次のようにインデックスキー (インデックス付き列) を指定してセカンダリインデックスを使用できます。
+
+```java
+// Create a `Scan` operation by using a secondary index.
+Key indexKey = Key.ofFloat("c4", 1.23F);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .indexKey(indexKey)
+ .projections("c1", "c2", "c3", "c4")
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+Scanner scanner = storage.scan(scan);
+```
+
+:::note
+
+セカンダリインデックスを使用して、`Scan` でクラスタリングキーの境界と順序を指定することはできません。
+
+:::
+
+##### パーティションキーを指定せずに `Scan` を実行して、テーブルのすべてのレコードを取得します
+
+パーティションキーを指定せずに `Scan` 操作を実行できます。
+
+ビルダーで `partitionKey()` メソッドを呼び出す代わりに、次のように `all()` メソッドを呼び出して、パーティションキーを指定せずにテーブルをスキャンできます。
+
+```java
+// Create a `Scan` operation without specifying a partition key.
+Key partitionKey = Key.ofInt("c1", 10);
+Key startClusteringKey = Key.of("c2", "aaa", "c3", 100L);
+Key endClusteringKey = Key.of("c2", "aaa", "c3", 300L);
+
+Scan scan =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .projections("c1", "c2", "c3", "c4")
+ .limit(10)
+ .build();
+
+// Execute the `Scan` operation.
+Scanner scanner = storage.scan(scan);
+```
+
+:::note
+
+パーティションキーを指定せずに `Scan` でクラスタリングキーの境界と順序を指定することはできません。
+
+:::
+
+#### `Put` 操作
+
+`Put` は、プライマリーキーで指定されたレコードを配置する操作です。この操作はレコードの upsert 操作として動作し、レコードが存在する場合はレコードを更新し、レコードが存在しない場合はレコードを挿入します。
+
+まず `Put` オブジェクトを作成し、次に次のように `storage.put()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Put` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+// Execute the `Put` operation.
+storage.put(put);
+```
+
+次のように `null` 値を持つレコードを配置することもできます。
+
+```java
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", null)
+ .doubleValue("c5", null)
+ .build();
+```
+
+:::note
+
+`Put` 操作ビルダーで `enableImplicitPreRead()`、`disableImplicitPreRead()`、または `implicitPreReadEnabled()` を指定した場合、それらは無視されます。
+
+:::
+
+#### `Delete` 操作
+
+`Delete` は、プライマリーキーで指定されたレコードを削除する操作です。
+
+まず `Delete` オブジェクトを作成し、次に次のように `storage.delete()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create a `Delete` operation.
+Key partitionKey = Key.ofInt("c1", 10);
+Key clusteringKey = Key.of("c2", "aaa", "c3", 100L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .build();
+
+// Execute the `Delete` operation.
+storage.delete(delete);
+```
+
+#### 条件付きの `Put` および `Delete`
+
+条件をチェックするロジックを実装することで、操作を実行する前に満たす必要がある任意の条件 (たとえば、銀行口座の残高は 0 以上である必要があります) を記述できます。または、`Put` や `Delete` などのミューテーション操作で単純な条件を記述することもできます。
+
+`Put` または `Delete` 操作に条件が含まれている場合、指定された条件が満たされた場合にのみ操作が実行されます。操作の実行時に条件が満たされていない場合は、`NoMutationException` という例外がスローされます。
+
+##### `Put` の条件
+
+Storage API の `Put` 操作では、指定された条件が一致した場合にのみ `Put` 操作が実行されるようにする条件を指定できます。この操作は、条件が比較され、更新がアトミックに実行される比較とスワップの操作に似ています。
+
+`Put` 操作では次のように条件を指定できます。
+
+```java
+// Build a condition.
+MutationCondition condition =
+ ConditionBuilder.putIf(ConditionBuilder.column("c4").isEqualToFloat(0.0F))
+ .and(ConditionBuilder.column("c5").isEqualToDouble(0.0))
+ .build();
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .condition(condition) // condition
+ .build();
+```
+
+`putIf` 条件以外に、`putIfExists` および `putIfNotExists` 条件を次のように指定できます。
+
+```java
+// Build a `putIfExists` condition.
+MutationCondition putIfExistsCondition = ConditionBuilder.putIfExists();
+
+// Build a `putIfNotExists` condition.
+MutationCondition putIfNotExistsCondition = ConditionBuilder.putIfNotExists();
+```
+
+##### `Delete` の条件
+
+`Put` 操作と同様に、Storage API の `Delete` 操作でも条件を指定できます。
+
+`Delete` 操作では、次のように条件を指定できます。
+
+```java
+// Build a condition.
+MutationCondition condition =
+ ConditionBuilder.deleteIf(ConditionBuilder.column("c4").isEqualToFloat(0.0F))
+ .and(ConditionBuilder.column("c5").isEqualToDouble(0.0))
+ .build();
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKey)
+ .condition(condition) // condition
+ .build();
+```
+
+`deleteIf` 条件を使用するだけでなく、次のように `deleteIfExists` 条件を指定することもできます。
+
+```java
+// Build a `deleteIfExists` condition.
+MutationCondition deleteIfExistsCondition = ConditionBuilder.deleteIfExists();
+```
+
+#### ミューテート操作
+
+ミューテートは、単一のパーティションで複数のミューテート (`Put` および `Delete` 操作) を実行する操作です。
+
+まずミューテートオブジェクトを作成し、次に次のように `storage.mutate()` メソッドを使用してオブジェクトを実行する必要があります。
+
+```java
+// Create `Put` and `Delete` operations.
+Key partitionKey = Key.ofInt("c1", 10);
+
+Key clusteringKeyForPut = Key.of("c2", "aaa", "c3", 100L);
+
+Put put =
+ Put.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForPut)
+ .floatValue("c4", 1.23F)
+ .doubleValue("c5", 4.56)
+ .build();
+
+Key clusteringKeyForDelete = Key.of("c2", "bbb", "c3", 200L);
+
+Delete delete =
+ Delete.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .partitionKey(partitionKey)
+ .clusteringKey(clusteringKeyForDelete)
+ .build();
+
+// Execute the operations.
+storage.mutate(Arrays.asList(put, delete));
+```
+
+:::note
+
+Mutate 操作では、単一のパーティションのミューテーションのみが受け入れられます。それ以外の場合は、例外がスローされます。
+
+さらに、Mutate 操作で複数の条件を指定すると、すべての条件が一致した場合にのみ操作が実行されます。
+
+:::
+
+#### CRUD 操作のデフォルト名前空間
+
+すべての CRUD 操作のデフォルト名前空間は、ScalarDB 設定のプロパティを使用して設定できます。
+
+```properties
+scalar.db.default_namespace_name=
+```
+
+名前空間を指定しない操作では、設定で設定されたデフォルトの名前空間が使用されます。
+
+```java
+// This operation will target the default namespace.
+Scan scanUsingDefaultNamespace =
+ Scan.newBuilder()
+ .table("tbl")
+ .all()
+ .build();
+// This operation will target the "ns" namespace.
+Scan scanUsingSpecifiedNamespace =
+ Scan.newBuilder()
+ .namespace("ns")
+ .table("tbl")
+ .all()
+ .build();
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-transactions-through-scalardb-core-library.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-transactions-through-scalardb-core-library.mdx
new file mode 100644
index 00000000..5402ef0a
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/run-transactions-through-scalardb-core-library.mdx
@@ -0,0 +1,222 @@
+---
+tags:
+ - Community
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB コアライブラリを介してトランザクションを実行する
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このガイドでは、ScalarDB コアライブラリを使用して、ScalarDB プロパティファイルを設定し、1 フェーズまたは 2 フェーズのコミットインターフェイスを介してトランザクションを実行するためのスキーマを作成する方法について説明します。
+
+## 準備
+
+このガイドでは、ScalarDB サンプルリポジトリのサンプルを使用して、データベースと ScalarDB をセットアップします。
+
+### ScalarDB サンプルリポジトリのクローンを作成する
+
+**Terminal** を開き、次のコマンドを実行して ScalarDB サンプルリポジトリのクローンを作成します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples
+```
+
+次に、次のコマンドを実行して、必要なファイルが含まれているディレクトリに移動します。
+
+```console
+cd scalardb-samples/scalardb-sample
+```
+
+## データベースをセットアップする
+
+データベースを選択し、指示に従って ScalarDB 用に設定します。
+
+ScalarDB がサポートするデータベースの一覧については、[データベース](requirements.mdx#データベース)を参照してください。
+
+
+
+ MySQLをローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で MySQL を実行できます。
+
+ MySQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d mysql
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の MySQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For MySQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:mysql://localhost:3306/
+ scalar.db.username=root
+ scalar.db.password=mysql
+ ```
+
+
+ PostgreSQL をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で PostgreSQL を実行できます。
+
+ PostgreSQL を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d postgres
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の PostgreSQL のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For PostgreSQL
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:postgresql://localhost:5432/
+ scalar.db.username=postgres
+ scalar.db.password=postgres
+ ```
+
+
+ Oracle Database をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Oracle Database を実行できます。
+
+ Oracle Database を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d oracle
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Oracle データベースのプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Oracle
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:oracle:thin:@//localhost:1521/FREEPDB1
+ scalar.db.username=SYSTEM
+ scalar.db.password=Oracle
+ ```
+
+
+ SQL Server をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で SQL Server を実行できます。
+
+ SQL Server を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d sqlserver
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の SQL Server のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For SQL Server
+ scalar.db.storage=jdbc
+ scalar.db.contact_points=jdbc:sqlserver://localhost:1433;encrypt=true;trustServerCertificate=true
+ scalar.db.username=sa
+ scalar.db.password=SqlServer22
+ ```
+
+
+ Amazon DynamoDB をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Amazon DynamoDB Local を実行できます。
+
+ Amazon DynamoDB Local を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d dynamodb
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Amazon DynamoDB Local のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For DynamoDB Local
+ scalar.db.storage=dynamo
+ scalar.db.contact_points=sample
+ scalar.db.username=sample
+ scalar.db.password=sample
+ scalar.db.dynamo.endpoint_override=http://localhost:8000
+ ```
+
+
+ Azure Cosmos DB for NoSQL を使用するには、Azure アカウントが必要です。Azure アカウントをお持ちでない場合は、[Azure Cosmos DB アカウントを作成する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/quickstart-portal#create-account)にアクセスしてください。
+
+ Cosmos DB for NoSQL を設定する
+
+ [既定の整合性レベルを設定する](https://learn.microsoft.com/ja-jp/azure/cosmos-db/nosql/how-to-manage-consistency#configure-the-default-consistency-level)の公式ドキュメントに従って、**既定の整合性レベル**を**強力**に設定します。
+
+ ScalarDB を設定する
+
+ 以下の手順では、ローカル環境に JDK が適切にインストールおよび設定されており、Azure で Cosmos DB for NoSQL アカウントが適切に設定されていることを前提としています。
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。`scalar.db.contact_points` と `scalar.db.password` の値は、説明に従って必ず変更してください。
+
+ ```properties
+ # For Cosmos DB
+ scalar.db.storage=cosmos
+ scalar.db.contact_points=
+ scalar.db.password=
+ ```
+
+:::note
+
+Azure Cosmos DB アカウントのプライマリーキーまたはセカンダリキーを `scalar.db.password` の値として使用できます。
+
+:::
+
+
+ Cassandra をローカルで実行する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの `docker-compose.yml` ファイルを使用して、Docker Compose で Apache Cassandra を実行できます。
+
+ Apache Cassandra を起動するには、次のコマンドを実行します。
+
+ ```console
+ docker compose up -d cassandra
+ ```
+
+ ScalarDB を設定する
+
+ `scalardb-samples/scalardb-sample` ディレクトリの **database.properties** ファイルには、ScalarDB のデータベース設定が含まれています。**database.properties** ファイル内の Cassandra のプロパティのコメントを解除して、設定が次のようになるようにしてください。
+
+ ```properties
+ # For Cassandra
+ scalar.db.storage=cassandra
+ scalar.db.contact_points=localhost
+ scalar.db.username=cassandra
+ scalar.db.password=cassandra
+ ```
+
+
+
+ScalarDB の設定の包括的なリストについては、[ScalarDB 設定](configurations.mdx)を参照してください。
+
+## スキーマを作成またはインポートする
+
+ScalarDB には、実装固有のデータモデルとスキーマにマップされる独自のデータモデルとスキーマがあります。
+
+- **データベーススキーマを作成する必要がありますか?** [ScalarDB Schema Loader](schema-loader.mdx) を参照してください。
+- **既存のデータベースをインポートする必要がありますか?** [ScalarDB Schema Loader を使用して既存のテーブルを ScalarDB にインポートする](schema-loader-import.mdx)を参照してください。
+
+## Javaを使用してトランザクションを実行する
+
+- **1 フェーズコミットインターフェイスを使用してトランザクションを実行しますか?** [ScalarDB Java API ガイド](api-guide.mdx#transactional-api)を参照してください。
+- **2 フェーズコミットインターフェイスを使用してトランザクションを実行しますか?** [2 フェーズコミットインターフェースを使用したトランザクション](two-phase-commit-transactions.mdx)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/getting-started.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/getting-started.mdx
new file mode 100644
index 00000000..4f60b24a
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/getting-started.mdx
@@ -0,0 +1,101 @@
+---
+tags:
+ - Community
+---
+
+# ScalarDB Analytics with PostgreSQL をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このドキュメントでは、ScalarDB Analytics with PostgreSQL の使用を開始する方法について説明します。ScalarDB Analytics with PostgreSQL がすでにインストールされており、必要なサービスがすべて実行されていることを前提としています。そのような環境がない場合は、[Docker を使用してローカル環境に ScalarDB Analytics with PostgreSQL をインストールする方法](./installation.mdx)の手順に従ってください。ScalarDB Analytics with PostgreSQL は PostgreSQL 経由でクエリを実行するため、PostgreSQL にクエリを送信するための `psql` クライアントまたは別の PostgreSQL クライアントがすでにあることも前提としています。
+
+## ScalarDB Analytics with PostgreSQL とは
+
+ユニバーサルトランザクションマネージャーである ScalarDB は、主にトランザクションワークロードを対象としているため、リレーショナルクエリの限られたサブセットをサポートしています。
+
+ScalarDB Analytics with PostgreSQL は、PostgreSQL とその外部データラッパー (FDW) 拡張機能を使用して、ScalarDB の機能を拡張し、ScalarDB が管理するデータに対する分析クエリを処理します。
+
+ScalarDB Analytics with PostgreSQL は、主に PostgreSQL と Schema Importer の 2 つのコンポーネントで構成されています。
+
+PostgreSQL はサービスとして実行され、ユーザーからのクエリを受け入れて処理します。FDW 拡張機能は、ScalarDB が管理するバックエンドストレージからデータを読み取るために使用されます。Schema Importer は、ScalarDB データベースのスキーマを PostgreSQL にインポートするツールです。これにより、ユーザーは PostgreSQL 側のテーブル (ScalarDB 側のテーブルと同一) を表示できます。
+
+## ScalarDB データベースをセットアップする
+
+まず、ScalarDB Analytics with PostgreSQL で分析クエリを実行するには、1 つ以上の ScalarDB データベースが必要です。独自の ScalarDB データベースがある場合は、このセクションをスキップして、代わりにそのデータベースを使用できます。[scalardb-samples/scalardb-analytics-postgresql-sample](https://github.com/scalar-labs/scalardb-samples/tree/main/scalardb-analytics-postgresql-sample) プロジェクトを使用する場合は、プロジェクトディレクトリで次のコマンドを実行してサンプルデータベースを設定できます。
+
+```console
+docker compose run --rm schema-loader \
+ -c /etc/scalardb.properties \
+ --schema-file /etc/schema.json \
+ --coordinator \
+ --no-backup \
+ --no-scaling
+```
+
+このコマンドは、DynamoDB、PostgreSQL、Cassandra で設定される [複数のストレージインスタンス](../multi-storage-transactions.mdx)を設定します。次に、これらのストレージにマップされる `dynamons`、`postgresns`、`cassandrans` の名前空間を作成し、[ScalarDB Schema Loader](https://scalardb.scalar-labs.com/docs/latest/schema-loader/)を使用して `dynamons.customer`、`postgresns.orders`、`cassandrans.lineitem` のテーブルを作成します。
+
+
+
+次のコマンドを実行すると、作成されたテーブルにサンプルデータをロードできます。
+
+```console
+docker compose run --rm sample-data-loader
+```
+
+## PostgreSQL に ScalarDB 管理下のデータベースのスキーマをインポートする
+
+次に、分析クエリを処理する PostgreSQL に ScalarDB 管理下のデータベースのスキーマをインポートします。ScalarDB Analytics with PostgreSQL には、この目的のためのツールである Schema Importer が用意されています。このツールを使用すると、分析クエリを実行するために必要なすべての準備が整います。
+
+```console
+docker compose run --rm schema-importer \
+ import \
+ --config /etc/scalardb.properties \
+ --host analytics \
+ --port 5432 \
+ --database test \
+ --user postgres \
+ --password postgres \
+ --namespace cassandrans \
+ --namespace postgresns \
+ --namespace dynamons \
+ --config-on-postgres-host /etc/scalardb.properties
+```
+
+独自の ScalarDB データベースを使用する場合は、`--config` および `--config-on-postgres-host` オプションを ScalarDB 設定ファイルに置き換え、`--namespace` オプションをインポートする ScalarDB 名前空間に置き換える必要があります。
+
+これにより、ScalarDB データベース内のテーブルと同じ名前のテーブル (正確にはビュー) が作成されます。この例では、`dynamons.customer`、`postgresns.orders`、および `cassandrans.lineitem` のテーブルが作成されます。列定義も ScalarDB データベースと同一です。これらのテーブルは、FDW を使用して ScalarDB データベースの基盤となるストレージに接続された [外部テーブル](https://www.postgresql.org/docs/current/sql-createforeigntable.html)です。したがって、PostgreSQL 内のこれらのテーブルを ScalarDB データベース内のテーブルと同等と見なすことができます。
+
+
+
+## 分析クエリを実行する
+
+これで、ScalarDB データベース内の同じデータを読み取るすべてのテーブルが揃い、PostgreSQL でサポートされている任意の分析クエリを実行できるようになりました。クエリを実行するには、`psql` またはその他のクライアントを使用して PostgreSQL に接続してください。
+
+```console
+psql -U postgres -h localhost test
+Password for user postgres:
+
+> select c_mktsegment, count(*) from dynamons.customer group by c_mktsegment;
+ c_mktsegment | count
+--------------+-------
+ AUTOMOBILE | 4
+ BUILDING | 2
+ FURNITURE | 1
+ HOUSEHOLD | 2
+ MACHINERY | 1
+(5 rows)
+```
+
+サンプルデータと追加の実作業の詳細については、サンプルアプリケーションページを参照してください。
+
+## 注意事項
+
+### 分離レベル
+
+ScalarDB Analytics with PostgreSQL は、**Read Committed** 分離レベルを設定してデータを読み取ります。この分離レベルにより、読み取るデータが過去にコミットされていることが保証されますが、特定の時点で一貫性のあるデータを読み取ることができることは保証されません。
+
+### 書き込み操作はサポートされていません
+
+ScalarDB Analytics with PostgreSQL は、読み取り専用クエリのみをサポートします。`INSERT`、`UPDATE`、およびその他の書き込み操作はサポートされていません。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/imported-schema.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/imported-schema.png
new file mode 100644
index 00000000..1cf8fea3
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/imported-schema.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/multi-storage-overview.png b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/multi-storage-overview.png
new file mode 100644
index 00000000..fc8df1cb
Binary files /dev/null and b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/images/multi-storage-overview.png differ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/installation.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/installation.mdx
new file mode 100644
index 00000000..b1e66411
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/installation.mdx
@@ -0,0 +1,64 @@
+---
+tags:
+ - Community
+---
+
+# Docker を使用してローカル環境に ScalarDB Analytics with PostgreSQL をインストールする方法
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このドキュメントでは、[Docker Compose](https://docs.docker.com/compose/) を使用して、Cassandra、PostgreSQL、および DynamoDB ローカルサーバーのマルチストレージバックエンドを使用して、ScalarDB Analytics with PostgreSQL を実行するローカル環境を設定する方法について説明します。
+
+## 前提条件
+
+- [Docker Engine](https://docs.docker.com/engine/) および [Docker Compose](https://docs.docker.com/compose/)。
+
+プラットフォームに応じて、Docker ウェブサイトの手順に従ってください。
+
+## ステップ 1. `scalardb-samples` リポジトリを複製します
+
+[scalardb-samples/scalardb-analytics-postgresql-sample](https://github.com/scalar-labs/scalardb-samples/tree/main/scalardb-analytics-postgresql-sample) リポジトリは、ScalarDB Analytics with PostgreSQL を設定するためのサンプル設定を含むプロジェクトです。
+
+scalardb-analytics-postgresql-sample アプリを実行するローカルマシン上の場所を決定します。次に、ターミナルを開き、`cd` コマンドを使用してその場所に移動し、次のコマンドを実行します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples.git
+cd scalardb-samples/scalardb-analytics-postgresql-sample
+```
+
+## ステップ 2. ScalarDB Analytics with PostgreSQL サービスを起動する
+
+次のコマンドは、ScalarDB Analytics with PostgreSQL を提供する PostgreSQL インスタンスと、Docker コンテナ内の Cassandra、PostgreSQL、および DynamoDB ローカルのバックエンドサーバーを起動します。このコマンドを初めて実行すると、必要な Docker イメージが GitHub Container Registry からダウンロードされます。
+
+```console
+docker-compose up
+```
+
+コンテナをバックグラウンドで実行する場合は、`-d` (--detach) オプションを追加します。
+
+```console
+docker-compose up -d
+```
+
+すでに独自の ScalarDB データベースがあり、それをバックエンドサービスとして使用したい場合は、コンテナー内で追加のバックエンドサーバーを起動せずに、PostgreSQL インスタンスのみを起動できます。
+
+```console
+docker-compose up analytics
+```
+
+## ステップ 3. 分析クエリを実行する
+
+これで、必要なサービスがすべて実行されているはずです。分析クエリを実行するには、[ScalarDB Analytics with PostgreSQL の開始方法](./getting-started.mdx)を参照してください。
+
+## ステップ 4. ScalarDB Analytics with PostgreSQL サービスをシャットダウンする
+
+コンテナをシャットダウンするには、方法に応じて、ターミナルで次のいずれかを実行します。
+
+- フォアグラウンドでコンテナを起動した場合は、`docker-compose` が実行されている場所で Ctrl+C を押します。
+- バックグラウンドでコンテナを起動した場合は、次のコマンドを実行します。
+
+```console
+docker-compose down
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/scalardb-fdw.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/scalardb-fdw.mdx
new file mode 100644
index 00000000..38345761
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/scalardb-fdw.mdx
@@ -0,0 +1,183 @@
+---
+tags:
+ - Community
+---
+
+# ScalarDB FDW
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB FDW は、[ScalarDB](https://www.scalar-labs.com/scalardb/) の外部データラッパー (FDW) を実装する PostgreSQL 拡張機能です。
+
+ScalarDB FDW は、Java Native Interface を使用して、FDW 内のライブラリとして ScalarDB を直接利用し、ScalarDB のスキャン操作を介して外部データベースからデータを読み取ります。
+
+## 前提条件
+
+環境に次の前提条件が設定されている必要があります。
+
+### JDK
+
+ScalarDB と互換性のあるバージョンの Java Development Kit (JDK) をインストールする必要があります。さらに、JDK インストールディレクトリを指す `JAVA_HOME` 環境変数を設定する必要があります。
+
+これらの拡張機能は内部で Java Native Interface (JNI) を使用するため、ライブラリ検索パスに `libjvm.so` などの Java 仮想マシン (JVM) の動的ライブラリを含める必要があることに注意してください。
+
+### PostgreSQL
+
+この拡張機能は PostgreSQL 13 以降をサポートしています。PostgreSQL のインストール方法の詳細については、[サーバー管理](https://www.postgresql.org/docs/current/admin.html)の公式ドキュメントを参照してください。
+
+## ビルドとインストール
+
+以下のコマンドを実行すると、この拡張機能をビルドしてインストールできます。
+
+```console
+make install
+```
+
+### 一般的なビルドエラー
+
+このセクションでは、発生する可能性のある一般的なビルドエラーについて説明します。
+
+#### ld: -ljvm のライブラリが見つかりません
+
+通常、ビルドスクリプトは `libjvm.so` のパスを見つけ、それをライブラリ検索パスとして適切に設定しています。ただし、`ld: library not found for -ljvm` というエラーが発生した場合は、`libjvm.so` ファイルをデフォルトのライブラリ検索パスにコピーしてください。例:
+
+```console
+ln -s //libjvm.so /usr/lib64/libjvm.so
+```
+
+## 使用方法
+
+このセクションでは、ScalarDB の FDW の使用例と利用可能なオプションについて説明します。
+
+### 例
+
+次の例では、必要なコンポーネントをインストールして作成し、FDW 拡張機能を使用してクエリを実行する方法を示します。
+
+#### 1. 拡張機能をインストールする
+
+拡張機能のインストール方法の詳細については、[ビルドとインストール](#ビルドとインストール)セクションを参照してください。
+
+#### 2. 拡張機能を作成する
+
+拡張機能を作成するには、次のコマンドを実行します。
+
+```sql
+CREATE EXTENSION scalardb_fdw;
+```
+
+#### 3. 外部サーバーを作成する
+
+外部サーバーを作成するには、次のコマンドを実行します。
+
+```sql
+CREATE SERVER scalardb FOREIGN DATA WRAPPER scalardb_fdw OPTIONS (
+ config_file_path '/path/to/scalardb.properties'
+);
+```
+
+#### 4. ユーザーマッピングを作成する
+
+ユーザーマッピングを作成するには、次のコマンドを実行します。
+
+```sql
+CREATE USER MAPPING FOR PUBLIC SERVER scalardb;
+```
+
+#### 5. 外部テーブルを作成する
+
+外部テーブルを作成するには、次のコマンドを実行します。
+
+```sql
+CREATE FOREIGN TABLE sample_table (
+ pk int,
+ ck1 int,
+ ck2 int,
+ boolean_col boolean,
+ bigint_col bigint,
+ float_col double precision,
+ double_col double precision,
+ text_col text,
+ blob_col bytea
+) SERVER scalardb OPTIONS (
+ namespace 'ns',
+ table_name 'sample_table'
+);
+```
+
+#### 6. クエリを実行する
+
+クエリを実行するには、次のコマンドを実行します。
+
+```sql
+select * from sample_table;
+```
+
+### 使用可能なオプション
+
+ScalarDB FDW オブジェクトには次のオプションを設定できます。
+
+#### `CREATE SERVER`
+
+ScalarDB 外部サーバーオブジェクトには次のオプションを設定できます。
+
+| 名前 | 必須 | タイプ | 説明 |
+| ------------------ | ------- | -------- | ------------------------------------------- |
+| `config_file_path` | **はい** | `string` | ScalarDB 設定ファイルへのパス。 |
+| `max_heap_size` | いいえ | `string` | JVM の最大ヒープサイズ。形式は `-Xmx` と同じです。 |
+
+#### `CREATE USER MAPPING`
+
+現在、`CREATE USER MAPPING` のオプションはありません。
+
+#### `CREATE FOREIGN SERVER`
+
+ScalarDB 外部テーブルオブジェクトには次のオプションを設定できます。
+
+| 名前 | 必須 | タイプ | 説明 |
+| ------------ | ------- | -------- | -------------------------------------------- |
+| `namespace` | **はい** | `string` | ScalarDB インスタンス内のテーブルの名前空間の名前。 |
+| `table_name` | **はい** | `string` | ScalarDB インスタンス内のテーブルの名前。 |
+
+### データ型のマッピング
+
+| ScalarDB | PostgreSQL |
+| -------- | ---------------- |
+| BOOLEAN | boolean |
+| INT | int |
+| BIGINT | bigint |
+| FLOAT | float |
+| DOUBLE | double precision |
+| TEXT | text |
+| BLOB | bytea |
+
+## テスト
+
+このセクションでは、ScalarDB の FDW をテストする方法について説明します。
+
+### テスト用の ScalarDB インスタンスの設定
+
+ScalarDB の FDW をテストする前に、テストデータを含む実行中の ScalarDB インスタンスが必要です。次のコマンドを実行して、インスタンスを設定し、テストデータをロードできます。
+
+```console
+./test/setup.sh
+```
+
+インスタンスをリセットする場合は、次のコマンドを実行してから、上記のセットアップコマンドを再度実行します。
+
+```console
+./test/cleanup.sh
+```
+
+### 回帰テストを実行する
+
+FDW 拡張機能をインストールした後、次のコマンドを実行すると、回帰テストを実行できます。
+
+```console
+make installcheck
+```
+
+## 制限事項
+
+- この拡張機能は、ScalarDB 管理データベースでの分析クエリ処理を可能にすることを目的としています。したがって、この拡張機能は ScalarDB からのデータの読み取りのみをサポートします。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/schema-importer.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/schema-importer.mdx
new file mode 100644
index 00000000..c724d4c6
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-postgresql/schema-importer.mdx
@@ -0,0 +1,68 @@
+---
+tags:
+ - Community
+---
+
+# Schema Importer
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+Schema Importer は、PostgreSQL を自動的に設定するための CLI ツールです。このツールを使用すると、PostgreSQL データベースに、ScalarDB インスタンスと同じデータベースオブジェクト (名前空間やテーブルなど) を持たせることができます。
+
+Schema Importer は、ScalarDB 設定ファイルを読み取り、ScalarDB で定義されているテーブルのスキーマを取得し、対応する外部データラッパーの外部テーブルとビューをこの順序で作成します。詳細については、[PostgreSQL での ScalarDB 分析の開始](getting-started.mdx)を参照してください。
+
+## Schema Importer のビルド
+
+[Gradle](https://gradle.org/) を使用して Schema Importer をビルドできます。Schema Importer をビルドするには、次のコマンドを実行します。
+
+```console
+./gradlew build
+```
+
+`java -jar` を使用して Schema Importer を起動できるように、Fat JAR ファイルを作成する必要があります。Fat JAR を作成するには、次のコマンドを実行します。
+
+ ```console
+ ./gradlew shadowJar
+ ```
+
+fat JAR をビルドすると、`app/build/libs/` ディレクトリに fat JAR ファイルが作成されます。
+
+## Schema Importer を実行する
+
+fat JAR ファイルを使用して Schema Importer を実行するには、次のコマンドを実行します。
+
+```console
+java -jar
+```
+利用可能なオプションは次のとおりです。
+
+| 名前 | 必須 | 説明 | デフォルト |
+| --------------------------- | -------- | ----------------------------------------------------------------------------------------------------- | ------------------------------- |
+| `--config` | **はい** | ScalarDB 設定ファイルへのパス | |
+| `--config-on-postgres-host` | No | PostgreSQL を実行しているホスト上の ScalarDB 設定ファイルへのパス | `--config` と同じ値が使用されます。 |
+| `--namespace`, `-n` | **はい** | 分析インスタンスにインポートする名前空間。2 つ以上の名前空間がある場合は、`--namespace` オプションを複数回指定できます。 | |
+| `--host` | いいえ | PostgreSQL ホスト | localhost |
+| `--port` | いいえ | PostgreSQL ポート | 5432 |
+| `--database` | いいえ | PostgreSQL ポート | postgres |
+| `--user` | いいえ | PostgreSQL ユーザー | postgres |
+| `--password` | いいえ | PostgreSQL パスワード | |
+| `--debug` | いいえ | デバッグモードを有効にする | |
+
+
+## Schema Importer のテスト
+
+Schema Importer をテストするには、次のコマンドを実行します。
+
+```console
+./gradlew test
+```
+
+## Schema Importer の Docker イメージをビルドする
+
+Schema Importer の Docker イメージをビルドするには、次のコマンドを実行します。`` は、使用する Schema Importer のタグバージョンに置き換えます。
+
+```console
+docker build -t ghcr.io/scalar-labs/scalardb-analytics-postgresql-schema-importer: -f ./app/Dockerfile .
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/README.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/README.mdx
new file mode 100644
index 00000000..81c7417e
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/README.mdx
@@ -0,0 +1,36 @@
+---
+tags:
+ - Enterprise Option
+ - Private Preview
+---
+
+# ScalarDB Analytics with Spark
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+:::warning
+
+このバージョンの ScalarDB Analytics with Spark はプライベートプレビューでした。代わりにバージョン 3.14 以降を使用してください。
+
+:::
+
+ScalarDB は、ユニバーサルトランザクションマネージャーとして、主にトランザクションワークロードを対象としているため、リレーショナルクエリの限定されたサブセットをサポートしています。
+
+ScalarDB Analytics with Spark は、Apache Spark と Spark SQL を使用して、ScalarDB が管理するデータに対する分析クエリを処理するために ScalarDB の機能を拡張します。
+
+ScalarDB Analytics with Spark は Spark カタログプラグインとして提供されるため、外部で管理されるデータソースをそのデータスキーマで読み取ることができます。このプラグインを使用すると、ScalarDB テーブルから同じスキーマを持つ Spark SQL テーブルとしてデータを読み取ることができます。
+
+:::warning
+
+ScalarDB Analytics with Spark を使用するには、商用ライセンスが必要です。商用ライセンスが必要な場合は、[お問い合わせ](https://scalar-labs.com/contact_us/)ください。
+
+:::
+
+## 参考資料
+
+* ScalarDB Analytics with Spark を使用してアドホック分析クエリまたは開発アプリケーションを実行するには、[ScalarDB Analytics with Spark の使用開始](getting-started.mdx)を参照してください。
+* サンプルデータセットとアプリケーションを使用して ScalarDB Analytics with Spark を使用する方法に関するチュートリアルについては、[ScalarDB Analytics with Spark を使用してサンプルデータで分析クエリを実行する](../scalardb-samples/scalardb-analytics-spark-sample/README.mdx)を参照してください。
+* ScalarDB Analytics with Spark を設定する方法の詳細については、[ScalarDB Analytics with Spark の設定](configuration.mdx)を参照してください。
+* サポートされている Spark および Scala のバージョンについては、[ScalarDB Analytics with Spark のバージョン互換性](version-compatibility.mdx)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/configuration.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/configuration.mdx
new file mode 100644
index 00000000..7a0fc439
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/configuration.mdx
@@ -0,0 +1,135 @@
+---
+tags:
+ - Enterprise Option
+ - Private Preview
+---
+
+# ScalarDB Analytics with Spark の設定
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+:::warning
+
+このバージョンの ScalarDB Analytics with Spark はプライベートプレビューでした。代わりにバージョン 3.14 以降を使用してください。
+
+:::
+
+ScalarDB Analytics with Spark を設定する方法は 2 つあります:
+
+- `spark.conf` でプロパティを設定する
+- ScalarDB Analytics with Spark が提供するヘルパーメソッドを使用する
+
+どちらの方法も概念的には同等のプロセスなので、好みに応じてどちらかを選択できます。
+
+## `spark.conf` を使用して ScalarDB Analytics with Spark を設定する
+
+ScalarDB Analytics with Spark は Spark カスタムカタログプラグインとして提供されるため、`spark.conf` を介して ScalarDB Analytics with Spark を有効にできます。
+
+```properties
+spark.sql.catalog.scalardb_catalog = com.scalar.db.analytics.spark.datasource.ScalarDbCatalog
+spark.sql.catalog.scalardb_catalog.config = //config.properties
+spark.sql.catalog.scalardb_catalog.namespaces = ,
+spark.sql.catalog.scalardb_catalog.license.key = {"your":"license", "key":"in", "json":"format"}
+spark.sql.catalog.scalardb_catalog.license.cert_path = //cert.pem
+```
+
+:::note
+
+`scalardb_catalog` 部分は設定可能なカタログ名です。任意の名前を選択できます。
+
+:::
+
+### 使用可能なプロパティ
+
+ScalarDB Analytics with Spark で使用可能なプロパティのリストは次のとおりです。
+
+| プロパティ名 | 必須 | 説明 |
+|------------------------------------------------------|---------------------------------------------|-----------------------------------------------------------------------------|
+| `spark.sql.catalog.{catalog_name}` | はい | `com.scalar.db.analytics.spark.datasource.ScalarDbCatalog` である必要があります |
+| `spark.sql.catalog.{catalog_name}.config` | はい | ScalarDB 設定ファイルへのパス |
+| `spark.sql.catalog.{catalog_name}.namespaces` | はい | Spark 側にインポートする ScalarDB 名前空間のコンマ区切りリスト |
+| `spark.sql.catalog.{catalog_name}.license.key` | はい | JSON形式のライセンスキー |
+| `spark.sql.catalog.{catalog_name}.license.cert_path` | これか `license.cert_pem` のいずれかが必要です | ライセンス証明書ファイルへのパス |
+| `spark.sql.catalog.{catalog_name}.license.cert_pem` | これか `license.cert_path` のいずれかが必要です | PEM形式のライセンス証明書 |
+
+### スキーマのインポート
+
+`spark.conf` を適切に設定すると、ScalarDB の基盤となるデータベースに接続されたテーブルを含むカタログが Spark 環境に作成されます。ただし、カタログは、ScalarDB によって管理されるトランザクションメタデータを含む生のテーブルへのアクセスを提供します。代わりに、トランザクションメタデータのないアプリケーション管理データのみに関心がある場合があります。
+
+この目的のために、ScalarDB Analytics with Spark は、トランザクションメタデータを解釈し、アプリケーション管理データのみを表示するビューを作成する `SchemaImporter` クラスを提供します。これらのビューには ScalarDB テーブルと同等のスキーマがあり、ユーザーはビューを ScalarDB テーブルのように使用できます。以下は、適切に設定されたカタログで `SchemaImporter` を実行する方法の例です。
+
+```java
+import com.scalar.db.analytics.spark.view.SchemaImporter
+
+class YourApp {
+ public static void main(String[] args) {
+ SparkSession spark = SparkSession.builder().appName("").getOrCreate()
+ new SchemaImporter(spark, "scalardb_catalog").run() // Import ScalarDB table schemas from the catalog named "scalardb_catalog"
+ spark.sql("select * from .").show()
+ spark.stop()
+ }
+}
+```
+
+## ヘルパーメソッドを使用して ScalarDB Analytics with Spark を設定する
+
+ScalarDB Analytics with Spark が提供するヘルパーメソッドを使用すると、カタログの設定やスキーマのインポートなど、分析クエリを実行するためのすべての設定を行うことができます。さらに、ヘルパーメソッドを使用して、アプリケーションコードで ScalarDB Analytics with Spark を設定することもできます。これは、事前の設定なしで簡単なテストを実行する場合に便利です。
+
+ヘルパーメソッドは、Java および Scala を通じて提供されます。Java では、`ScalarDbAnalyticsInitializer` を使用して、`spark.conf` のプロパティに相当するオプションを次のように指定できます。
+
+```java
+import com.scalar.db.analytics.spark.ScalarDbAnalyticsInitializer
+
+class YourApp {
+ public static void main(String[] args) {
+ // Initialize SparkSession as usual
+ SparkSession spark = SparkSession.builder().appName("").getOrCreate()
+ // Setup ScalarDB Analytics with Spark via helper class
+ ScalarDbAnalyticsInitializer
+ .builder()
+ .spark(spark)
+ .configPath("//config.properties")
+ .namespace("")
+ .namespace("")
+ .licenseKey("{\"your\":\"license\", \"key\":\"in\", \"json\":\"format\"}")
+ .licenseCertPath("//cert.pem")
+ .build()
+ .run()
+ // Run arbitrary queries
+ spark.sql("select * from .").show()
+ // Stop SparkSession
+ spark.stop()
+ }
+}
+```
+
+Scala では、`setupScalarDbAnalytics` メソッドは `SparkSession` の拡張として利用できます。
+
+```scala
+import com.scalar.db.analytics.spark.implicits._
+
+object YourApp {
+ def main(args: Array[String]): Unit = {
+ // Initialize SparkSession as usual
+ val spark = SparkSession.builder.appName("").getOrCreate()
+ // Setup ScalarDB Analytics with Spark via helper method
+ spark.setupScalarDbAnalytics(
+ // ScalarDB config file
+ configPath = "//config.properties",
+ // Namespaces in ScalarDB to import
+ namespaces = Set("", ""),
+ // License information
+ license = License.certPath("""{"your":"license", "key":"in", "json":"format"}""", "//cert.pem")
+ )
+ // Run arbitrary queries
+ spark.sql("select * from .").show()
+ // Stop SparkSession
+ spark.stop()
+ }
+}
+```
+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/getting-started.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/getting-started.mdx
new file mode 100644
index 00000000..6ed5bb3e
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/getting-started.mdx
@@ -0,0 +1,189 @@
+---
+tags:
+ - Enterprise Option
+ - Private Preview
+---
+
+# ScalarDB Analytics with Spark をはじめよう
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+:::warning
+
+このバージョンの ScalarDB Analytics with Spark はプライベートプレビューでした。代わりにバージョン 3.14 以降を使用してください。
+
+:::
+
+このガイドでは、ScalarDB Analytics with Spark の使用を開始する方法について説明します。
+
+## 前提条件
+
+ScalarDB Analytics with Spark を使用してクエリを実行する前に、ScalarDB テーブルを設定し、Apache Spark をインストールする必要があります。
+
+### ScalarDB テーブルの設定
+
+ScalarDB Analytics with Spark を使用するには、分析クエリを実行するための ScalarDB の基盤となるデータベースが少なくとも 1 つ必要です。ScalarDB に独自の基盤となるデータベースを設定している場合は、このセクションをスキップして、代わりにそのデータベースを使用できます。
+
+独自のデータベースをまだ設定していない場合は、[ScalarDB Analytics with Spark を使用してサンプルデータに対して分析クエリを実行する](../scalardb-samples/scalardb-analytics-spark-sample/README.mdx)の手順に従って、サンプルの基盤となるデータベースを使用して ScalarDB を設定できます。
+
+### Apache Spark のインストール
+
+Apache Spark のパッケージリリースも必要です。すでに Spark がインストールされている場合は、このセクションをスキップできます。
+
+Spark が必要な場合は、[Spark ウェブサイト](https://spark.apache.org/downloads.html)からダウンロードできます。圧縮された Spark ファイルをダウンロードしたら、次のコマンドを実行してファイルを解凍する必要があります。`X.X.X` は、ダウンロードした Spark のバージョンに置き換えてください。
+
+```console
+tar xf spark-X.X.X-bin-hadoop3.tgz
+```
+
+次に、次のコマンドを実行してディレクトリに入ります。ここでも、`X.X.X` はダウンロードした Spark のバージョンに置き換えます。
+
+```console
+cd spark-X.X.X-bin-hadoop3
+```
+
+## Spark シェルを設定する
+
+以下では、Spark シェルを使用してインタラクティブな分析を実行する方法について説明します。
+
+ScalarDB Analytics with Spark は Maven Central Repository で利用できるため、`--packages` オプションを使用して Spark シェルで ScalarDB Analytics with Spark を有効にすることができます。`_:` は、使用しているバージョンに置き換えてください。
+
+```console
+./bin/spark-shell --packages com.scalar-labs:scalardb-analytics-spark-_:
+```
+
+:::warning
+
+ScalarDB Analytics with Spark は、さまざまな Spark および Scala バージョン用のさまざまなアーティファクトを提供します。これは、`scalardb-analytics-spark-_` の形式で提供されます。使用している Spark および Scala バージョンに一致するアーティファクトを選択してください。
+
+参考として、[ScalarDB Analytics with Spark のバージョン互換性](version-compatibility.mdx)を参照してください。
+
+:::
+
+次に、シェルで ScalarDB Analytics with Spark 環境を設定する必要があります。ScalarDB Analytics with Spark には、分析クエリを実行するためのすべての設定を行うヘルパーメソッドが用意されています。
+
+```scala
+spark-shell> import com.scalar.db.analytics.spark.implicits._
+spark-shell> spark.setupScalarDbAnalytics(
+ | // ScalarDB config file
+ | configPath = "//config.properties",
+ | // Namespaces in ScalarDB to import
+ | namespaces = Set("", ""),
+ | // License information
+ | license = License.certPath("""{"your":"license", "key":"in", "json":"format"}""", "//cert.pem")
+ | )
+```
+
+これで、ScalarDB の基盤となるデータベースのテーブルからデータを読み取り、Spark Dataset API を通じて任意の分析クエリを実行できるようになりました。例:
+
+```console
+spark-shell> spark.sql("select * from .").show()
+```
+
+## Spark アプリケーションを実装して起動する
+
+このセクションでは、ScalarDB Analytics with Spark を使用して Spark アプリケーションを実装し、当該アプリケーションを起動する方法について説明します。
+
+SBT、Gradle、Maven などのビルドツールを使用して、ScalarDB Analytics with Spark をアプリケーションに統合できます。
+
+
+
+ Gradle プロジェクトの場合は、`build.gradle.kts` ファイルに以下を追加し、`_:` を使用しているバージョンに置き換えます。
+
+ ```kotlin
+ implementation("com.scalar-labs:scalardb-analytics-spark-_:")
+ ```
+
+
+ Groovy を使用して Gradle を設定するには、`build.gradle` ファイルに以下を追加し、`_:` を、使用しているバージョンに置き換えます。
+
+ ```groovy
+ implementation 'com.scalar-labs:scalardb-analytics-spark-_:'
+ ```
+
+
+ アプリケーションを SBT プロジェクトに追加するには、`build.sbt` ファイルに次のコードを挿入し、`` と `` を使用しているバージョンに置き換えます。
+
+ ```scala
+ libraryDependencies += "com.scalar-labs" %% "scalardb-analytics-spark-" % ""
+ ```
+
+
+
+ScalarDB Analytics with Spark をアプリケーションに統合した後、上記で説明したのと同じヘルパーメソッドを使用して、Spark アプリケーションで ScalarDB Analytics with Spark を設定できます。
+
+
+
+ 以下は Scala を使用するサンプルアプリケーションです。
+
+ ```scala
+ import com.scalar.db.analytics.spark.implicits._
+
+ object YourApp {
+ def main(args: Array[String]): Unit = {
+ // Initialize SparkSession as usual
+ val spark = SparkSession.builder.appName("").getOrCreate()
+ // Setup ScalarDB Analytics with Spark via helper method
+ spark.setupScalarDbAnalytics(
+ // ScalarDB config file
+ configPath = "//config.properties",
+ // Namespaces in ScalarDB to import
+ namespaces = Set("", ""),
+ // License information
+ license = License.certPath("""{"your":"license", "key":"in", "json":"format"}""", "//cert.pem")
+ )
+ // Run arbitrary queries
+ spark.sql("select * from .").show()
+ // Stop SparkSession
+ spark.stop()
+ }
+ }
+ ```
+
+
+ Java で ScalarDB Analytics with Spark を使用した Spark アプリケーションを作成できます。
+
+ ```java
+ import com.scalar.db.analytics.spark.ScalarDbAnalyticsInitializer
+
+ class YourApp {
+ public static void main(String[] args) {
+ // Initialize SparkSession as usual
+ SparkSession spark = SparkSession.builder().appName("").getOrCreate()
+ // Setup ScalarDB Analytics with Spark via helper class
+ ScalarDbAnalyticsInitializer
+ .builder()
+ .spark(spark)
+ .configPath("//config.properties")
+ .namespace("")
+ .namespace("")
+ .licenseKey("{\"your\":\"license\", \"key\":\"in\", \"json\":\"format\"}")
+ .licenseCertPath("//cert.pem")
+ .build()
+ .run()
+ // Run arbitrary queries
+ spark.sql("select * from .").show()
+ // Stop SparkSession
+ spark.stop()
+ }
+ }
+ ```
+
+
+
+次に、`sbt package` や `./gradlew assemble` などの好みのビルドツールを使用して .jar ファイルを作成する必要があります。
+
+.jar ファイルを作成したら、`spark-submit` を使用してその .jar ファイルを Spark クラスターに送信できます。`--packages` オプションを使用して、次のコマンドを実行し、クラスターで ScalarDB Analytics ライブラリを有効にします。`_:` は、使用しているバージョンに置き換えてください。
+
+```console
+./bin/spark-submit \
+ --class "YourApp" \
+ --packages com.scalar-labs:scalardb-analytics-spark-_: \
+ .jar
+```
+
+一般的な Spark アプリケーション開発の詳細については、[Apache Spark ドキュメント](https://spark.apache.org/docs/latest/)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/version-compatibility.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/version-compatibility.mdx
new file mode 100644
index 00000000..c8c8238b
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-analytics-spark/version-compatibility.mdx
@@ -0,0 +1,27 @@
+---
+tags:
+ - Enterprise Option
+ - Private Preview
+---
+
+# ScalarDB Analytics with Spark のバージョン互換性
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+:::warning
+
+このバージョンの ScalarDB Analytics with Spark はプライベートプレビューでした。代わりにバージョン 3.14 以降を使用してください。
+
+:::
+
+Spark と Scala はマイナーバージョン間で互換性がない場合があるため、ScalarDB Analytics with Spark では、さまざまな Spark および Scala バージョンに対して、`scalardb-analytics-spark-_` という形式で名前が付けられたさまざまなアーティファクトを提供しています。使用している Spark および Scala のバージョンに一致するアーティファクトを選択してください。たとえば、Scala 2.13 で Spark 3.5 を使用している場合は、`scalardb-analytics-spark-3.5_2.13` を指定する必要があります。
+
+Java バージョンに関しては、ScalarDB Analytics with Spark は Java 8 以降をサポートしています。
+
+以下は、ScalarDB Analytics with Spark の各バージョンでサポートされている Spark および Scalar バージョンのリストです。
+
+| ScalarDB Analytics with Spark バージョン | ScalarDB バージョン | サポートされている Spark バージョン | サポートされている Scala バージョン | 最小 Java バージョン |
+|:---------------------------------------|:------------------|:-------------------------------|:-------------------------------|:-------------------|
+| 3.12 | 3.12 | 3.5, 3.4 | 2.13, 2.12 | 8 |
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-benchmarks/README.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-benchmarks/README.mdx
new file mode 100644
index 00000000..08cc7c8e
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-benchmarks/README.mdx
@@ -0,0 +1,216 @@
+---
+tags:
+ - Community
+---
+
+# ScalarDB ベンチマークツール
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このチュートリアルでは、ScalarDB のベンチマークツールを実行する方法について説明します。データベースベンチマークは、一連の標準データセットワークロードに対するデータベースのパフォーマンスを評価するのに役立ちます。
+
+## ベンチマークのワークロード
+
+- TPC-C
+- YCSB (ワークロード A、C、および F)
+- マルチストレージ YCSB (ワークロード C および F)
+ - この YCSB バリアントは、ScalarDB を使用するマルチストレージ環境用です。
+ - マルチストレージ YCSB のワーカーは、2 つの名前空間 (`ycsb_primary` と `ycsb_secondary`) で同じ数の読み取り操作と書き込み操作を実行します。
+
+## 前提条件
+
+- 次の Java 開発キット (JDK) のいずれか:
+ - [Oracle JDK](https://www.oracle.com/java/technologies/downloads/) LTS バージョン 8
+ - [OpenJDK](https://openjdk.org/install/) LTS バージョン 8
+- Gradle
+- [Kelpie](https://github.com/scalar-labs/kelpie)
+ - Kelpie は、システムのベンチマークや検証などのエンドツーエンドのテストを実行するためのフレームワークです。 [Kelpie Releases](https://github.com/scalar-labs/kelpie) から最新バージョンを入手し、アーカイブファイルを解凍します。
+- ベンチマークツールを実行するクライアント
+- ターゲットデータベース
+ - ScalarDB がサポートするデータベースの一覧については、[Supported Databases](../scalardb-supported-databases.mdx) を参照してください。
+
+:::note
+
+現在、ベンチマークツールを実行するときに使用できるのは JDK 8 のみです。
+
+:::
+
+## ベンチマークツールをセットアップする
+
+次のセクションでは、ベンチマークツールのセットアップ方法について説明します。
+
+### ScalarDB ベンチマークリポジトリをクローンする
+
+**ターミナル**を開き、次のコマンドを実行して ScalarDB ベンチマークリポジトリのクローンを作成します。
+
+```console
+git clone https://github.com/scalar-labs/scalardb-benchmarks
+```
+
+次に、下記のコマンドを実行して、ベンチマークファイルが含まれるディレクトリに移動します。
+
+```console
+cd scalardb-benchmarks
+```
+
+### ツールをビルドする
+
+ベンチマークツールをビルドするには、次のコマンドを実行します。
+
+```console
+./gradlew shadowJar
+```
+
+### スキーマをロードする
+
+初期データをロードする前に、[ScalarDB Schema Loader](../schema-loader.mdx) を使用してテーブルを定義する必要があります。スキーマを適用するには、[ScalarDB Releases](https://github.com/scalar-labs/scalardb/releases) ページに移動し、使用している ScalarDB のバージョンに一致する ScalarDB Schema Loader を `scalardb-benchmarks` ルートフォルダーにダウンロードします。
+
+さらに、ScalarDB のデータベース設定を含むプロパティファイルが必要です。ScalarDB プロパティファイルの設定の詳細については、[ScalarDB 設定](../configurations.mdx)を参照してください。
+
+スキーマを適用してプロパティファイルを設定したら、ベンチマークを選択し、指示に従ってテーブルを作成します。
+
+
+
+ TPC-C ベンチマーク用のテーブル ([`tpcc-schema.json`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/tpcc-schema.json)) を作成するには、山括弧内の内容を説明に従って置き換えて、次のコマンドを実行します。
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config -f tpcc-schema.json --coordinator
+ ```
+
+
+ YCSB ベンチマーク用のテーブル ([`ycsb-schema.json`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/ycsb-schema.json)) を作成するには、山括弧内の内容を説明に従って置き換えて、次のコマンドを実行します。
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config -f ycsb-schema.json --coordinator
+ ```
+
+
+ マルチストレージ YCSB ベンチマーク用のテーブル ([`ycsb-multi-storage-schema.json`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/ycsb-multi-storage-schema.json)) を作成するには、山括弧内の内容を説明に従って置き換えて、次のコマンドを実行します。
+
+ ```console
+ java -jar scalardb-schema-loader-.jar --config -f ycsb-multi-storage-schema.json --coordinator
+ ```
+
+
+
+### ベンチマーク設定ファイルを準備する
+
+ベンチマークを実行するには、まずベンチマーク設定ファイルを準備する必要があります。設定ファイルには、少なくとも実行するワークロードモジュールの場所とデータベース設定が必要です。
+
+以下は、TPC-C ベンチマークを実行するための設定例です。`config_file` に指定する ScalarDB プロパティファイルは、[以前に設定したベンチマーク環境](#ベンチマーク-ツールをセットアップする)のプロパティファイルである必要があります。
+
+:::note
+
+または、ScalarDB プロパティファイルを使用する代わりに、`.toml` ファイルで各データベース設定項目を指定することもできます。`config_file` が指定されている場合、`[database_config]` の下の他のすべての設定は、コメントが解除されていても無視されます。
+
+:::
+
+```toml
+[modules]
+[modules.preprocessor]
+name = "com.scalar.db.benchmarks.tpcc.TpccLoader"
+path = "./build/libs/scalardb-benchmarks-all.jar"
+[modules.processor]
+name = "com.scalar.db.benchmarks.tpcc.TpccBench"
+path = "./build/libs/scalardb-benchmarks-all.jar"
+[modules.postprocessor]
+name = "com.scalar.db.benchmarks.tpcc.TpccReporter"
+path = "./build/libs/scalardb-benchmarks-all.jar"
+
+[database_config]
+config_file = ""
+#contact_points = "localhost"
+#contact_port = 9042
+#username = "cassandra"
+#password = "cassandra"
+#storage = "cassandra"
+```
+
+モジュールに渡すパラメータは設定ファイルで定義できます。詳細については、以下のサンプル設定ファイルと [共通パラメータ](#共通パラメータ)で使用可能なパラメータを参照してください。
+
+- **TPC-C:** [`tpcc-benchmark-config.toml`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/tpcc-benchmark-config.toml)
+- **YCSB:** [`ycsb-benchmark-config.toml`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/ycsb-benchmark-config.toml)
+- **マルチストレージ YCSB:** [`ycsb-multi-storage-benchmark-config.toml`](https://github.com/scalar-labs/scalardb-benchmarks/blob/master/ycsb-multi-storage-benchmark-config.toml)
+
+## ベンチマークを実行する
+
+ベンチマークを選択し、指示に従ってベンチマークを実行します。
+
+
+
+ TPC-C ベンチマークを実行するには、`` を Kelpie ディレクトリへのパスに置き換えて、次のコマンドを実行します。
+
+ ```console
+ //bin/kelpie --config tpcc-benchmark-config.toml
+ ```
+
+
+ YCSB ベンチマークを実行するには、`` を Kelpie ディレクトリへのパスに置き換えて、次のコマンドを実行します。
+
+ ```console
+ //bin/kelpie --config ycsb-benchmark-config.toml
+ ```
+
+
+ マルチストレージ YCSB ベンチマークを実行するには、`` を Kelpie ディレクトリへのパスに置き換えて、次のコマンドを実行します。
+
+ ```console
+ //bin/kelpie --config ycsb-multi-storage-benchmark-config.toml
+ ```
+
+
+
+さらに、次のオプションが利用可能です。
+
+- `--only-pre`。データのみをロードします。
+- `--only-process`。ベンチマークのみを実行します。
+- `--except-pre`。データをロードせずにジョブを実行します。
+- `--except-process`。ベンチマークを実行せずにジョブを実行します。
+
+## 共通パラメータ
+
+| 名前 | 説明 | デフォルト |
+|:---------------|:----------------------------------|:----------|
+| `concurrency` | ベンチマーク用のスレッド数。 | `1` |
+| `run_for_sec` | ベンチマークの継続時間 (秒単位)。 | `60` |
+| `ramp_for_sec` | ベンチマーク前の立ち上げ時間 (秒単位)。 | `0` |
+
+## ワークロード固有のパラメータ
+
+ワークロードを選択すると、使用可能なパラメータが表示されます。
+
+
+
+ | 名前 | 説明 | デフォルト |
+ |:-----------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------|
+ | `num_warehouses` | ベンチマーク用のウェアハウスの数 (スケール係数)。 | `1` |
+ | `load_concurrency` | ロード用のスレッド数。 | `1` |
+ | `load_start_warehouse` | ロード中のウェアハウスの開始 ID。このオプションは、複数のクライアントで大規模なデータをロードする場合や、ウェアハウスを追加する場合に、`--skip-item-load` と一緒に使用すると便利です。 | `1` |
+ | `load_end_warehouse` | ロード中のウェアハウスの終了 ID。ロード中のウェアハウスの数を指定するには、`--num-warehouses` または `--end-warehouse` のいずれかを使用できます。 | `1` |
+ | `skip_item_load` | アイテムテーブルのロードをスキップするかどうか。 | `false` |
+ | `use_table_index` | ScalarDB のセカンダリインデックスの代わりに、汎用テーブルベースのセカンダリインデックスを使用するかどうか。 | `false` |
+ | `np_only` | 新規注文と支払いトランザクションのみ (それぞれ 50%) でベンチマークを実行します。 | `false` |
+ | `rate_new_order` | 新規注文トランザクションの割合。必要に応じてこの割合を指定する場合、他のすべてのレートパラメータの割合を指定する必要があります。その場合、すべてのレートパラメータの合計は 100% に等しくなければなりません。 | N/A |
+ | `rate_payment` | 支払いトランザクションの割合。必要に応じてこの割合を指定する場合、他のすべてのレートパラメータの割合を指定する必要があります。その場合、すべてのレートパラメータの合計は 100% に等しくなければなりません。 | N/A |
+ | `rate_order_status` | 注文ステータストランザクションの割合。ニーズに基づいてこのパーセンテージを指定する場合、他のすべてのレートパラメータのパーセンテージを指定する必要があります。その場合、すべてのレートパラメータの合計は 100 パーセントに等しくなければなりません。 | N/A |
+ | `rate_delivery` | 配送トランザクションのパーセンテージ。ニーズに基づいてこのパーセンテージを指定する場合、他のすべてのレートパラメータのパーセンテージを指定する必要があります。その場合、すべてのレートパラメータの合計は 100 パーセントに等しくなければなりません。 | N/A |
+ | `rate_stock_level` | 在庫レベルトランザクションのパーセンテージ。ニーズに基づいてこのパーセンテージを指定する場合、他のすべてのレートパラメータのパーセンテージを指定する必要があります。その場合、すべてのレートパラメータの合計は 100 パーセントに等しくなければなりません。 | N/A |
+ | `backoff` | 競合によりトランザクションがアボートされた後に挿入されるスリープ時間 (ミリ秒単位)。 | `0` |
+
+
+ | 名前 | 説明 | デフォルト |
+ |:------------------------|:----------------------------------------------------------------------------------|:----------------------------------------------|
+ | `load_concurrency` | ロード用のスレッド数。 | `1` |
+ | `load_batch_size` | 1回のロードトランザクションで入力されるレコード数。 | `1` |
+ | `load_overwrite` | レコードをロードするときに上書きするかどうか。 | `false` |
+ | `ops_per_tx` | 1回のトランザクションでの操作数。 | `2` (ワークロード A および C)
`1` (ワークロード F) |
+ | `record_count` | ターゲットテーブル内のレコード数。 | `1000` |
+ | `use_read_modify_write` | ワークロード A でブラインド書き込みではなく読み取り、変更、書き込みを使用するかどうか。 | `false`[^rmw] |
+
+ [^rmw]: ワークロード A はトランザクションが最初に元のレコードを読み取ることを想定していないため、`use_read_modify_write` のデフォルト値は `false` です。ただし、トランザクションマネージャーとして Consensus Commit を使用している場合は、`use_read_modify_write` を `true` に設定する必要があります。これは、ScalarDB が既存のレコードに対するブラインド書き込みを許可しないためです。
+
+
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/common-reference.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/common-reference.mdx
new file mode 100644
index 00000000..837809ab
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/common-reference.mdx
@@ -0,0 +1,163 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK リファレンス
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このリファレンスでは、ScalarDB Cluster .NET Client SDK の動作について詳しく説明します。
+
+## クライアント設定
+
+クライアントは、次のものを使用して設定できます。
+
+- 設定ファイル (`appsettings.json` など) またはカスタム JSON ファイル
+- 環境変数
+- `ScalarDbOptions` オブジェクト
+
+ASP.NET Core で SDK を使用する場合は、アプリをさまざまな方法で設定できます。詳細については、[ASP.NET Core の構成](https://learn.microsoft.com/ja-jp/aspnet/core/fundamentals/configuration/?view=aspnetcore-8.0)を参照してください。
+
+設定できるオプションの一覧については、[使用可能なオプション](#使用可能なオプション)を参照してください。
+
+### 設定ファイルの使用
+
+SDK は、標準の `appsettings.json` とカスタム JSON 設定ファイルの両方をサポートしています。 JSON ファイルでクライアントを設定するには、`ScalarDbOptions` セクションを追加し、必要なオプションを設定します。例:
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://localhost:60053",
+ "HopLimit": 10
+ }
+}
+```
+
+次に、次のように設定された `TransactionFactory` オブジェクトを作成します。
+
+```c#
+// If appsettings.json is used, call the Create() method without parameters.
+var factory = TransactionFactory.Create();
+
+// Or, if a custom file is used, call the Create() method that is passed in the path to the custom file as a parameter.
+factory = TransactionFactory.Create("scalardb-options.json");
+```
+
+ASP.NET Core で SDK を使用する場合、登録されたトランザクションマネージャーや `ScalarDbContext` が作成されると、`appsettings.json` の設定が自動的に適用されます。カスタム JSON ファイルを使用する場合は、次のように設定フレームワークに追加します。
+
+```c#
+var builder = WebApplication.CreateBuilder(args);
+
+// ...
+
+builder.Configuration.AddJsonFile("scalardb-options.json");
+```
+
+:::warning
+
+カスタム JSON ファイルはすべての標準設定プロバイダーの後に適用されるため、カスタムファイルの値が他のソースの値を上書きします。
+
+:::
+
+### 環境変数の使用
+
+クライアントが環境変数を使用するように設定するには、プレフィックス `ScalarDbOptions__` を使用します。例:
+
+```console
+export ScalarDbOptions__Address="http://localhost:60053"
+export ScalarDbOptions__HopLimit=10
+```
+
+:::warning
+
+環境変数の値は設定ファイルの値を上書きします。
+
+:::
+
+### `ScalarDbOptions` オブジェクトの使用
+
+次のように `ScalarDbOptions` オブジェクトを使用して、実行時にクライアントを設定できます。
+
+```c#
+var options = new ScalarDbOptions()
+{
+ Address = "http://localhost:60053",
+ HopLimit = 10
+};
+
+var factory = TransactionFactory.Create(options);
+```
+
+また、次のように、JSON ファイルや環境変数の値を使用して `ScalarDbOptions` オブジェクトを初期化し、残りの値を実行時に設定することもできます。
+
+```c#
+// If appsettings.json is used, call the Load() method without parameters.
+var options = ScalarDbOptions.Load();
+
+// Or, if a custom file is used, call the Load() method that is passed in the path to the custom file as a parameter.
+options = ScalarDbOptions.Load("scalardb-options.json");
+
+options.HopLimit = 10;
+
+var factory = TransactionFactory.Create(options);
+```
+
+ASP.NET Core で SDK を使用する場合は、次のように `AddScalarDb` および `AddScalarDbContext` のラムダ式を使用できます。
+
+```c#
+var builder = WebApplication.CreateBuilder(args);
+
+//...
+
+builder.Services.AddScalarDb(options =>
+{
+ options.Address = "http://localhost:60053";
+ options.HopLimit = 10;
+});
+
+builder.Services.AddScalarDbContext(options =>
+{
+ options.Address = "http://localhost:60053";
+ options.HopLimit = 10;
+});
+```
+
+この構成を使用すると、ラムダ式に渡される `ScalarDbOptions` オブジェクト (上記の例では `options` という名前) が、JSON ファイル、環境変数、およびその他のソースからの値で初期化されます。
+
+### 使用可能なオプション
+
+利用可能なオプションは次のとおりです。
+
+| 名前 | 説明 | デフォルト |
+|---------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------|
+| `Address` | **必須:** クラスターのアドレス。形式は `://:` です。``: ワイヤ暗号化 (TLS) が有効な場合は `https`、それ以外の場合は `http` です。``: クラスターの FQDN または IP アドレスです。``: クラスターのポート番号 (デフォルトでは `60053`)。 | - |
+| `HopLimit` | クラスターへのリクエストのホップ数。`HopLimit` の目的は、クラスター内での無限ループを防ぐことです。リクエストが別のクラスターノードに転送されるたびに、`HopLimit` は 1 ずつ減少します。`HopLimit` が 0 に達すると、リクエストは拒否されます。 | `3` |
+| `RetryCount` | クラスターが利用できない場合にクライアントがクラスターへの接続を試行できる回数。 | `10` |
+| `AuthEnabled` | 認証と認可が有効かどうか。 | `false` |
+| `Username` | 認証/認可のためのユーザー名。 | |
+| `Password` | 認証用のパスワード。設定されていない場合は、パスワードなしで認証が行われます。 | |
+| `AuthTokenExpirationTime` | 認証トークンを更新するまでの時間。`AuthTokenExpirationTime` に設定された時間がクラスターの有効期限よりも長い場合、認証エラーを受信すると認証トークンが更新されます。認証トークンが正常に更新されると、認証エラーはクライアントコードに伝播されません。代わりに、認証エラーで失敗した操作が自動的に再試行されます。複数の操作が並行して実行されている場合、認証トークンが更新される前に、これらすべての操作が認証エラーで一度失敗します。 | `00:00:00` (クラスターから受信した認証トークンの有効期限が使用されます。) |
+| `TlsRootCertPem` | TLS 通信用のカスタム CA ルート証明書 (PEM データ)。 | |
+| `TlsRootCertPath` | TLS 通信用のカスタム CA ルート証明書へのファイルパス。 | |
+| `TlsOverrideAuthority` | TLS 通信のカスタム認証局。これは、実際に接続しているホストを変更するものではありません。これは主にテストを目的としています。たとえば、クラスターの証明書 (クラスターの `scalar.db.cluster.node.tls.cert_chain_path` パラメータ) に記載されているホスト名を指定できます。クラスターの証明書に複数のホスト名がある場合は、最初のホスト名のみがチェックされます。 | |
+| `LogSensitiveData` | `true` に設定すると、gRPC リクエストとレスポンスをログに記録するときに、ユーザー名、パスワード、認証トークンなどの情報がマスクされずにそのままログに記録されます。 | `false` |
+
+## ScalarDB 列型と .NET 型間の変換方法
+
+[LINQ](getting-started-with-linq.mdx#クラスを設定する) または [Transactional API](getting-started-with-scalardb-tables-as-csharp-classes.mdx#すべての-scalardb-テーブルのクラスを作成する)、[SQL API](getting-started-with-distributed-sql-transactions.mdx#sql-クエリを実行する)、または [Administrative API](getting-started-with-scalardb-tables-as-csharp-classes.mdx#administrative-api-を使用する) の拡張メソッドを使用すると、クラスターから受信した列の値は、対応する .NET 型に自動的に変換されます。同様に、オブジェクトがクラスターに保存されるときに、.NET プロパティの値は対応するクラスターの型に自動的に変換されます。
+
+次の表に、型がどのように変換されるかを示します。
+
+| ScalarDB 型 | .NET 型 | C# エイリアス |
+|------------|----------------------------|-------------|
+| TEXT | System.String | string |
+| INT | System.Int32 | int |
+| BIGINT | System.Int64 | long |
+| FLOAT | System.Single | float |
+| DOUBLE | System.Double | double |
+| BOOLEAN | System.Boolean | bool |
+| BLOB | Google.Protobuf.ByteString | |
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/exception-handling.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/exception-handling.mdx
new file mode 100644
index 00000000..5170e6c5
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/exception-handling.mdx
@@ -0,0 +1,176 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK での例外処理
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+トランザクションを実行するときは、例外も適切に処理する必要があります。
+
+:::warning
+
+例外を適切に処理しないと、異常やデータの不整合が発生する可能性があります。
+
+:::
+
+:::note
+
+この例では Transactional API が使用されていますが、SQL API または `ScalarDbContext` を使用する場合も例外は同じ方法で処理できます。
+
+:::
+
+次のサンプルコードは、例外を処理する方法を示しています。
+
+```c#
+using System.ComponentModel.DataAnnotations.Schema;
+using ScalarDB.Client;
+using ScalarDB.Client.DataAnnotations;
+using ScalarDB.Client.Exceptions;
+using ScalarDB.Client.Extensions;
+
+var options = new ScalarDbOptions { Address = "http://:"};
+
+var factory = TransactionFactory.Create(options);
+using var manager = factory.GetTransactionManager();
+
+var retryCount = 0;
+TransactionException? lastException = null;
+
+while (true)
+{
+ if (retryCount++ > 0)
+ {
+ // Retry the transaction three times maximum in this sample code
+ if (retryCount > 3)
+ // Throw the last exception if the number of retries exceeds the maximum
+ throw lastException!;
+
+ // Sleep 100 milliseconds before retrying the transaction in this sample code
+ await Task.Delay(100);
+ }
+
+ // Begin a transaction
+ var tran = await manager.BeginAsync();
+ try
+ {
+ // Execute CRUD operations in the transaction
+ var getKeys = new Dictionary { { nameof(Item.Id), 1 } };
+ var result = await tran.GetAsync- (getKeys);
+
+ var scanKeys = new Dictionary { { nameof(Item.Id), 1 } };
+ await foreach (var item in tran.ScanAsync
- (scanKeys, null))
+ Console.WriteLine($"{item.Id}, {item.Name}, {item.Price}");
+
+ await tran.InsertAsync(new Item { Id = 1, Name = "Watermelon", Price = 4500 });
+ await tran.DeleteAsync(new Item { Id = 1 });
+
+ // Commit the transaction
+ await tran.CommitAsync();
+
+ return;
+ }
+ catch (UnsatisfiedConditionException)
+ {
+ // You need to handle `UnsatisfiedConditionException` only if a mutation operation specifies
+ // a condition. This exception indicates the condition for the mutation operation is not met.
+ // InsertAsync/UpdateAsync implicitlly sets IfNotExists/IfExists condition
+
+ try
+ {
+ await tran.RollbackAsync();
+ }
+ catch (TransactionException ex)
+ {
+ // Rolling back the transaction failed. As the transaction should eventually recover, you
+ // don't need to do anything further. You can simply log the occurrence here
+ Console.WriteLine($"Rollback error: {ex}");
+ }
+
+ // You can handle the exception here, according to your application requirements
+
+ return;
+ }
+ catch (UnknownTransactionStatusException)
+ {
+ // If you catch `UnknownTransactionStatusException` when committing the transaction, it
+ // indicates that the status of the transaction, whether it has succeeded or not, is
+ // unknown. In such a case, you need to check if the transaction is committed successfully
+ // or not and retry it if it failed. How to identify a transaction status is delegated to users
+ return;
+ }
+ catch (TransactionException ex)
+ {
+ // For other exceptions, you can try retrying the transaction.
+
+ // For `TransactionConflictException` and `TransactionNotFoundException`,
+ // you can basically retry the transaction. However, for the other exceptions,
+ // the transaction may still fail if the cause of the exception is nontransient.
+ // In such a case, you will exhaust the number of retries and throw the last exception
+
+ try
+ {
+ await tran.RollbackAsync();
+ }
+ catch (TransactionException e)
+ {
+ // Rolling back the transaction failed. As the transaction should eventually recover,
+ // you don't need to do anything further. You can simply log the occurrence here
+ Console.WriteLine($"Rollback error: {e}");
+ }
+
+ lastException = ex;
+ }
+}
+
+[Table("order_service.items")]
+public class Item
+{
+ [PartitionKey]
+ [Column("item_id", Order = 0)]
+ public int Id { get; set; }
+
+ [Column("name", Order = 1)]
+ public string Name { get; set; } = String.Empty;
+
+ [Column("price", Order = 2)]
+ public int Price { get; set; }
+}
+
+```
+
+:::note
+
+サンプルコードでは、トランザクションは最大 3 回再試行され、再試行される前に 100 ミリ秒間スリープします。アプリケーションの要件に応じて、指数バックオフなどの再試行ポリシーを選択できます。
+
+:::
+
+### 例外の詳細
+
+以下の表は、クラスターとの通信時に発生する可能性のあるトランザクション例外を示しています。
+
+| 例外 | 操作 | 説明 |
+|-----------------------------------|--------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| AuthorizationErrorException | Put, Insert, Update, Delete, Mutate, Execute, Administrative | 権限が不足しているため、認証に失敗しました。 |
+| IllegalArgumentException | 全て | 要求メッセージ内の引数が無効です。 |
+| IllegalStateException | 全て | RPC が無効な状態で呼び出されました。 |
+| InternalErrorException | 全て | 一時的または非一時的障害のため、操作が失敗しました。トランザクションを最初から再試行することはできますが、原因が非一時的である場合は、トランザクションが失敗する可能性があります。 |
+| TransactionConflictException | Begin、Join、Rollback を除くすべて | トランザクションの競合が発生しました。このエラーが発生した場合は、トランザクションを最初から再試行してください。 |
+| TransactionNotFoundException | Begin、Join を除くすべて | 指定されたトランザクション ID に関連付けられたトランザクションが見つかりませんでした。このエラーは、トランザクションの有効期限が切れたか、クラスタートポロジの変更によりルーティング情報が更新されたことを示します。この場合、トランザクションを最初から再試行してください。 |
+| UnavailableException | 全て | ScalarDB Cluster は、複数回接続を試みても利用できません。 |
+| UnknownTransactionStatusException | Commit | トランザクションのステータスは不明です (トランザクションが正常にコミットされたかどうかは不明です)。この状況では、トランザクションが正常にコミットされたかどうかを確認し、そうでない場合は再試行する必要があります。トランザクションステータスの判断はユーザーの責任です。トランザクションステータステーブルを作成し、他のアプリケーションデータと連動して更新すると、役立つ場合があります。そうすることで、テーブル自体からトランザクションのステータスを判断できるようになります。 |
+| UnsatisfiedConditionException | Put, Insert, Update, Delete, Mutate | 突然変異条件が満たされていません。 |
+
+例外が発生した場合は、`Begin` の場合を除き、トランザクションをロールバックする必要があります。トランザクションをロールバックした後、再試行によって解決できる例外については、トランザクションを最初から再試行できます。
+
+上記の例外の他に、gRPC ライブラリによってスローされる例外が発生する場合があります。このような場合は、`RpcException` プロパティで詳細を確認できます。
+
+また、`ScalarDbContext` は、次の場合に `TransactionException` タイプの例外をスローします。
+
+- すでにアクティブなトランザクションがあるときに `BeginTransaction` または `JoinTransaction` が呼び出された場合
+- アクティブなトランザクションがない状態で `CommitTransaction` または `RollbackTransaction` が呼び出された場合
+- アクティブな 2 フェーズコミットトランザクションがない状態で `PrepareTransaction` または `ValidateTransaction` が呼び出された場合
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-admin-api.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-admin-api.mdx
new file mode 100644
index 00000000..dba34141
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-admin-api.mdx
@@ -0,0 +1,131 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK の Administrative API をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ScalarDB Cluster の Administrative API をサポートしています。この API を使用すると、.NET アプリケーションから ScalarDB Cluster を管理できます。
+
+:::note
+
+次の例のように非同期メソッドを使用することをお勧めしますが、代わりに同期メソッドを使用することもできます。
+
+:::
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を、使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## 設定ファイルを作成する
+
+`scalardb-options.json` ファイルを作成し、次の内容を追加します。`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーを取得する
+
+Administrative API とやり取りするためのオブジェクトを取得する必要があります。オブジェクトを取得するには、次のように `TransactionFactory` を使用します。
+
+```c#
+// Pass the path to the settings file created in the previous step.
+var factory = TransactionFactory.Create("scalardb-options.json");
+
+using var admin = factory.GetTransactionAdmin();
+```
+
+## ScalarDB Cluster の管理
+
+ScalarDB Cluster .NET Client SDK を使用して、次の操作を実行できます。
+
+### 新しい名前空間を作成する
+
+```c#
+await admin.CreateNamespaceAsync("ns", ifNotExists: true);
+```
+
+### 名前空間を削除する
+
+```c#
+await admin.DropNamespaceAsync("ns", ifExists: true);
+```
+
+### 名前空間が存在するかどうかを確認する
+
+```c#
+var namespaceExists = await admin.IsNamespacePresentAsync("ns");
+```
+
+### 新しいテーブルを作成する
+
+```c#
+// ...
+using ScalarDB.Client.Builders.Admin;
+using ScalarDB.Client.Core;
+
+// ...
+
+var tableMetadata =
+ new TableMetadataBuilder()
+ .AddPartitionKey("pk", DataType.Int)
+ .AddClusteringKey("ck", DataType.Double)
+ .AddSecondaryIndex("index", DataType.Float)
+ .AddColumn("ordinary", DataType.Text)
+ .Build();
+
+await admin.CreateTableAsync("ns", "table_name", tableMetadata, ifNotExists: true);
+```
+
+### テーブルを削除する
+
+```c#
+await admin.DropTableAsync("ns", "table_name", ifExists: true);
+```
+
+### テーブルが存在するかどうかを確認する
+
+```c#
+var tableExists = await admin.IsTablePresentAsync("ns", "table_name");
+```
+
+### 既存のテーブルの名前を取得する
+
+```c#
+var tablesList = await admin.GetTableNamesAsync("ns");
+```
+
+### Coordinator テーブルを作成する
+
+```c#
+await admin.CreateCoordinatorTablesAsync();
+```
+
+### Coordinator テーブルを削除する
+
+```c#
+await admin.DropCoordinatorTablesAsync();
+```
+
+### Coordinator テーブルが存在するかどうかを確認します
+
+```c#
+var exists = await admin.AreCoordinatorTablesPresentAsync();
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-aspnet-and-di.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-aspnet-and-di.mdx
new file mode 100644
index 00000000..88b2263a
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-aspnet-and-di.mdx
@@ -0,0 +1,81 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK での ASP.NET Core と依存性注入をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ASP.NET Core などのフレームワークでの依存性注入をサポートしています。
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## クライアント設定の追加
+
+ASP.NET Core アプリの `appsettings.json` ファイルに `ScalarDbOptions` セクションを追加し、`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーをセットアップする
+
+次のように、ScalarDB トランザクションマネージャーを `IServiceCollection` のサービスとして登録できます。
+
+```c#
+using ScalarDB.Client.Extensions;
+
+//...
+
+var builder = WebApplication.CreateBuilder(args);
+
+//...
+
+builder.Services.AddScalarDb();
+```
+
+トランザクションマネージャーを登録したら、次のようにコントローラーのコンストラクターに挿入できます。
+
+```c#
+[ApiController]
+public class OrderController: ControllerBase
+{
+ private readonly IDistributedTransactionManager _manager;
+ private readonly ISqlTransactionManager _sqlManager;
+ private readonly ITwoPhaseCommitTransactionManager _twoPhaseManager;
+ private readonly ISqlTwoPhaseCommitTransactionManager _sqlTwoPhaseManager;
+ private readonly IDistributedTransactionAdmin _admin;
+
+ public OrderController(IDistributedTransactionManager manager,
+ ISqlTransactionManager sqlManager,
+ ITwoPhaseCommitTransactionManager twoPhaseManager,
+ ISqlTwoPhaseCommitTransactionManager sqlTwoPhaseManager,
+ IDistributedTransactionAdmin admin)
+ {
+ _manager = manager;
+ _sqlManager = sqlManager;
+ _twoPhaseManager = twoPhaseManager;
+ _sqlTwoPhaseManager = sqlTwoPhaseManager;
+ _admin = admin;
+ }
+}
+```
+
+これらの例は WebApi プロジェクト用ですが、GrpcService プロジェクトでも同様に動作します。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-auth.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-auth.mdx
new file mode 100644
index 00000000..3af384cb
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-auth.mdx
@@ -0,0 +1,70 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK を使用した認証と認可をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は [認証と認可](../scalardb-cluster/scalardb-auth-with-sql.mdx)をサポートしており、これにより ScalarDB Cluster へのリクエストを認証および認可できます。
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## 設定ファイルで資格情報を設定する
+
+設定ファイルの資格情報を次のように設定し、山括弧内の内容を置き換えてください。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10,
+ "AuthEnabled": true,
+ "Username": "",
+ "Password": ""
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーを取得する
+
+次のように `TransactionFactory` を使用して、トランザクションマネージャーまたはトランザクション管理オブジェクトを取得する必要があります。`` を `GetTransactionManager()`、`GetTwoPhaseCommitTransactionManager()`、`GetSqlTransactionManager()`、または `GetSqlTwoPhaseCommitTransactionManager()` に置き換えてください。
+
+```c#
+// Pass the path to the settings file.
+var factory = TransactionFactory.Create("scalardb-options.json");
+
+// To get a transaction manager
+using var manager = factory.();
+
+// To get a transaction admin
+using var admin = factory.GetTransactionAdmin();
+```
+
+提供された資格情報を使用して `TransactionFactory` から作成されたトランザクションマネージャーまたはトランザクション管理オブジェクトは、ScalarDB Cluster に自動的にログインし、通信できます。
+
+## ワイヤ暗号化
+
+[ワイヤ暗号化](../scalardb-cluster/scalardb-auth-with-sql.mdx#ワイヤ暗号化) もサポートされています。次のように `Address` を `https` で始まる URL に設定することで有効にできます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "https://:"
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-sql-transactions.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-sql-transactions.mdx
new file mode 100644
index 00000000..1e5ccb6b
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-sql-transactions.mdx
@@ -0,0 +1,195 @@
+---
+tags:
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK での分散 SQL トランザクションをはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ScalarDB Cluster の分散 SQL トランザクション機能をサポートします。SDK には、クラスター内での通信を容易にするためのトランザクションとマネージャーの抽象化が含まれています。
+
+:::note
+
+次の例のように非同期メソッドを使用することをお勧めしますが、代わりに同期メソッドを使用することもできます。
+
+:::
+
+分散非 SQL トランザクションの詳細については、[ScalarDB Cluster .NET Client SDK での分散トランザクションをはじめよう](getting-started-with-distributed-transactions.mdx)を参照してください。
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を、使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## 設定ファイルを作成する
+
+`scalardb-options.json` ファイルを作成し、次の内容を追加します。`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーを取得する
+
+分散 SQL トランザクション用のトランザクションマネージャーオブジェクトを取得する必要があります。トランザクションマネージャーオブジェクトを取得するには、次のように `TransactionFactory` を使用します。
+
+```c#
+// Pass the path to the settings file created in the previous step.
+var factory = TransactionFactory.Create("scalardb-options.json");
+
+using var manager = factory.GetSqlTransactionManager();
+```
+
+## SQL クエリを実行する
+
+SQL ステートメントを実行するには、次のようにビルダーを使用して作成できる `ISqlStatement` オブジェクトが必要です。
+
+```c#
+using ScalarDB.Client.Builders.Sql;
+
+// ...
+
+var sqlStatement =
+ new SqlStatementBuilder()
+ .SetSql("SELECT * FROM order_service.statements WHERE item_id = :item_id")
+ .AddParam("item_id", 2)
+ .Build();
+```
+
+次のようにトランザクションマネージャーを使用して、単一の SQL ステートメントを直接実行できます。
+
+```c#
+var resultSet = await manager.ExecuteAsync(sqlStatement);
+```
+
+`ExecuteAsync` メソッドの結果には、クラスターから受信したレコードが含まれます。特定の列の値は、次の方法で取得できます。
+
+```c#
+foreach (var record in resultSet.Records)
+{
+ // Getting an integer value from the "item_id" column.
+ // If it fails, an exception will be thrown.
+ var itemId = record.GetValue("item_id");
+
+ // Trying to get a string value from the "order_id" column.
+ // If it fails, no exception will be thrown.
+ if (record.TryGetValue("order_id", out var orderId))
+ Console.WriteLine($"order_id: {orderId}");
+
+ // Checking if the "count" column is null.
+ if (record.IsNull("count"))
+ Console.WriteLine("'count' is null");
+}
+```
+
+`GetValue` および `TryGetValue` で使用する型の詳細については、[ScalarDB 列型を .NET 型に変換する方法](common-reference.mdx#scalardb-列型と-net-型間の変換方法) を参照してください。
+
+## トランザクションで SQL クエリを実行する
+
+1 つのトランザクションの一部として複数の SQL ステートメントを実行するには、トランザクションオブジェクトが必要です。
+
+次のようにトランザクションマネージャーを使用してトランザクションオブジェクトを作成できます。
+
+```c#
+var transaction = await manager.BeginAsync();
+```
+
+次のようにして、すでに開始されているトランザクションを再開することもできます。
+
+```c#
+var transaction = manager.Resume(transactionIdString);
+```
+
+:::note
+
+`Resume` メソッドはトランザクションオブジェクトを作成するだけなので、非同期バージョンはありません。このため、間違った ID を使用してトランザクションを再開する可能性があります。
+
+:::
+
+トランザクションには、トランザクションマネージャーと同じ `ExecuteAsync` メソッドがあります。このメソッドを使用して、SQL ステートメントを実行できます。
+
+トランザクションをコミットする準備ができたら、次のようにトランザクションの `CommitAsync` メソッドを呼び出すことができます。
+
+```c#
+await transaction.CommitAsync();
+```
+
+トランザクションをロールバックするには、`RollbackAsync` メソッドを使用できます。
+
+```c#
+await transaction.RollbackAsync();
+```
+
+## メタデータを取得する
+
+次のように、Metadata プロパティを使用して ScalarDB のメタデータを取得できます。
+
+```c#
+// namespaces, tables metadata
+var namespaceNames = new List();
+
+await foreach (var ns in manager.Metadata.GetNamespacesAsync())
+{
+ namespaceNames.Add(ns.Name);
+ Console.WriteLine($"Namespace: {ns.Name}");
+
+ await foreach (var tbl in ns.GetTablesAsync())
+ {
+ Console.WriteLine($" Table: {tbl.Name}");
+
+ Console.WriteLine($" Columns:");
+ foreach (var col in tbl.Columns)
+ Console.WriteLine($" {col.Name} [{col.DataType}]");
+
+ Console.WriteLine($" PartitionKey:");
+ foreach (var col in tbl.PartitionKey)
+ Console.WriteLine($" {col.Name}");
+
+ Console.WriteLine($" ClusteringKey:");
+ foreach (var col in tbl.ClusteringKey)
+ Console.WriteLine($" {col.Name} [{col.ClusteringOrder}]");
+
+ Console.WriteLine($" Indexes:");
+ foreach (var index in tbl.Indexes)
+ Console.WriteLine($" {index.ColumnName}");
+
+ Console.WriteLine();
+ }
+}
+
+// users metadata
+await foreach (var user in manager.Metadata.GetUsersAsync())
+{
+ Console.WriteLine($"User: {user.Name} [IsSuperuser: {user.IsSuperuser}]");
+
+ foreach (var nsName in namespaceNames)
+ {
+ Console.WriteLine($" Namespace: {nsName}");
+
+ Console.WriteLine($" Privileges:");
+ foreach (var privilege in await user.GetPrivilegesAsync(nsName))
+ Console.WriteLine($" {privilege}");
+ }
+
+ Console.WriteLine();
+}
+```
+
+:::note
+
+`IAsyncEnumerable` で LINQ メソッドを使用するには、[System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async/) パッケージをインストールします。
+
+:::
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-transactions.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-transactions.mdx
new file mode 100644
index 00000000..91a4e612
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-distributed-transactions.mdx
@@ -0,0 +1,329 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK での分散トランザクションをはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ScalarDB Cluster の分散トランザクション機能をサポートします。SDK には、クラスター内での通信を容易にするためのトランザクションとマネージャーの抽象化が含まれています。
+
+:::note
+
+次の例のように非同期メソッドを使用することをお勧めしますが、代わりに同期バージョンを使用することもできます。
+
+:::
+
+分散 SQL トランザクションの詳細については、[ScalarDB Cluster .NET Client SDK での分散 SQL トランザクションをはじめよう](getting-started-with-distributed-sql-transactions.mdx)を参照してください。
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用して、`.` を使用しているバージョンに置き換えることでこれを行うことができます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## 設定ファイルを作成する
+
+`scalardb-options.json` ファイルを作成し、次の内容を追加します。`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーを取得する
+
+分散トランザクションにはトランザクションマネージャーを取得する必要があります。トランザクションマネージャーを取得するには、次のように `TransactionFactory` を使用します。
+
+```c#
+// Pass the path to the settings file created in the previous step.
+var factory = TransactionFactory.Create("scalardb-options.json");
+
+using var manager = factory.GetTransactionManager();
+```
+
+## トランザクションを管理する
+
+複数の CRUD 操作を単一のトランザクションの一部として実行するには、まずトランザクションを開始する必要があります。次のようにトランザクションマネージャーを使用してトランザクションを開始できます。
+
+```c#
+var transaction = await manager.BeginAsync();
+```
+
+次のようにして、すでに実行中のトランザクションを再開することもできます。
+
+```c#
+var transaction = manager.Resume(transactionIdString);
+```
+
+:::note
+
+`Resume` メソッドはトランザクションオブジェクトを作成するだけなので、非同期バージョンはありません。このため、間違った ID を使用してトランザクションを再開する可能性があります。
+
+:::
+
+トランザクションをコミットする準備ができたら、次のようにトランザクションの `CommitAsync` メソッドを呼び出すことができます。
+
+```c#
+await transaction.CommitAsync();
+```
+
+トランザクションをロールバックするには、`RollbackAsync` メソッドを使用できます。
+
+```c#
+await transaction.RollbackAsync();
+```
+
+## CRUD 操作を実行する
+
+トランザクションには、クラスターに対して CRUD 操作を実行するための `GetAsync`、`ScanAsync`、`InsertAsync`、`UpsertAsync`、`UpdateAsync`、`DeleteAsync`、および `MutateAsync` メソッドがあります。パラメーターとして、これらのメソッドには操作オブジェクトがあります。操作オブジェクトは、このセクションにリストされているビルダーを使用して作成できます。
+
+:::note
+
+CRUD 操作は、トランザクションを明示的に作成する必要なく、ワンショットトランザクション方式で実行できます。そのために、マネージャーオブジェクトには、トランザクションオブジェクトと同じ CRUD メソッドがあります。
+
+:::
+
+ビルダーを使用するには、`using` セクションに次の名前空間を追加します。
+
+```c#
+using ScalarDB.Client.Builders;
+```
+
+:::note
+
+クラスターは 1 つのトランザクション内でのコマンドの並列実行をサポートしていないため、非同期メソッドには必ず `await` を使用してください。
+
+:::
+
+### `GetAsync` メソッドの例
+
+単一のレコードを取得するには、次のように `GetAsync` メソッドを使用します。
+
+```c#
+var get =
+ new GetBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddClusteringKey("item_id", 2)
+ .SetProjections("item_id", "count")
+ .Build();
+
+var getResult = await transaction.GetAsync(get);
+```
+
+パーティションキーの代わりにインデックスを使用してレコードを取得することも可能です。そのためには、次のように操作の種類を `GetWithIndex` に設定する必要があります。
+
+```c#
+// ...
+using ScalarDB.Client.Core;
+
+// ...
+
+var get =
+ new GetBuilder()
+ // ...
+ .SetGetType(GetOperationType.GetWithIndex)
+ .AddPartitionKey("index_column", "1")
+ .Build();
+```
+
+取得されたレコードが満たす必要のある任意の条件を指定することもできます。満たさない場合はレコードは返されません。条件は、次のように条件の結合として設定できます。
+
+```c#
+var get =
+ new GetBuilder()
+ // ...
+ .AddConjunction(c => c.AddCondition("cost", 1000, Operator.LessThan))
+ .AddConjunction(c =>
+ {
+ c.AddCondition("cost", 10000, Operator.LessThan);
+ c.AddCondition("in_stock", true, Operator.Equal);
+ })
+ .Build();
+```
+
+上記の例では、`cost` が `1000` 未満の場合、または `cost` が `10000` 未満で `in_stock` が true の場合にのみ、レコードが返されます。
+
+#### `IResult` オブジェクトの処理
+
+`GetAsync` メソッドと `ScanAsync` メソッドは `IResult` オブジェクトを返します。`IResult` オブジェクトには、取得されたレコードの列が含まれます。特定の列の値は、次の方法で取得できます。
+
+```c#
+// Getting an integer value from the "item_id" column.
+// If it fails, an exception will be thrown.
+var itemId = result.GetValue("item_id");
+
+// Trying to get a string value from the "order_id" column.
+// If it fails, no exception will be thrown.
+if (result.TryGetValue("order_id", out var orderId))
+ Console.WriteLine($"order_id: {orderId}");
+
+// Checking if the "count" column is null.
+if (result.IsNull("count"))
+ Console.WriteLine("'count' is null");
+```
+
+`GetValue` および `TryGetValue` で使用する型の詳細については、[ScalarDB 列型と .NET 型間の変換方法](common-reference.mdx#scalardb-列型を-net-型間の変換方法) を参照してください。
+
+### `ScanAsync` メソッドの例
+
+レコードの範囲を取得するには、次のように `ScanAsync` メソッドを使用できます。
+
+```c#
+var scan =
+ new ScanBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddStartClusteringKey("item_id", 2)
+ .SetStartInclusive(true)
+ .AddEndClusteringKey("item_id", 8)
+ .SetEndInclusive(true)
+ .SetProjections("item_id", "count")
+ .Build();
+
+var scanResult = await transaction.ScanAsync(scan);
+```
+
+パーティションキーの代わりにインデックスを使用してレコードを取得することも可能です。そのためには、次のように操作の種類を `ScanWithIndex` に設定する必要があります。
+
+```c#
+// ...
+using ScalarDB.Client.Core;
+
+// ...
+var scan =
+ new ScanBuilder()
+ // ...
+ .SetScanType(ScanOperationType.ScanWithIndex)
+ .AddPartitionKey("index_column", "1")
+ .Build();
+```
+
+取得されたレコードが満たす必要のある任意の条件は、[get 操作](getting-started-with-distributed-transactions.mdx#getasync-メソッドの例)の場合と同様に、スキャン操作に対しても設定できます。
+
+### `InsertAsync` メソッドの例
+
+新しいレコードを挿入するには、次のように `InsertAsync` メソッドを使用します。
+
+```c#
+var insert =
+ new InsertBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddClusteringKey("item_id", 2)
+ .AddColumn("count", 11)
+ .Build();
+
+await transaction.InsertAsync(insert);
+```
+
+### `UpsertAsync` メソッドの例
+
+レコードをUPSERTする (既存のレコードを更新するか、新しいレコードを挿入する) には、次のように `UpsertAsync` メソッドを使用できます。
+
+```c#
+var upsert =
+ new UpsertBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddClusteringKey("item_id", 2)
+ .AddColumn("count", 11)
+ .Build();
+
+await transaction.UpsertAsync(upsert);
+```
+
+### `UpdateAsync` メソッドの例
+
+既存のレコードを更新するには、次のように `UpdateAsync` メソッドを使用します。
+
+```c#
+// ...
+using ScalarDB.Client.Core;
+
+// ...
+
+var update =
+ new UpdateBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddClusteringKey("item_id", 2)
+ .AddColumn("count", 11)
+ .AddCondition("processed", false, Operator.Equal)
+ .Build();
+
+await transaction.UpdateAsync(update);
+```
+
+### `DeleteAsync` メソッドの例
+
+レコードを削除するには、次のように `DeleteAsync` メソッドを使用します。
+
+```c#
+// ...
+using ScalarDB.Client.Core;
+
+// ...
+var delete =
+ new DeleteBuilder()
+ .SetNamespaceName("ns")
+ .SetTableName("statements")
+ .AddPartitionKey("order_id", "1")
+ .AddClusteringKey("item_id", 2)
+ .AddCondition("processed", false, Operator.Equal)
+ .Build();
+
+await transaction.DeleteAsync(delete);
+```
+
+### `MutateAsync` メソッドの例
+
+`MutateAsync` メソッドを使用すると、クラスターへの 1 回の呼び出しで複数のミューテーション操作を実行できます。これは次の方法で実行できます。
+
+```c#
+// ...
+using ScalarDB.Client.Core;
+
+// ...
+var mutations = new IMutation[]
+ {
+ new InsertBuilder()
+ // ...
+ .Build(),
+ new UpsertBuilder()
+ // ...
+ .Build(),
+ new UpdateBuilder()
+ // ...
+ .Build(),
+ new DeleteBuilder()
+ // ...
+ .Build()
+ };
+
+await transaction.MutateAsync(mutations);
+```
+
+:::note
+
+`InsertAsync`、`UpsertAsync`、`UpdateAsync`、`DeleteAsync`、または `MutateAsync` メソッドを使用してデータを変更するには、まず `GetAsync` または `ScanAsync` メソッドを使用してデータを取得する必要があります。
+
+:::
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-linq.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-linq.mdx
new file mode 100644
index 00000000..6f6545ef
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-linq.mdx
@@ -0,0 +1,366 @@
+---
+tags:
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK での LINQ をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、LINQ と Entity Framework のような機能を使用してクラスターをクエリすることをサポートしています。
+
+:::note
+
+この SDK は [Entity Framework](https://learn.microsoft.com/ja-jp/ef/) をサポートしていません。代わりに、この SDK は Entity Framework に似た機能を実装します。
+
+:::
+
+:::note
+
+LINQ を使用するには、クラスターで SQL サポートを有効にする必要があります。
+
+:::
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を、使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## クライアント設定の追加
+
+ASP.NET Core アプリの `appsettings.json` ファイルに `ScalarDbOptions` セクションを追加し、`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## クラスを設定する
+
+SQL サポートが有効になっていることを確認したら、使用する ScalarDB テーブルごとに C# クラスを作成します。例:
+
+```c#
+using System.ComponentModel.DataAnnotations.Schema;
+using ScalarDB.Client.DataAnnotations;
+
+// ...
+
+[Table("ns.statements")]
+public class Statement
+{
+ [PartitionKey]
+ [Column("statement_id", Order = 0)]
+ public int Id { get; set; }
+
+ [SecondaryIndex]
+ [Column("order_id", Order = 1)]
+ public string OrderId { get; set; } = String.Empty;
+
+ [SecondaryIndex]
+ [Column("item_id", Order = 2)]
+ public int ItemId { get; set; }
+
+ [Column("count", Order = 3)]
+ public int Count { get; set; }
+}
+
+[Table("order_service.items")]
+public class Item
+{
+ [PartitionKey]
+ [Column("item_id", Order = 0)]
+ public int Id { get; set; }
+
+ [Column("name", Order = 1)]
+ public string Name { get; set; } = String.Empty;
+
+ [Column("price", Order = 2)]
+ public int Price { get; set; }
+}
+```
+
+パーティションキー、クラスタリングキー、またはセカンダリインデックスが複数の列で設定されている場合、`ColumnAttribute` の `Order` プロパティによってキーまたはインデックス内の順序が決まります。
+
+プロパティに使用する型の詳細については、[ScalarDB 列型と .NET 型間の変換方法](common-reference.mdx#scalardb-列型と-net-型間の変換方法) を参照してください。
+
+使用するすべてのテーブルのプロパティを持つコンテキストクラスを作成します。例:
+
+```c#
+ public class MyDbContext: ScalarDbContext
+ {
+ public ScalarDbSet Statements { get; set; }
+ public ScalarDbSet
- Items { get; set; }
+ }
+```
+
+すべてのクラスが作成されたら、作成されたコンテキストを依存性注入に追加する必要があります。例:
+
+```c#
+using ScalarDB.Client.Extensions;
+
+//...
+
+var builder = WebApplication.CreateBuilder(args);
+
+//...
+
+builder.Services.AddScalarDbContext();
+```
+
+コンテキストは、次のようにコントローラーのコンストラクターに挿入できます。
+
+```c#
+[ApiController]
+public class OrderController: ControllerBase
+{
+ private readonly MyDbContext _myDbContext;
+
+ public OrderController(MyDbContext myDbContext)
+ {
+ _myDbContext = myDbContext;
+ }
+}
+```
+
+## LINQ を使用してプロパティをクエリする
+
+コントローラーで `MyDbContext` を受け取ったら、LINQ を使用してそのプロパティをクエリできます。例:
+
+### クエリ構文を使用する
+
+```c#
+from stat in _myDbContext.Statements
+join item in _myDbContext.Items on stat.ItemId equals item.Id
+where stat.Count > 2 && item.Name.Contains("apple")
+orderby stat.Count descending, stat.ItemId
+select new { item.Name, stat.Count };
+```
+
+### メソッド構文を使用する
+
+```c#
+_myDbContext.Statements
+ .Where(stat => stat.OrderId == "1")
+ .Skip(1)
+ .Take(2);
+```
+
+### `First` メソッドを使用して、パーティションキーで 1 つの `Statement` を取得します。
+
+```c#
+_myDbContext.Statements.First(stat => stat.OrderId == "1");
+```
+
+### `DefaultIfEmpty` メソッドを使用して左外部結合を実行します
+
+```c#
+from stat in _myDbContext.Statements
+join item in _myDbContext.Items on stat.ItemId equals item.Id into items
+from i in items.DefaultIfEmpty()
+select new { ItemName = i != null ? i.Name : "" }
+```
+
+以下のメソッドがサポートされています:
+
+- `Select`
+- `Where`
+- `Join`
+- `GroupJoin`
+- `First`/`FirstOrDefault`
+- `Skip`
+- `Take`
+- `OrderBy`/`OrderByDescending`
+- `ThenBy`/`ThenByDescending`
+
+次の `String` メソッドは、`Where` メソッドと `First`/`FirstOrDefault` メソッドの述語内でサポートされています。
+
+- `Contains`
+- `StartsWith`
+- `EndsWith`
+
+サポートされていない LINQ メソッドは、サポートされているメソッドの後に使用できます。例:
+
+```c#
+_myDbContext.Statements
+ .Where(stat => stat.OrderId == "1") // Will be executed remotely on the cluster.
+ .Distinct() // Will be executed locally in the app.
+ .Where(stat => stat.ItemId < 5); // Will be executed locally.
+```
+
+:::note
+
+`Take` または `First`/`FirstOrDefault` の前に `Skip` が指定されている場合、`Skip` に渡される数値が SQL クエリの `LIMIT` 数値に追加されます。`Skip` 自体では、結果の SQL クエリは変更されません。
+
+:::
+
+## `ScalarDbSet{T}` オブジェクトに対して LINQ を使用する場合の制限
+
+- すべてのメソッド呼び出しは `Select` 内でサポートされます。例:
+
+```c#
+.Select(stat => convertToSomething(stat.ItemId))
+//...
+.Select(stat => stat.ItemId * getSomeNumber())
+```
+
+- クエリオブジェクトに対する呼び出しを除くメソッド呼び出しは、`Where` および `First`/`FirstOrDefault` 内でもサポートされます。例:
+
+```c#
+.Where(stat => stat.ItemId == getItemId()) // is OK
+//...
+.Where(stat => stat.ItemId.ToString() == "1") // is not supported
+```
+
+- すべてのメソッド呼び出しは、`Join` および `GroupJoin` の結果選択ラムダ内でサポートされます。例:
+
+```c#
+.Join(_myDbContext.Items,
+ stat => stat.ItemId,
+ item => item.Id,
+ (stat, item) => new { ItemName = convertToSomething(item.Name),
+ ItemCount = stat.Count.ToString() })
+```
+
+- `Join` および `GroupJoin` のキー選択ラムダ内では、メソッド呼び出しはサポートされていません。
+- カスタム等価比較子はサポートされていません。`Join` および `GroupJoin` メソッドの `comparer` 引数は、引数が渡された場合は無視されます。
+- `DefaultIfEmpty` メソッドを使用して左外部結合を実行する場合を除き、1 つのクエリ内で複数の `from` を直接使用することはサポートされていません。後続の各 `from` は、個別のクエリと見なされます。
+
+```c#
+var firstQuery = from stat in _myDbContext.Statements
+ where stat.Count > 2
+ select new { stat.Count };
+
+var secondQuery = from item in _myDbContext.Items
+ where item.Price > 6
+ select new { item.Name };
+
+var finalQuery = from first in firstQuery
+ from second in secondQuery
+ select new { first.Count, second.Name };
+
+// 1. firstQuery will be executed against the cluster.
+// 2. secondQuery will be executed against the cluster for each object (row) from 1.
+// 3. finalQuery will be executed locally with the results from 1 and 2.
+var result = finalQuery.ToArray();
+```
+
+- メソッド呼び出しは、`OrderBy`/`OrderByDescending` または `ThenBy`/`ThenByDescending` 内ではサポートされていません。
+- `Where` および `First`/`FirstOrDefault` 内では、単一の文字列引数を持つ `Contains`、`StartsWith`、および `EndsWith` メソッドのオーバーロードのみがサポートされています。
+
+## `ScalarDbContext` を使用してクラスター内のデータを変更する
+
+`ScalarDbContext` から継承されたクラスのプロパティを使用して、データを変更できます。
+
+### `AddAsync` メソッドを使用して新しいオブジェクトを追加します
+
+```c#
+var statement = new Statement
+ {
+ OrderId = "2",
+ ItemId = 4,
+ Count = 8
+ };
+await _myDbContext.Statements.AddAsync(statement);
+```
+
+### `UpdateAsync` メソッドを使用してオブジェクトを更新する
+
+```c#
+var statement = _myDbContext.Statements.First(stat => stat.Id == 1);
+
+// ...
+
+statement.Count = 10;
+await _myDbContext.Statements.UpdateAsync(statement);
+```
+
+### `RemoveAsync` メソッドを使用してオブジェクトを削除する
+
+```c#
+var statement = _myDbContext.Statements.First(stat => stat.Id == 1);
+
+// ...
+
+await _myDbContext.Statements.RemoveAsync(statement);
+```
+
+## トランザクションの管理
+
+LINQ クエリと `AddAsync`、`UpdateAsync`、および `RemoveAsync` メソッドは、明示的に開始されたトランザクションなしで実行できます。ただし、1 つのトランザクションの一部として複数のクエリとメソッドを実行するには、トランザクションを明示的に開始してコミットする必要があります。`ScalarDbContext` は、通常のトランザクションと、ScalarDB の 2 フェーズコミットインターフェイスを使用したトランザクションの両方をサポートします。
+
+### 新しいトランザクションを開始する
+
+```c#
+await _myDbContext.BeginTransactionAsync();
+```
+
+### 2 フェーズコミットインターフェースで新しいトランザクションを開始する
+
+```c#
+await _myDbContext.BeginTwoPhaseCommitTransactionAsync();
+```
+
+### 現在アクティブなトランザクションのIDを取得する
+
+```c#
+var transactionId = _myDbContext.CurrentTransactionId;
+```
+
+### 2 フェーズコミットインターフェースを使用して既存のトランザクションに参加する
+
+```c#
+await _myDbContext.JoinTwoPhaseCommitTransactionAsync(transactionId);
+```
+
+### 既存のトランザクションを再開する
+
+```c#
+await _myDbContext.ResumeTransaction(transactionId);
+```
+
+### 2 フェーズコミットインターフェースを使用して既存のトランザクションを再開する
+
+```c#
+await _myDbContext.ResumeTwoPhaseCommitTransaction(transactionId);
+```
+
+:::note
+
+`ResumeTransaction`/`ResumeTwoPhaseCommitTransaction` メソッドには非同期バージョンがありません。これは、クラスターを照会せずに `ScalarDbContext` 継承オブジェクト内のトランザクションデータを初期化するだけだからです。このため、間違った ID を使用してトランザクションを再開する可能性があります。
+
+:::
+
+### トランザクションをコミットする(通常または 2 フェーズコミット)
+
+```c#
+await _myDbContext.CommitTransactionAsync();
+```
+
+### トランザクションをロールバックする(通常または 2 フェーズコミット)
+
+```c#
+await _myDbContext.RollbackTransactionAsync();
+```
+
+### コミット用の 2 フェーズコミットインターフェースを使用してトランザクションを準備する
+
+```c#
+await _myDbContext.PrepareTransactionAsync();
+```
+
+### コミット前に 2 フェーズコミットインターフェースでトランザクションを検証する
+
+```c#
+await _myDbContext.ValidateTransactionAsync();
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-scalardb-tables-as-csharp-classes.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-scalardb-tables-as-csharp-classes.mdx
new file mode 100644
index 00000000..7a5fb2cc
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-scalardb-tables-as-csharp-classes.mdx
@@ -0,0 +1,207 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK で C# クラスとしてテーブルをはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ScalarDB テーブルを C# オブジェクトとして抽象化することで、クラスターにアクセスするコードの作成に役立ちます。クラスター内のテーブルを表すクラスを定義すると、クラスターをクエリするときに列名やその型が混同されないようにすることができます。さらに、テーブルの構造が変更された場合は、IDE のリファクタリング機能を使用してコードに変更を適用できます。
+
+:::note
+
+次の例のように非同期メソッドを使用することをお勧めしますが、代わりに同期メソッドを使用することもできます。
+
+:::
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を、使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## すべての ScalarDB テーブルのクラスを作成する
+
+ScalarDB テーブルを C# オブジェクトとして操作するには、使用するテーブルごとにクラスを作成する必要があります。例:
+
+```c#
+using System.ComponentModel.DataAnnotations.Schema;
+using ScalarDB.Client.DataAnnotations;
+
+// ...
+
+[Table("ns.statements")]
+public class Statement
+{
+ [PartitionKey]
+ [Column("order_id", Order = 0)]
+ public string OrderId { get; set; } = String.Empty;
+
+ [ClusteringKey]
+ [Column("item_id", Order = 1)]
+ public int ItemId { get; set; }
+
+ [Column("count", Order = 2)]
+ public int Count { get; set; }
+}
+```
+
+プロパティに使用する型の詳細については、[ScalarDB 列型と .NET 型間の変換方法](common-reference.mdx#scalardb-列型と-net-型間の変換方法)を参照してください。
+
+## CRUD 操作を実行する
+
+各テーブルのクラスを作成した後、`ITransactionCrudOperable` の汎用 `GetAsync`、`ScanAsync`、`InsertAsync`、`UpdateAsync`、`DeleteAsync`、`UpsertAsync`、または `MutateAsync` メソッドを使用して、クラスをオブジェクトとして使用できます。
+
+これらの汎用メソッドを使用するには、`using` セクションに次の名前空間を追加します。
+
+```c#
+using ScalarDB.Client.Extensions;
+```
+
+### `GetAsync` メソッドを使用して 1 つのオブジェクトを取得します
+
+```c#
+var keys = new Dictionary
+ {
+ { nameof(Statement.OrderId), "1" }
+ };
+var statement = await transaction.GetAsync(keys);
+
+Console.WriteLine($"ItemId: {statement.ItemId}, Count: {statement.Count}");
+```
+
+### `ScanAsync` メソッドを使用して複数のオブジェクトを取得する
+
+```c#
+var startKeys = new Dictionary
+ {
+ { nameof(Statement.OrderId), "1" },
+ { nameof(Statement.ItemId), 3 }
+ };
+var endKeys = new Dictionary
+ {
+ { nameof(Statement.ItemId), 6}
+ };
+
+await foreach (var s in transaction.ScanAsync(startKeys, endKeys))
+ Console.WriteLine($"ItemId: {s.ItemId}, Count: {s.Count}");
+```
+
+:::note
+
+`IAsyncEnumerable` で LINQ メソッドを使用するには、[System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async/) パッケージをインストールします。
+
+:::
+
+### `InsertAsync` メソッドを使用して新しいオブジェクトを挿入します
+
+```c#
+var statement = new Statement
+ {
+ OrderId = "2",
+ ItemId = 4,
+ Count = 8
+ };
+await transaction.InsertAsync(statement);
+```
+
+### `UpdateAsync` メソッドを使用してオブジェクトを更新する
+
+```c#
+// ...
+statement.ItemId = 4;
+statement.Count = 8;
+
+await transaction.UpdateAsync(statement);
+```
+
+### `DeleteAsync` メソッドを使用してオブジェクトを削除する
+
+```c#
+// ...
+await transaction.DeleteAsync(statement);
+```
+
+### `UpsertAsync` メソッドを使用してオブジェクトをUPSERTする
+
+```c#
+var statement = new Statement
+ {
+ OrderId = "2",
+ ItemId = 4,
+ Count = 8
+ };
+await transaction.UpsertAsync(statement);
+```
+
+### `MutateAsync` メソッドを使用して複数のオブジェクトを一度にUPSERTおよび削除する
+
+```c#
+var statement = new Statement
+ {
+ OrderId = "2",
+ ItemId = 4,
+ Count = 16
+ };
+
+// ...
+
+await transaction.MutateAsync(objectsToUpsert: new[] { statement },
+ objectsToDelete: new[] { statement2 });
+```
+
+:::note
+
+`UpdateAsync`、`DeleteAsync`、`UpsertAsync`、または `MutateAsync` メソッドを使用してオブジェクトを変更するには、まず `GetAsync` または `ScanAsync` メソッドを使用してオブジェクトを取得する必要があります。
+
+:::
+
+## Administrative API を使用する
+
+C# オブジェクトも Administrative API で使用できます。汎用 Administrative API メソッドを使用するには、次の名前空間を `using` セクションに追加します。
+
+```c#
+using ScalarDB.Client.Extensions;
+```
+
+### 新しい名前空間を作成する
+
+```c#
+await admin.CreateNamespaceAsync();
+```
+
+### 既存の名前空間を削除する
+
+```c#
+await admin.DropNamespaceAsync();
+```
+
+### 名前空間が存在するかどうかを確認する
+
+```c#
+var namespaceExists = await admin.IsNamespacePresentAsync();
+```
+
+### 新しいテーブルを作成する
+
+```c#
+await admin.CreateTableAsync();
+```
+
+### 既存のテーブルを削除する
+
+```c#
+await admin.DropTableAsync();
+```
+
+### テーブルが存在するかどうかを確認する
+
+```c#
+var tableExists = await admin.IsTablePresentAsync();
+```
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-two-phase-commit-transactions.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-two-phase-commit-transactions.mdx
new file mode 100644
index 00000000..03d6bbb6
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/getting-started-with-two-phase-commit-transactions.mdx
@@ -0,0 +1,145 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK の 2 フェーズコミットインターフェイスを使用した分散トランザクションをはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK は、ScalarDB の 2 フェーズコミットインターフェイスを使用したトランザクションをサポートします。SDK には、クラスター内の通信を強化するためのトランザクションとマネージャーの抽象化が含まれています。
+
+:::note
+
+次の例のように非同期メソッドを使用することをお勧めしますが、代わりに同期メソッドを使用することもできます。
+
+:::
+
+## 2 フェーズコミットインターフェースを使用したトランザクションについて
+
+SDK を使用すると、複数のアプリケーションにまたがる 2 フェーズコミットインターフェースを使用したトランザクションを実行できます。たとえば、複数のマイクロサービスがある場合、それぞれのマイクロサービスにトランザクションマネージャーを作成し、それらのマイクロサービスにまたがるトランザクションを実行できます。
+
+2 フェーズコミットインターフェースを使用したトランザクションには、コーディネーターと参加者の 2 つのロールがあり、これらが協力して 1 つのトランザクションを実行します。
+
+コーディネータープロセスは最初にトランザクションを開始し、トランザクションの ID をすべての参加者に送信し、参加者プロセスがトランザクションに参加します。 CRUD または SQL 操作を実行した後、コーディネータープロセスと参加者プロセスは 2 フェーズインターフェースを使用してトランザクションをコミットします。
+
+## SDK をインストールする
+
+ScalarDB Cluster と同じメジャーバージョンとマイナーバージョンの [SDK](https://www.nuget.org/packages/ScalarDB.Client) を .NET プロジェクトにインストールします。組み込みの NuGet パッケージマネージャーを使用してこれを行うことができます。`.` を、使用しているバージョンに置き換えます。
+
+```console
+dotnet add package ScalarDB.Client --version '..*'
+```
+
+## 設定ファイルを作成する
+
+`scalardb-options.json` ファイルを作成し、次の内容を追加します。`` を FQDN または IP アドレスに、`` をクラスターのポート番号 (デフォルトでは `60053`) に置き換えます。
+
+```json
+{
+ "ScalarDbOptions": {
+ "Address": "http://:",
+ "HopLimit": 10
+ }
+}
+```
+
+設定ファイルやクライアントを設定するその他の方法の詳細については、[クライアント設定](common-reference.mdx#クライアント設定)を参照してください。
+
+## トランザクションマネージャーを取得します (コーディネータと参加者用)
+
+2 フェーズコミットインターフェイスを使用した分散トランザクションには、トランザクションマネージャーを取得する必要があります。トランザクションマネージャーを取得するには、次のように `TransactionFactory` を使用します。
+
+```c#
+// Pass the path to the settings file created in the previous step.
+var factory = TransactionFactory.Create("scalardb-options.json");
+
+using var manager = factory.GetTwoPhaseCommitTransactionManager();
+```
+
+あるいは、次のトランザクションマネージャーを指定して、2 フェーズコミットインターフェイスを使用したトランザクションに CRUD 操作の代わりに SQL を使用することもできます。
+
+```c#
+using var manager = factory.GetSqlTwoPhaseCommitTransactionManager();
+```
+
+## トランザクションを開始する (コーディネータ用)
+
+次のように、コーディネータの 2 フェーズコミットインターフェイスを使用してトランザクションを開始できます。
+
+```c#
+var transaction = await manager.BeginAsync();
+```
+
+開始されたトランザクションの ID は、次のコードで取得できます。
+
+```c#
+var transactionId = transaction.Id;
+```
+
+## トランザクションに参加する (参加者向け)
+
+参加者の 2 フェーズコミットインターフェイスを使用して、次のようにトランザクションに参加できます。
+
+```c#
+var transaction = await manager.JoinAsync(transactionId);
+```
+
+## トランザクションを再開する (コーディネータと参加者用)
+
+通常、2 フェーズコミットインターフェイスを使用したトランザクションには、複数の要求と応答の交換が含まれます。以前の要求で開始または参加したトランザクションを操作する必要がある場合は、次のようにしてそのトランザクションを再開できます。
+
+```c#
+var transaction = manager.Resume(transactionId);
+```
+
+:::note
+
+`Resume` メソッドはトランザクションオブジェクトを作成するだけなので、非同期バージョンはありません。このため、間違った ID を使用してトランザクションを再開する可能性があります。
+
+:::
+
+## トランザクションをロールバックする
+
+トランザクションがコミットに失敗した場合は、次のようにトランザクションをロールバックできます。
+
+```c#
+await transaction.RollbackAsync();
+```
+
+## トランザクションをコミットする (コーディネータと参加者用)
+
+CRUD または SQL 操作を完了したら、トランザクションをコミットする必要があります。ただし、2 フェーズコミットインターフェイスを使用したトランザクションの場合は、まずコーディネータとすべての参加者でトランザクションを準備する必要があります。
+
+```c#
+await transaction.PrepareAsync();
+```
+
+次に、同時実行制御プロトコルに応じて、次のようにコーディネーターとすべての参加者でトランザクションを検証する必要がある場合があります。
+
+```c#
+await transaction.ValidateAsync();
+```
+
+最後に、次のようにしてコーディネーターとすべての参加者にトランザクションをコミットできます。
+
+```c#
+await transaction.CommitAsync();
+```
+
+コーディネータまたは参加者のいずれかがトランザクションの準備または検証に失敗した場合は、コーディネータとすべての参加者で `RollbackAsync` を呼び出す必要があります。
+
+また、コーディネータとすべての参加者がトランザクションのコミットに失敗した場合は、コーディネータとすべての参加者で `RollbackAsync` を呼び出す必要があります。
+
+ただし、コーディネータまたは一部の参加者のみがトランザクションのコミットに失敗した場合は、コーディネータまたはいずれかの参加者がトランザクションのコミットに成功している限り、トランザクションはコミットされたとみなされます。
+
+## CRUD 操作を実行する
+
+トランザクションの 2 フェーズコミットインターフェイスには、通常のトランザクションと同じ CRUD 操作メソッドがあります。詳細については、[CRUD 操作を実行する](getting-started-with-distributed-transactions.mdx#crud-操作を実行する) を参照してください。
+
+## SQL ステートメントを実行する
+
+SQL トランザクションの 2 フェーズコミットインターフェイスには、通常の SQL トランザクションと同じ SQL クエリを実行するメソッドがあります。詳細については、[SQL クエリを実行する](getting-started-with-distributed-sql-transactions.mdx#sql-クエリを実行する)を参照してください.
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/index.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/index.mdx
new file mode 100644
index 00000000..29e08a9a
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster-dotnet-client-sdk/index.mdx
@@ -0,0 +1,25 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster .NET Client SDK の概要
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster .NET Client SDK を使用すると、アプリケーションは gRPC を使用して ScalarDB Cluster に接続できるようになります。
+
+ScalarDB Cluster .NET Client SDK を使用するには、次の入門ガイドを参照してください。
+
+* [分散トランザクションをはじめよう](getting-started-with-distributed-transactions.mdx)
+* [分散 SQL トランザクションをはじめよう](getting-started-with-distributed-sql-transactions.mdx)
+* [Administrative API をはじめよう](getting-started-with-admin-api.mdx)
+* [C# クラスとしての ScalarDB テーブルをはじめよう](getting-started-with-scalardb-tables-as-csharp-classes.mdx)
+* [ASP.NET Core と依存性注入をはじめよう](getting-started-with-aspnet-and-di.mdx)
+* [LINQ をはじめよう](getting-started-with-linq.mdx)
+* [2 フェーズコミットインターフェイスを使用した分散トランザクションをはじめよう](getting-started-with-two-phase-commit-transactions.mdx)
+* [認証と認可をはじめよう](getting-started-with-auth.mdx)
+* [例外処理](exception-handling.mdx)
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/compatibility.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/compatibility.mdx
new file mode 100644
index 00000000..01d53eeb
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/compatibility.mdx
@@ -0,0 +1,42 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster 互換性マトリックス
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このドキュメントでは、クライアント SDK バージョン間の ScalarDB Cluster バージョンの互換性を示します。
+
+## ScalarDB Cluster とクライアント SDK の互換性
+
+| ScalarDB Cluster バージョン | ScalarDB Cluster Java Client SDK バージョン | ScalarDB Cluster .NET Client SDK バージョン |
+|:-----------------------|:---------------------------------------|:---------------------------------------|
+| 3.14 | 3.9 - 3.14 | 3.12* - 3.13 |
+| 3.13 | 3.9 - 3.13 | 3.12* - 3.13 |
+| 3.12 | 3.9 - 3.12 | 3.12* |
+| 3.11 | 3.9 - 3.11 | サポート対象外 |
+| 3.10 | 3.9 - 3.10 | サポート対象外 |
+| 3.9 | 3.9 | サポート対象外 |
+
+\* このバージョンはプライベートプレビュー段階であるため、将来のバージョンでは下位互換性のない更新が行われる可能性があります。
+
+## バージョンスキューポリシー
+
+:::note
+
+バージョンは `x.y.z` として表されます。`x` はメジャーバージョン、`y` はマイナーバージョン、`z` はパッチバージョンを表します。この形式は [セマンティックバージョニング](https://semver.org/) に従います。
+
+:::
+
+- ScalarDB Cluster とクライアント SDK の **メジャー** バージョンが異なる場合、それらは **互換性がない** ため、**サポートされていません**。
+- ScalarDB Cluster とクライアント SDK の **メジャー** バージョンが同じで、**マイナー** バージョンが異なる場合、ScalarDB Cluster のバージョンはクライアント SDK バージョン以上である必要があります。例:
+ - **サポート対象:** ScalarDB Cluster 3.13 とクライアント SDK 3.11 の組み合わせ
+ - **サポート対象外:** ScalarDB Cluster 3.11 とクライアント SDK 3.13 の組み合わせ
+- **メジャー** バージョンと **マイナー** バージョンが同じ場合、ScalarDB Cluster とクライアント SDK 間で異なる **パッチ** バージョンを使用できます。例:
+ - **サポート対象:** ScalarDB Cluster 3.13.2 とクライアント SDK 3.13.0 の組み合わせ
+ - **サポート対象:** ScalarDB Cluster 3.13.0 とクライアント SDK 3.13.2 の組み合わせ
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx
new file mode 100644
index 00000000..f0418cff
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/developer-guide-for-scalardb-cluster-with-java-api.mdx
@@ -0,0 +1,302 @@
+---
+tags:
+ - Enterprise Standard
+ - Enterprise Premium
+---
+
+# Java API を使用した ScalarDB Cluster の開発者ガイド
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster は、アプリケーションを開発するための Java API を提供します。このドキュメントでは、Java API の使用方法を説明します。
+
+## ビルドに ScalarDB Cluster Java Client SDK を追加する
+
+ScalarDB Cluster Java Client SDK は、[Maven Central Repository](https://mvnrepository.com/artifact/com.scalar-labs/scalardb-cluster-java-client-sdk) で入手できます。
+
+Gradle を使用して ScalarDB Cluster Java Client SDK への依存関係を追加するには、以下を使用します。
+
+```gradle
+dependencies {
+ implementation 'com.scalar-labs:scalardb-cluster-java-client-sdk:3.13.1'
+}
+```
+
+Maven を使用して依存関係を追加するには、以下を使用します。
+
+```xml
+
+ com.scalar-labs
+ scalardb-cluster-java-client-sdk
+ 3.13.1
+
+```
+
+## クライアントモード
+
+ScalarDB Cluster Java Client SDK は、`indirect` と `direct-kubernetes` の 2 つのクライアントモードをサポートしています。以下では、クライアントモードについて説明します。
+
+### `indirect` クライアントモード
+
+このモードでは、単にリクエストを任意のクラスターノードに送信します (通常は Envoy などのロードバランサー経由)。リクエストを受信したクラスターノードは、トランザクション状態を持つ適切なクラスターノードにリクエストをルーティングします。
+
+
+
+このモードの利点は、クライアントを軽量に保てることです。
+欠点は、正しいクラスターノードに到達するために追加のホップが必要になり、パフォーマンスに影響する可能性があることです。
+
+アプリケーションが別の Kubernetes クラスターで実行されていて、アプリケーションが Kubernetes API と各クラスターノードにアクセスできない場合でも、この接続モードを使用できます。
+アプリケーションが ScalarDB Cluster ノードと同じ Kubernetes クラスターで実行されている場合は、`direct-kubernetes` クライアントモードを使用できます。
+
+### `direct-kubernetes` クライアントモード
+
+このモードでは、クライアントはメンバーシップロジック (Kubernetes API を使用) と分散ロジック (コンシステントハッシュアルゴリズム) を使用して、トランザクション状態を持つ適切なクラスターノードを見つけます。次に、クライアントはクラスターノードに直接リクエストを送信します。
+
+
+
+このモードの利点は、適切なクラスターノードに到達するためのホップ数を減らすことができるため、パフォーマンスが向上することです。このモードの欠点は、クライアントにメンバーシップロジックとリクエストルーティングロジックが必要なため、クライアントをファットにする必要があることです。
+
+この接続モードは Kubernetes API と各クラスターノードにアクセスする必要があるため、アプリケーションが ScalarDB Cluster ノードと同じ Kubernetes クラスターで実行されている場合にのみ、この接続モードを使用できます。アプリケーションが別の Kubernetes クラスターで実行されている場合は、`indirect` クライアントモードを使用します。
+
+`direct-kubernetes` クライアントモードで Kubernetes にアプリケーションをデプロイする方法の詳細については、[`direct-kubernetes` モードを使用してクライアントアプリケーションを Kubernetes にデプロイする](../helm-charts/how-to-deploy-scalardb-cluster.mdx#direct-kubernetes-モードを使用してクライアント-アプリケーションを-kubernetes-にデプロイします) を参照してください。
+
+## ScalarDB Cluster Java API
+
+ScalarDB Cluster Java Client SDK は、アプリケーションが ScalarDB Cluster にアクセスするための Java API を提供します。次の図は、ScalarDB Cluster Java API のアーキテクチャを示しています。
+
+```
+ +-----------------------+
+ | ユーザー/アプリケーション |
+ +-----------------------+
+ ↓ Java API
+ +--------------+
+ | ScalarDB API |
+ +--------------+
+ ↓ gRPC
+ +------------------+
+ | ScalarDB Cluster |
+ +------------------+
+ ↓ DB ベンダー固有のプロトコル
+ +----+
+ | DB |
+ +----+
+```
+
+ScalarDB Cluster Java API の使用は、クライアント構成と Schema Loader が異なることを除いて、ScalarDB Java API の使用とほぼ同じです。詳細については、[ScalarDB Java API ガイド](../api-guide.mdx) を参照してください。
+
+次のセクションでは、ScalarDB Cluster Java API とクラスター用 Schema Loader のクライアント構成について説明します。
+
+### クライアント構成
+
+次の表は、ScalarDB Cluster Java API のクライアント構成を示しています。
+
+| 名前 | 説明 | デフォルト |
+|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------|
+| `scalar.db.transaction_manager` | `cluster` を指定する必要があります。 | - |
+| `scalar.db.contact_points` | クラスターの連絡先。`indirect` クライアントモードを使用する場合は、`indirect:` の形式を使用して、クラスターノードの前にあるロードバランサーの IP アドレスを指定します。`direct-kubernetes` クライアントモードを使用する場合は、`direct-kubernetes:/` または単に `direct-kubernetes:` の形式を使用して、名前空間名 (オプション) と [エンドポイントリソース](https://kubernetes.io/docs/concepts/services-networking/service/#endpoints) の名前を指定して、メンバーシップ情報を取得します。名前空間名を指定しない場合、クライアントは `default` 名前空間を使用します。 | |
+| `scalar.db.contact_port` | 連絡先のポート番号。 | `60053` |
+| `scalar.db.cluster.grpc.deadline_duration_millis` | gRPC の期限期間(ミリ秒単位)。 | `60000` (60 秒) |
+| `scalar.db.cluster.grpc.max_inbound_message_size` | 単一の gRPC フレームに許可される最大メッセージサイズ。 | gRPCのデフォルト値 |
+| `scalar.db.cluster.grpc.max_inbound_metadata_size` | 受信できるメタデータの最大サイズ。 | gRPCのデフォルト値 |
+
+たとえば、`indirect` クライアントモードを使用し、ロードバランサーの IP アドレスが `192.168.10.1` の場合、クライアントを次のように構成できます。
+
+```properties
+scalar.db.transaction_manager=cluster
+scalar.db.contact_points=indirect:192.168.10.1
+```
+
+または、エンドポイントの名前空間を `ns`、エンドポイント名を `scalardb-cluster` として `direct-kubernetes` クライアントモードを使用する場合は、次のようにクライアントを構成できます。
+
+```properties
+scalar.db.transaction_manager=cluster
+scalar.db.contact_points=direct-kubernetes:ns/scalardb-cluster
+```
+
+### クラスター用 Schema Loader
+
+ScalarDB Cluster 経由でスキーマをロードするには、専用の ScalarDB Cluster 用 Schema Loader (クラスター用 Schema Loader) を使用する必要があります。クラスター用Schema Loader の使用方法は、JAR ファイルの名前が異なることを除いて、[ScalarDB Schema Loader](../schema-loader.mdx) の使用方法と基本的に同じです。クラスター用 Schema Loader は、[ScalarDB リリース](https://github.com/scalar-labs/scalardb/releases/tag/v3.13.1) からダウンロードできます。JAR ファイルをダウンロードしたら、次のコマンドでクラスター用 Schema Loader を実行できます。
+
+```console
+java -jar scalardb-cluster-schema-loader-3.13.1-all.jar --config -f --coordinator
+```
+
+## ScalarDB Cluster SQL
+
+ScalarDB Cluster SQL には、次のように Java の ScalarDB 用 JDBC および Spring Data JDBC を介してアクセスできます。
+
+```
+ +----------------------------------------------+
+ | ユーザー/アプリケーション |
+ +----------------------------------------------+
+ ↓ ↓ Java API
+Java API ↓ +-------------------------------+
+ (JDBC) ↓ | Spring Data JDBC for ScalarDB |
+ ↓ +-------------------------------+
++----------------------------------------------+
+| ScalarDB JDBC (ScalarDB SQL) |
++----------------------------------------------+
+ ↓ gRPC
+ +----------------------+
+ | ScalarDB Cluster SQL |
+ +----------------------+
+ ↓ DB ベンダー固有のプロトコル
+ +----+
+ | DB |
+ +----+
+```
+
+このセクションでは、JDBC 経由で ScalarDB Cluster SQL を使用する方法と、Spring Data JDBC for ScalarDB を使用する方法について説明します。
+
+### JDBC 経由の ScalarDB Cluster SQL
+
+JDBC 経由での ScalarDB Cluster SQL の使用は、プロジェクトに JDBC ドライバーを追加する方法を除いて、[ScalarDB JDBC](../scalardb-sql/jdbc-guide.mdx) を使用する場合とほぼ同じです。
+
+[ビルドに ScalarDB Cluster Java Client SDK を追加する](#add-scalardb-cluster-java-client-sdk-to-your-build) で説明されているように ScalarDB Cluster Java Client SDK を追加することに加えて、プロジェクトに次の依存関係を追加する必要があります。
+
+Gradle を使用して ScalarDB Cluster JDBC ドライバーへの依存関係を追加するには、以下を使用します。
+
+```gradle
+dependencies {
+ implementation 'com.scalar-labs:scalardb-sql-jdbc:3.13.1'
+ implementation 'com.scalar-labs:scalardb-cluster-java-client-sdk:3.13.1'
+}
+```
+
+Maven を使用して依存関係を追加するには、以下を使用します。
+
+```xml
+
+
+ com.scalar-labs
+ scalardb-sql-jdbc
+ 3.13.1
+
+
+ com.scalar-labs
+ scalardb-cluster-java-client-sdk
+ 3.13.1
+
+
+```
+
+それ以外は、JDBC 経由で ScalarDB Cluster SQL を使用することは、ScalarDB JDBC を使用することと同じです。ScalarDB JDBC の詳細については、[ScalarDB JDBC ガイド](../scalardb-sql/jdbc-guide.mdx) を参照してください。
+
+### Spring Data JDBC for ScalarDB 経由の ScalarDB Cluster SQL
+
+JDBC 経由の ScalarDB Cluster SQL と同様に、Spring Data JDBC for ScalarDB 経由の ScalarDB Cluster SQL を使用することは、プロジェクトへの追加方法を除いて、[Spring Data JDBC for ScalarDB](../scalardb-sql/spring-data-guide.mdx) を使用することとほぼ同じです。
+
+[ScalarDB Cluster Java Client SDK をビルドに追加する](#add-scalardb-cluster-java-client-sdk-to-your-build) で説明されているように ScalarDB Cluster Java Client SDK を追加することに加えて、プロジェクトに次の依存関係を追加する必要があります:
+
+Gradle を使用して依存関係を追加するには、以下を使用します:
+
+```gradle
+dependencies {
+ implementation 'com.scalar-labs:scalardb-sql-spring-data:3.13.1'
+ implementation 'com.scalar-labs:scalardb-cluster-java-client-sdk:3.13.1'
+}
+```
+
+Maven を使用して依存関係を追加するには、以下を使用します。
+
+```xml
+
+
+ com.scalar-labs
+ scalardb-sql-spring-data
+ 3.13.1
+
+
+ com.scalar-labs
+ scalardb-cluster-java-client-sdk
+ 3.13.1
+
+
+```
+
+それ以外では、Spring Data JDBC for ScalarDB 経由で ScalarDB Cluster SQL を使用することは、Spring Data JDBC for ScalarDB を使用することと同じです。Spring Data JDBC for ScalarDB の詳細については、[Spring Data JDBC for ScalarDB ガイド](../scalardb-sql/spring-data-guide.mdx) を参照してください。
+
+### ScalarDB Cluster SQL クライアント構成
+
+次の表は、ScalarDB Cluster SQL の構成を示しています。
+
+| 名前 | 説明 | デフォルト |
+|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------|
+| `scalar.db.sql.connection_mode` | `cluster` を指定する必要があります。 | - |
+| `scalar.db.sql.cluster_mode.contact_points` | クラスターの連絡先。`indirect` クライアントモードを使用する場合は、`indirect:` の形式を使用して、クラスターノードの前にあるロードバランサーの IP アドレスを指定します。`direct-kubernetes` クライアントモードを使用する場合は、`direct-kubernetes:/` または単に `direct-kubernetes:` の形式を使用して、名前空間名 (オプション) と [エンドポイントリソース](https://kubernetes.io/docs/concepts/services-networking/service/#endpoints) の名前を指定して、メンバーシップ情報を取得します。名前空間名を指定しない場合、クライアントは `default` 名前空間を使用します。 | |
+| `scalar.db.sql.cluster_mode.contact_port` | 連絡先のポート番号。 | `60053` |
+| `scalar.db.sql.default_transaction_mode` | デフォルトのトランザクションモード。`TRANSACTION` または `TWO_PHASE_COMMIT_TRANSACTION` を設定できます。 | `TRANSACTION` |
+| `scalar.db.sql.default_namespace_name` | デフォルトの名前空間名。SQL ステートメントで名前空間名を指定しない場合は、この値が使用されます。 | |
+| `scalar.db.cluster.grpc.deadline_duration_millis` | gRPC の期限期間(ミリ秒単位)。 | `60000` (60 秒) |
+| `scalar.db.cluster.grpc.max_inbound_message_size` | 単一の gRPC フレームに許可される最大メッセージサイズ。 | gRPCのデフォルト値 |
+| `scalar.db.cluster.grpc.max_inbound_metadata_size` | 受信できるメタデータの最大サイズ。 | gRPCのデフォルト値 |
+
+たとえば、`indirect` クライアントモードを使用し、ロードバランサーの IP アドレスが `192.168.10.1` の場合、クライアントを次のように構成できます。
+
+```properties
+scalar.db.sql.connection_mode=cluster
+scalar.db.sql.cluster_mode.contact_points=indirect:192.168.10.1
+```
+
+または、エンドポイントの名前空間を `ns`、エンドポイント名を `scalardb-cluster` として `direct-kubernetes` クライアントモードを使用する場合は、次のようにクライアントを構成できます。
+
+```properties
+scalar.db.sql.connection_mode=cluster
+scalar.db.sql.cluster_mode.contact_points=direct-kubernetes:ns/scalardb-cluster
+```
+
+ScalarDB JDBC の構成方法の詳細については、[JDBC 接続 URL](../scalardb-sql/jdbc-guide.mdx#jdbc-接続-url) を参照してください。
+
+Spring Data JDBC for ScalarDB の構成方法の詳細については、[構成](../scalardb-sql/spring-data-guide.mdx#構成) を参照してください。
+
+### SQL CLI
+
+他の SQL データベースと同様に、ScalarDB SQL にも、コマンドラインシェルで対話的に SQL ステートメントを発行できる CLI ツールが用意されています。
+
+Cluster 用の SQL CLI は、[ScalarDB リリース](https://github.com/scalar-labs/scalardb/releases/tag/v3.13.1) からダウンロードできます。JAR ファイルをダウンロードしたら、次のコマンドで SQL CLI を実行できます。
+
+```console
+java -jar scalardb-cluster-sql-cli-3.13.1-all.jar --config
+```
+
+#### 使用方法
+
+CLI の使用方法は、次のように `-h` オプションを使用して確認できます。
+
+```console
+java -jar scalardb-cluster-sql-cli-3.13.1-all.jar -h
+Usage: scalardb-sql-cli [-hs] -c=PROPERTIES_FILE [-e=COMMAND] [-f=FILE]
+ [-l=LOG_FILE] [-o=] [-p=PASSWORD]
+ [-u=USERNAME]
+Starts ScalarDB SQL CLI.
+ -c, --config=PROPERTIES_FILE
+ A configuration file in properties format.
+ -e, --execute=COMMAND A command to execute.
+ -f, --file=FILE A script file to execute.
+ -h, --help Display this help message.
+ -l, --log=LOG_FILE A file to write output.
+ -o, --output-format=
+ Format mode for result display. You can specify
+ table/vertical/csv/tsv/xmlattrs/xmlelements/json/a
+ nsiconsole.
+ -p, --password=PASSWORD A password to connect.
+ -s, --silent Reduce the amount of informational messages
+ displayed.
+ -u, --username=USERNAME A username to connect.
+```
+
+## 参考資料
+
+Java 以外のプログラミング言語で ScalarDB Cluster を使用する場合は、ScalarDB Cluster gRPC API を使用できます。
+ScalarDB Cluster gRPC API の詳細については、以下を参照してください。
+
+* [ScalarDB Cluster gRPC API ガイド](scalardb-cluster-grpc-api-guide.mdx)
+* [ScalarDB Cluster SQL gRPC API ガイド](scalardb-cluster-sql-grpc-api-guide.mdx)
+
+Javadocs も利用可能です:
+
+* [ScalarDB Cluster Java Client SDK](https://javadoc.io/doc/com.scalar-labs/scalardb-cluster-java-client-sdk/3.13.1/index.html)
+* [ScalarDB Cluster Common](https://javadoc.io/doc/com.scalar-labs/scalardb-cluster-common/3.13.1/index.html)
+* [ScalarDB Cluster RPC](https://javadoc.io/doc/com.scalar-labs/scalardb-cluster-rpc/3.13.1/index.html)
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-graphql.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-graphql.mdx
new file mode 100644
index 00000000..4e613e00
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-graphql.mdx
@@ -0,0 +1,324 @@
+---
+tags:
+ - Enterprise Premium
+---
+
+# ScalarDB Cluster GraphQL をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+ScalarDB Cluster gRPC API の詳細については、以下を参照してください。
+
+## 前提条件
+
+- 以下のいずれかの Java 開発キット (JDK):
+ - [Oracle JDK](https://www.oracle.com/java/technologies/downloads/) LTS バージョン (8、11、17、または 21)
+ - [OpenJDK](https://openjdk.org/install/) LTS バージョン (8、11、17、または 21)
+- Kubernetes クラスターで実行されている ScalarDB Cluster
+ - [ScalarDB Cluster をローカルにデプロイする方法](setup-scalardb-cluster-on-kubernetes-by-using-helm-chart.mdx) の手順に従ってデプロイした Kubernetes クラスターで ScalarDB Cluster が実行されていることを前提としています。
+
+## サンプルアプリケーション
+
+このチュートリアルでは、口座間で資金を移動できる電子マネーアプリケーションを作成するプロセスについて説明します。
+
+次の図は、サンプルアプリケーションのシステムアーキテクチャを示しています。
+
+```
+ +-----------------------------------------------------------------------------------------------------------------------------------------+
+ | [Kubernetes クラスター] |
+ | |
+ | [ポッド] [ポッド] [ポッド] |
+ | |
+ | +-------+ |
+ | +---> | Envoy | ---+ |
+ | | +-------+ | |
+ | | | |
+ +------------------------+ | +---------+ | +-------+ | +--------------------+ |
+ | Schema Loader | --+-> | サービス | ---+---> | Envoy | ---+---------> | サービス | ---+ |
+ | (間接クライアントモード) | | | (Envoy) | | +-------+ | | (ScalarDB Cluster) | | |
+ +------------------------+ | +---------+ | | +--------------------+ | +------------------------+ |
+ | | +-------+ | | +---> | ScalarDB Cluster ノード | ---+ |
+ | +---> | Envoy | ---+ | | +------------------------+ | |
+ | +-------+ | | | |
+ | | | +------------------------+ | +------------+ |
+ | +---+---> | ScalarDB Cluster ノード | ---+---> | PostgreSQL | |
+ | | | +------------------------+ | +------------+ |
+ | | | | |
+ | | | +------------------------+ | |
+ | | +---> | ScalarDB Cluster ノード | ---+ |
+ | | +------------------------+ |
+ +------------+ | +----------------------------+ | |
+ | ブラウザ | ------+---------------------------------------> | サービス | ---+ |
+ | (GraphiQL) | | | (ScalarDB Cluster GraphQL) | |
+ +------------+ | +----------------------------+ |
+ | |
+ +-----------------------------------------------------------------------------------------------------------------------------------------+
+```
+
+## ステップ 1. `schema.json` を作成する
+
+以下は簡単なサンプルスキーマです。
+
+`schema.json` を作成し、ファイルに次の内容を追加します。
+
+```json
+{
+ "emoney.account": {
+ "transaction": true,
+ "partition-key": [
+ "id"
+ ],
+ "clustering-key": [],
+ "columns": {
+ "id": "TEXT",
+ "balance": "INT"
+ }
+ }
+}
+```
+
+## ステップ 2. `database.properties` を作成する
+
+ScalarDB Cluster の Schema Loader 用に `database.properties` を作成する必要があります。
+
+ただし、まず Envoy (`scalardb-cluster-envoy`) のサービスリソースの `EXTERNAL-IP` アドレスを取得する必要があります。
+
+`EXTERNAL-IP` アドレスを確認するには、次のコマンドを実行します。
+
+```console
+kubectl get svc scalardb-cluster-envoy
+NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+scalardb-cluster-envoy LoadBalancer 10.105.121.51 localhost 60053:30641/TCP 16h
+```
+
+この場合、`EXTERNAL-IP` アドレスは `localhost` です。
+
+次に、`database.properties` を作成し、ファイルに次の内容を追加します。
+
+```properties
+scalar.db.transaction_manager=cluster
+scalar.db.contact_points=indirect:localhost
+```
+
+ScalarDB Cluster に接続するには、`scalar.db.transaction_manager` プロパティに `cluster` を指定する必要があります。
+
+また、このチュートリアルでは `indirect` クライアントモードを使用して Envoy のサービスリソースに接続します。
+
+クライアントモードの詳細については、[Java API を使用した ScalarDB Cluster の開発者ガイド](developer-guide-for-scalardb-cluster-with-java-api.mdx) を参照してください。
+
+## ステップ 3. スキーマをロードする
+
+ScalarDB Cluster 経由でスキーマをロードするには、ScalarDB Cluster 専用の Schema Loader (Schema Loader for Cluster) を使用する必要があります。Schema Loader for Cluster の使用方法は、JAR ファイルの名前が異なることを除いて、[Schema Loader for ScalarDB](../schema-loader.mdx) の使用方法と基本的に同じです。Cluster 用の Schema Loader は、[ScalarDB リリース](https://github.com/scalar-labs/scalardb/releases/tag/v3.13.1) からダウンロードできます。JAR ファイルをダウンロードしたら、次のコマンドで Cluster 用の Schema Loader を実行できます。
+
+```console
+java -jar scalardb-cluster-schema-loader-3.13.1-all.jar --config database.properties -f schema.json --coordinator
+```
+
+## ステップ 4. GraphiQL から操作を実行する
+
+ScalarDB Cluster では、`scalar.db.graphql.graphiql` プロパティが `true` に設定されている場合 (`true` がデフォルト値)、GraphiQL IDE が使用可能になります。
+
+ScalarDB Cluster GraphQL (`scalardb-cluster-graphql`) のサービスリソースの `EXTERNAL-IP` アドレスを取得するには、次のコマンドを実行します。
+
+```console
+kubectl get svc scalardb-cluster-graphql
+NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+scalardb-cluster-graphql LoadBalancer 10.105.74.214 localhost 8080:30514/TCP 16h
+```
+
+この場合、`EXTERNAL-IP` アドレスは `localhost`、GraphiQL IDE のエンドポイント URL は `http://localhost:8080/graphql` です。
+Web ブラウザでその URL を開くと、GraphiQL 画面が表示されます。
+
+最初のレコードを挿入してみましょう。左ペインに次のミューテーションを貼り付け、ウィンドウ上部の三角形の `Execute Query` ボタンを押します。
+
+```graphql
+mutation PutUser1 {
+ account_put(put: {key: {id: "user1"}, values: {balance: 1000}})
+}
+```
+
+ScalarDB GraphQL は常にトランザクションを使用してクエリを実行します。上記のクエリは新しいトランザクションを開始し、ScalarDB Put コマンドを実行し、実行の最後にトランザクションをコミットします。
+
+GraphQL サーバーからの次の応答が右側のペインに表示されます。
+
+```json
+{
+ "data": {
+ "account_put": true
+ }
+}
+```
+
+`"data"` フィールドには実行結果が含まれます。この応答は、ミューテーションの `account_put` フィールドが成功したことを示しています。ミューテーションの結果タイプは `Boolean!` で、操作が成功したかどうかを示します。
+
+次に、挿入したレコードを取得しましょう。左ペインの前のミューテーションの横に次のクエリを貼り付けて、`Execute Query` ボタンをクリックします。上記の `mutation PutUser1` を削除していないため、ボタンの下にプルダウンメニューが表示され、実行する操作を選択できます。 以下に示すように、`GetUser1` を選択します。
+
+```graphql
+query GetUser1 {
+ account_get(get: {key: {id: "user1"}}) {
+ account {
+ id
+ balance
+ }
+ }
+}
+```
+
+右側のペインに次の結果が表示されます。
+
+```json
+{
+ "data": {
+ "account_get": {
+ "account": {
+ "id": "user1",
+ "balance": 1000
+ }
+ }
+ }
+}
+```
+
+### GraphQL API と ScalarDB Java API 間のマッピング
+
+自動的に生成された GraphQL スキーマは、クエリ、ミューテーション、および入出力のオブジェクトタイプを定義し、ターゲット名前空間内のすべてのテーブルに対して CRUD 操作を実行できるようにします。
+
+これらの操作は、[`DistributedTransaction`](https://javadoc.io/doc/com.scalar-labs/scalardb/3.13.1/com/scalar/db/api/DistributedTransaction.html) インターフェースで定義されている ScalarDB API と一致するように設計されています。
+
+名前空間に `account` テーブルがあると仮定すると、次のクエリとミューテーションが生成されます。
+
+| ScalarDB API | GraphQL ルートタイプ | GraphQL フィールド |
+|--------------------------------------------------------|-------------------|------------------------------------------------------------------------------------|
+| `get(Get get)` | `Query` | `account_get(get: account_GetInput!): account_GetPayload` |
+| `scan(Scan scan)` | `Query` | `account_scan(scan: account_ScanInput!): account_ScanPayload` |
+| `put(Put put)` | `Mutation` | `account_put(put: account_PutInput!): Boolean!` |
+| `put(java.util.List puts)` | `Mutation` | `account_bulkPut(put: [account_PutInput!]!): Boolean!` |
+| `delete(Delete delete)` | `Mutation` | `account_delete(delete: account_DeleteInput!): Boolean!` |
+| `delete(java.util.List deletes)` | `Mutation` | `account_bulkDelete(delete: [account_DeleteInput!]!): Boolean!` |
+| `mutate(java.util.List extends Mutation> mutations)` | `Mutation` | `account_mutate(put: [account_PutInput!]delete: [account_DeleteInput!]): Boolean!` |
+
+クラスタリングキーのないテーブルでは、`scan` フィールドは生成されないことに注意してください。これが、この電子マネーサンプルアプリケーションで `account_scan` フィールドが使用できない理由です。
+
+生成されたすべての GraphQL タイプは、GraphiQL のドキュメントエクスプローラー (左上隅の `< Docs` リンク) で確認できます。
+
+## ステップ 5. GraphiQL からの複数のリクエストにまたがるトランザクションを実行する
+
+複数の GraphQL リクエストにまたがるトランザクションを実行してみましょう。
+
+生成されたスキーマには、トランザクションを識別できる `@transaction` ディレクティブが用意されています。このディレクティブは、クエリとミューテーションの両方で使用できます。
+
+トランザクションを開始する前に、次のミューテーションを使用して必要なレコードを挿入する必要があります。
+
+```graphql
+mutation PutUser2 {
+ account_put(put: {key: {id: "user2"}, values: {balance: 1000}})
+}
+```
+
+### 操作を実行する前にトランザクションを開始する
+
+以下を実行して、クエリまたはミューテーションに引数のない `@transaction` ディレクティブを追加すると、実行時に新しいトランザクションが開始されます。
+
+```graphql
+query GetAccounts @transaction {
+ user1: account_get(get: {key: {id: "user1"}}) {
+ account { balance }
+ }
+ user2: account_get(get: {key: {id: "user2"}}) {
+ account { balance }
+ }
+}
+```
+
+上記のコマンドを実行すると、`extensions` フィールドにトランザクション ID が入った結果が返されます。extensions の `id` 値は、リクエスト内の操作が実行されたトランザクション ID です。この場合、リクエストによって開始されたトランザクションの新しい ID は次のとおりです。
+
+```json
+{
+ "data": {
+ "user1": {
+ "account": {
+ "balance": 1000
+ }
+ },
+ "user2": {
+ "account": {
+ "balance": 1000
+ }
+ }
+ },
+ "extensions": {
+ "transaction": {
+ "id": "c88da8a6-a13f-4857-82fe-45f1ab4150f9"
+ }
+ }
+}
+```
+
+### 継続トランザクションで操作を実行する
+
+開始したトランザクションで次のクエリまたはミューテーションを実行するには、トランザクション ID を `@transaction` の `id` 引数として指定します。次の例では、同じトランザクションで user1 のアカウントから user2 のアカウントに残高を転送することにより、前の例で取得した 2 つのアカウントを更新します。
+
+```graphql
+mutation Transfer @transaction(id: "c88da8a6-a13f-4857-82fe-45f1ab4150f9") {
+ user1: account_put(put: {key: {id: "user1"}, values: {balance: 750}})
+ user2: account_put(put: {key: {id: "user2"}, values: {balance: 1250}})
+}
+```
+
+GraphQL で開始されたトランザクションには 1 分のタイムアウト (デフォルト) があり、タイムアウトを超えると自動的にアボートされることに注意してください。
+
+### トランザクションをコミットする
+
+継続中のトランザクションをコミットするには、`@transaction` ディレクティブの引数として `id` と `commit: true` フラグの両方を指定します。
+
+```graphql
+query GetAndCommit @transaction(id: "c88da8a6-a13f-4857-82fe-45f1ab4150f9", commit: true) {
+ user1: account_get(get: {key: {id: "user1"}}) {
+ account { balance }
+ }
+ user2: account_get(get: {key: {id: "user2"}}) {
+ account { balance }
+ }
+}
+```
+
+**注:** `@transaction(commit: true)` のように `id` 引数なしで `commit: true` フラグを指定すると、新しいトランザクションが開始され、1 つの操作に対してのみコミットされます。この動作は、GraphiQL を使用した上記の例で見られるように、`@transaction` ディレクティブを指定しない場合とまったく同じです。つまり、`@transaction(commit: true)` が指定されている場合は、ディレクティブ自体を省略できます。
+
+### トランザクションをアボートまたはロールバックする
+
+トランザクションを明示的にアボートまたはロールバックする必要がある場合は、`abort` または `rollback` ミューテーションフィールドを互換的に使用できます (どちらも効果と使用方法は同じです)。これらのフィールドを他の操作と混在させることはできないため、次のように `abort` または `rollback` ミューテーションフィールドのみを指定する必要があります。
+
+```graphql
+mutation AbortTx @transaction(id: "c88da8a6-a13f-4857-82fe-45f1ab4150f9") {
+ abort
+}
+```
+
+または:
+
+```graphql
+mutation RollbackTx @transaction(id: "c88da8a6-a13f-4857-82fe-45f1ab4150f9") {
+ rollback
+}
+```
+
+## 参照
+
+その他の ScalarDB Cluster チュートリアルについては、以下を参照してください。
+
+- [ScalarDB Cluster をはじめよう](getting-started-with-scalardb-cluster.mdx)
+- [JDBC 経由の ScalarDB Cluster SQL をはじめよう](getting-started-with-scalardb-cluster-sql-jdbc.mdx)
+- [Spring Data JDBC for ScalarDB を使用した ScalarDB Cluster SQL をはじめよう](getting-started-with-scalardb-cluster-sql-spring-data-jdbc.mdx)
+- [ScalarDB Cluster での Go をはじめよう](getting-started-with-using-go-for-scalardb-cluster.mdx)
+- [ScalarDB Cluster での Python をはじめよう](getting-started-with-using-python-for-scalardb-cluster.mdx)
+
+Java API で ScalarDB Cluster を使用するアプリケーションの開発の詳細については、以下を参照してください。
+
+- [Java API を使用した ScalarDB Cluster の開発者ガイド](developer-guide-for-scalardb-cluster-with-java-api.mdx)
+
+ScalarDB Cluster gRPC API の詳細については、以下を参照してください。
+
+- [ScalarDB Cluster gRPC API ガイド](scalardb-cluster-grpc-api-guide.mdx)
+- [ScalarDB Cluster SQL gRPC API ガイド](scalardb-cluster-sql-grpc-api-guide.mdx)
diff --git a/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-sql-jdbc.mdx b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-sql-jdbc.mdx
new file mode 100644
index 00000000..28cee2eb
--- /dev/null
+++ b/i18n/versioned_docs/ja-jp/docusaurus-plugin-content-docs/version-3.13/scalardb-cluster/getting-started-with-scalardb-cluster-sql-jdbc.mdx
@@ -0,0 +1,230 @@
+---
+tags:
+ - Enterprise Premium
+---
+
+# JDBC 経由の ScalarDB Cluster SQL をはじめよう
+
+import TranslationBanner from '/src/components/_translation-ja-jp.mdx';
+
+
+
+このチュートリアルでは、JDBC 経由で ScalarDB Cluster SQL を使用してサンプルアプリケーションを作成する方法について説明します。
+
+## このサンプルアプリケーションの前提条件
+
+- [Eclipse Temurin](https://adoptium.net/temurin/releases/) の OpenJDK LTS バージョン (8、11、17、または 21)
+- Kubernetes クラスターで実行されている ScalarDB Cluster
+ - [ScalarDB Cluster をローカルにデプロイする方法](setup-scalardb-cluster-on-kubernetes-by-using-helm-chart.mdx) の手順に従ってデプロイした Kubernetes クラスターで ScalarDB Cluster が実行されていることを前提としています。
+
+:::note
+
+このサンプルアプリケーションは、Eclipse Temurin の OpenJDK でテストされています。ただし、ScalarDB 自体は、さまざまなベンダーの JDK ディストリビューションでテストされています。互換性のある JDK ディストリビューションを含む ScalarDB の要件の詳細については、[要件](../requirements.mdx)を参照してください。
+
+:::
+
+## サンプルアプリケーション
+
+このチュートリアルでは、ScalarDB JDBC を使用して、クレジットラインでアイテムを注文し、支払いを行うことができるサンプル電子商取引アプリケーションを作成するプロセスについて説明します。
+
+次の図は、サンプルアプリケーションのシステムアーキテクチャを示しています。
+
+```
+ +------------------------------------------------------------------------------------------------------------------------------+
+ | [Kubernetes クラスター] |
+ | |
+ | [ポッド] [ポッド] [ポッド] |
+ +------------------------+ | |
+ | SQL CLI | | +-------+ +-----------------------+ |
+ | (間接クライアントモード) | --+ | +---> | Envoy | ---+ +---> | ScalarDB Cluster ノード | ---+ |
+ +------------------------+ | | | +-------+ | | +-----------------------+ | |
+ | | | | | | |
+ | | +---------+ | +-------+ | +--------------------+ | +-----------------------+ | +------------+ |
+ +--+-> | サービス | ---+---> | Envoy | ---+---> | サービス | ---+---> | ScalarDB Cluster ノード | ---+---> | PostgreSQL | |
+ | | | (Envoy) | | +-------+ | | (ScalarDB Cluster) | | +-----------------------+ | +------------+ |
+ +-------------------------+ | | +---------+ | | +--------------------+ | | |
+ | ScalarDB JDBC の | | | | +-------+ | | +-----------------------+ | |
+ | サンプルアプリケーション | --+ | +---> | Envoy | ---+ +---> | ScalarDB Cluster ノード | ---+ |
+ | (間接クライアントモード) | | +-------+ +-----------------------+ |
+ +-------------------------+ | |
+ +------------------------------------------------------------------------------------------------------------------------------+
+```
+
+## ステップ 1. ScalarDB サンプルリポジトリをクローンする
+
+```console
+git clone https://github.com/scalar-labs/scalardb-samples.git
+cd scalardb-samples/scalardb-sql-jdbc-sample
+```
+
+## ステップ 2. `scalardb-sql.properties` を変更する
+
+ScalarDB Cluster に接続するには、`scalardb-sql.properties` も変更する必要があります。ただし、その前に、次のように Envoy (`scalardb-cluster-envoy`) のサービスリソースの `EXTERNAL-IP` アドレスを取得する必要があります。
+
+```console
+kubectl get svc scalardb-cluster-envoy
+NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
+scalardb-cluster-envoy LoadBalancer 10.105.121.51 localhost 60053:30641/TCP 16h
+```
+
+この場合、`EXTERNAL-IP` アドレスは `localhost` です。
+
+次に、`scalardb-sql.properties` を開きます。
+
+```console
+vim scalardb-sql.properties
+```
+
+次に、`scalardb-sql.properties` を次のように変更します。
+
+```properties
+scalar.db.sql.connection_mode=cluster
+scalar.db.sql.cluster_mode.contact_points=indirect:localhost
+```
+
+ScalarDB Cluster に接続するには、`scalar.db.sql.connection_mode` プロパティに `cluster` を指定する必要があります。また、このチュートリアルでは `indirect` クライアントモードを使用して Envoy のサービスリソースに接続します。クライアントモードの詳細については、[Java API を使用した ScalarDB Cluster の開発者ガイド](developer-guide-for-scalardb-cluster-with-java-api.mdx) を参照してください。
+
+## ステップ 3. スキーマをロードする
+
+スキーマをロードするには、[SQL CLI](developer-guide-for-scalardb-cluster-with-java-api.mdx#sql-cli) を使用する必要があります。SQL CLI は [ScalarDB リリース](https://github.com/scalar-labs/scalardb/releases/tag/v3.13.1) からダウンロードできます。JAR ファイルをダウンロードしたら、次のコマンドを実行して Cluster 用の SQL CLI を使用できます。
+
+```console
+java -jar scalardb-cluster-sql-cli-3.13.1-all.jar --config scalardb-sql.properties --file schema.sql
+```
+
+## ステップ 4. 初期データをロードする
+
+サンプルアプリケーションを実行する前に、次のコマンドを実行して初期データをロードする必要があります。
+
+```console
+./gradlew run --args="LoadInitialData"
+```
+
+初期データがロードされた後、次のレコードがテーブルに保存されます:
+
+- `sample.customers` テーブルの場合:
+
+| customer_id | name | credit_limit | credit_total |
+|-------------|---------------|--------------|--------------|
+| 1 | Yamada Taro | 10000 | 0 |
+| 2 | Yamada Hanako | 10000 | 0 |
+| 3 | Suzuki Ichiro | 10000 | 0 |
+
+- `sample.items` テーブルの場合:
+
+| item_id | name | price |
+|---------|--------|-------|
+| 1 | Apple | 1000 |
+| 2 | Orange | 2000 |
+| 3 | Grape | 2500 |
+| 4 | Mango | 5000 |
+| 5 | Melon | 3000 |
+
+## ステップ 5. サンプルアプリケーションを実行する
+
+まず、ID が `1` である顧客に関する情報を取得します。
+
+```console
+./gradlew run --args="GetCustomerInfo 1"
+...
+{"id": 1, "name": "Yamada Taro", "credit_limit": 10000, "credit_total": 0}
+...
+```
+
+次に、顧客 ID `1` を使用して、リンゴ 3 個とオレンジ 2 個を注文します。注文形式は `
- :