Add transaction mode support for data export in dataloader core and CLI

data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java

@@ -5,6 +5,7 @@
 import static java.nio.file.StandardOpenOption.CREATE;
 
 import com.scalar.db.api.DistributedStorage;
+import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
 import com.scalar.db.dataloader.cli.exception.DirectoryValidationException;
 import com.scalar.db.dataloader.cli.util.DirectoryUtils;
@@ -13,6 +14,7 @@
 import com.scalar.db.dataloader.core.ColumnKeyValue;
 import com.scalar.db.dataloader.core.DataLoaderError;
 import com.scalar.db.dataloader.core.FileFormat;
+import com.scalar.db.dataloader.core.ScalarDbMode;
 import com.scalar.db.dataloader.core.ScanRange;
 import com.scalar.db.dataloader.core.dataexport.CsvExportManager;
 import com.scalar.db.dataloader.core.dataexport.ExportManager;
@@ -25,10 +27,14 @@
 import com.scalar.db.dataloader.core.exception.KeyParsingException;
 import com.scalar.db.dataloader.core.tablemetadata.TableMetadataException;
 import com.scalar.db.dataloader.core.tablemetadata.TableMetadataService;
+import com.scalar.db.dataloader.core.tablemetadata.TableMetadataStorageService;
+import com.scalar.db.dataloader.core.tablemetadata.TableMetadataTransactionService;
 import com.scalar.db.dataloader.core.util.KeyUtils;
 import com.scalar.db.io.Key;
 import com.scalar.db.service.StorageFactory;
+import com.scalar.db.service.TransactionFactory;
 import java.io.BufferedWriter;
+import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Paths;
@@ -60,14 +66,13 @@ public Integer call() throws Exception {
           spec.commandLine(), dataChunkSize, DataLoaderError.INVALID_DATA_CHUNK_SIZE);
       validatePositiveValue(spec.commandLine(), maxThreads, DataLoaderError.INVALID_MAX_THREADS);
 
-      StorageFactory storageFactory = StorageFactory.create(scalarDbPropertiesFilePath);
-      TableMetadataService metaDataService =
-          new TableMetadataService(storageFactory.getStorageAdmin());
+      TableMetadataService tableMetadataService =
+          createTableMetadataService(scalarDbMode, scalarDbPropertiesFilePath);
       ScalarDbDao scalarDbDao = new ScalarDbDao();
 
-      ExportManager exportManager = createExportManager(storageFactory, scalarDbDao, outputFormat);
-
-      TableMetadata tableMetadata = metaDataService.getTableMetadata(namespace, table);
+      ExportManager exportManager =
+          createExportManager(scalarDbMode, scalarDbDao, outputFormat, scalarDbPropertiesFilePath);
+      TableMetadata tableMetadata = tableMetadataService.getTableMetadata(namespace, table);
 
       Key partitionKey =
           partitionKeyValue != null ? getKeysFromList(partitionKeyValue, tableMetadata) : null;
@@ -124,11 +129,100 @@ private void validateOutputDirectory() throws DirectoryValidationException {
     }
   }
 
+  /**
+   * Creates a {@link TableMetadataService} instance based on the specified {@link ScalarDbMode} and
+   * ScalarDB configuration file.
+   *
+   * <p>If the mode is {@code TRANSACTION}, this method initializes a {@link TransactionFactory} and
+   * uses its transaction admin to create a {@link TableMetadataTransactionService}. Otherwise, it
+   * initializes a {@link StorageFactory} and creates a {@link TableMetadataStorageService} using
+   * its storage admin.
+   *
+   * @param scalarDbMode the mode ScalarDB is running in (either {@code STORAGE} or {@code
+   *     TRANSACTION})
+   * @param scalarDbPropertiesFilePath the path to the ScalarDB properties file
+   * @return an appropriate {@link TableMetadataService} based on the mode
+   * @throws IOException if reading the ScalarDB properties file fails
+   */
+  private TableMetadataService createTableMetadataService(
+      ScalarDbMode scalarDbMode, String scalarDbPropertiesFilePath) throws IOException {
+    if (scalarDbMode.equals(ScalarDbMode.TRANSACTION)) {
+      TransactionFactory transactionFactory = TransactionFactory.create(scalarDbPropertiesFilePath);
+      return new TableMetadataTransactionService(transactionFactory.getTransactionAdmin());
+    }
+    StorageFactory storageFactory = StorageFactory.create(scalarDbPropertiesFilePath);
+    return new TableMetadataStorageService(storageFactory.getStorageAdmin());
+  }
+
+  /**
+   * Creates an {@link ExportManager} instance based on ScalarDB mode and file format.
+   *
+   * @param scalarDbMode The ScalarDB mode (TRANSACTION or STORAGE).
+   * @param scalarDbDao The DAO for accessing ScalarDB.
+   * @param fileFormat The output file format (CSV, JSON, JSONL).
+   * @param scalarDbPropertiesFilePath Path to the ScalarDB properties file.
+   * @return A configured {@link ExportManager}.
+   * @throws IOException If there is an error reading the properties file.
+   */
   private ExportManager createExportManager(
-      StorageFactory storageFactory, ScalarDbDao scalarDbDao, FileFormat fileFormat) {
+      ScalarDbMode scalarDbMode,
+      ScalarDbDao scalarDbDao,
+      FileFormat fileFormat,
+      String scalarDbPropertiesFilePath)
+      throws IOException {
     ProducerTaskFactory taskFactory =
         new ProducerTaskFactory(delimiter, includeTransactionMetadata, prettyPrintJson);
-    DistributedStorage storage = storageFactory.getStorage();
+    if (scalarDbMode.equals(ScalarDbMode.STORAGE)) {
+      DistributedStorage storage = StorageFactory.create(scalarDbPropertiesFilePath).getStorage();
+      return createExportManagerWithStorage(storage, scalarDbDao, fileFormat, taskFactory);
+    } else {
+      DistributedTransactionManager distributedTransactionManager =
+          TransactionFactory.create(scalarDbPropertiesFilePath).getTransactionManager();
+      return createExportManagerWithTransaction(
+          distributedTransactionManager, scalarDbDao, fileFormat, taskFactory);
+    }
+  }
+
+  /**
+   * Returns an {@link ExportManager} that uses {@link DistributedTransactionManager}.
+   *
+   * @param distributedTransactionManager distributed transaction manager object
+   * @param scalarDbDao The DAO for accessing ScalarDB.
+   * @param fileFormat The output file format (CSV, JSON, JSONL).
+   * @param taskFactory Producer task factory object
+   * @return A configured {@link ExportManager}.
+   */
+  private ExportManager createExportManagerWithTransaction(
+      DistributedTransactionManager distributedTransactionManager,
+      ScalarDbDao scalarDbDao,
+      FileFormat fileFormat,
+      ProducerTaskFactory taskFactory) {
+    switch (fileFormat) {
+      case JSON:
+        return new JsonExportManager(distributedTransactionManager, scalarDbDao, taskFactory);
+      case JSONL:
+        return new JsonLineExportManager(distributedTransactionManager, scalarDbDao, taskFactory);
+      case CSV:
+        return new CsvExportManager(distributedTransactionManager, scalarDbDao, taskFactory);
+      default:
+        throw new AssertionError("Invalid file format" + fileFormat);
+    }
+  }
+
+  /**
+   * Returns an {@link ExportManager} that uses {@link DistributedStorage}.
+   *
+   * @param storage distributed storage object
+   * @param scalarDbDao The DAO for accessing ScalarDB.
+   * @param fileFormat The output file format (CSV, JSON, JSONL).
+   * @param taskFactory Producer task factory object
+   * @return A configured {@link ExportManager}.
+   */
+  private ExportManager createExportManagerWithStorage(
+      DistributedStorage storage,
+      ScalarDbDao scalarDbDao,
+      FileFormat fileFormat,
+      ProducerTaskFactory taskFactory) {
     switch (fileFormat) {
       case JSON:
         return new JsonExportManager(storage, scalarDbDao, taskFactory);
@@ -152,7 +246,8 @@ private ExportOptions buildExportOptions(Key partitionKey, ScanRange scanRange)
             .maxThreadCount(maxThreads)
             .dataChunkSize(dataChunkSize)
             .prettyPrintJson(prettyPrintJson)
-            .scanRange(scanRange);
+            .scanRange(scanRange)
+            .scalarDbMode(scalarDbMode);
 
     if (projectionColumns != null) {
       builder.projectionColumns(projectionColumns);

data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandOptions.java

@@ -3,6 +3,7 @@
 import com.scalar.db.api.Scan;
 import com.scalar.db.dataloader.core.ColumnKeyValue;
 import com.scalar.db.dataloader.core.FileFormat;
+import com.scalar.db.dataloader.core.ScalarDbMode;
 import java.util.ArrayList;
 import java.util.List;
 import picocli.CommandLine;
@@ -61,7 +62,7 @@ public class ExportCommandOptions {
   protected FileFormat outputFormat;
 
   @CommandLine.Option(
-      names = {"--include-metadata", "-m"},
+      names = {"--include-metadata", "-im"},
       description = "Include transaction metadata in the exported data (default: false)",
       defaultValue = "false")
   protected boolean includeTransactionMetadata;
@@ -144,4 +145,11 @@ public class ExportCommandOptions {
       description = "Size of the data chunk to process in a single task (default: 200)",
       defaultValue = "200")
   protected int dataChunkSize;
+
+  @CommandLine.Option(
+      names = {"--mode", "-m"},
+      description = "ScalarDB mode (STORAGE, TRANSACTION) (default: STORAGE)",
+      paramLabel = "<MODE>",
+      defaultValue = "STORAGE")
+  protected ScalarDbMode scalarDbMode;
 }

data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java

@@ -24,6 +24,7 @@
 import com.scalar.db.dataloader.core.dataimport.processor.ImportProcessorFactory;
 import com.scalar.db.dataloader.core.tablemetadata.TableMetadataException;
 import com.scalar.db.dataloader.core.tablemetadata.TableMetadataService;
+import com.scalar.db.dataloader.core.tablemetadata.TableMetadataStorageService;
 import com.scalar.db.dataloader.core.util.TableMetadataUtil;
 import com.scalar.db.service.StorageFactory;
 import com.scalar.db.service.TransactionFactory;
@@ -106,7 +107,7 @@ private Map<String, TableMetadata> createTableMetadataMap(
     File configFile = new File(configFilePath);
     StorageFactory storageFactory = StorageFactory.create(configFile);
     try (DistributedStorageAdmin storageAdmin = storageFactory.getStorageAdmin()) {
-      TableMetadataService tableMetadataService = new TableMetadataService(storageAdmin);
+      TableMetadataService tableMetadataService = new TableMetadataStorageService(storageAdmin);
       Map<String, TableMetadata> tableMetadataMap = new HashMap<>();
       if (controlFile != null) {
         for (ControlFileTable table : controlFile.getTables()) {

data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java

@@ -4,6 +4,7 @@
 
 import com.scalar.db.dataloader.core.DataLoaderError;
 import com.scalar.db.dataloader.core.FileFormat;
+import com.scalar.db.dataloader.core.ScalarDbMode;
 import java.io.File;
 import java.nio.file.Paths;
 import org.junit.jupiter.api.AfterEach;
@@ -55,4 +56,19 @@ void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exceptio
     exportCommand.outputFormat = FileFormat.JSON;
     Assertions.assertEquals(1, exportCommand.call());
   }
+
+  @Test
+  void call_withScalarDBModeTransaction_WithInvalidConfigurationFile_shouldReturnOne()
+      throws Exception {
+    ExportCommand exportCommand = new ExportCommand();
+    exportCommand.configFilePath = "scalardb.properties";
+    exportCommand.dataChunkSize = 100;
+    exportCommand.namespace = "scalar";
+    exportCommand.table = "asset";
+    exportCommand.outputDirectory = "";
+    exportCommand.outputFileName = "sample.json";
+    exportCommand.outputFormat = FileFormat.JSON;
+    exportCommand.scalarDbMode = ScalarDbMode.TRANSACTION;
+    Assertions.assertEquals(1, exportCommand.call());
+  }
 }

data-loader/core/src/main/java/com/scalar/db/dataloader/core/dataexport/CsvExportManager.java

@@ -1,6 +1,7 @@
 package com.scalar.db.dataloader.core.dataexport;
 
 import com.scalar.db.api.DistributedStorage;
+import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
 import com.scalar.db.dataloader.core.dataexport.producer.ProducerTaskFactory;
 import com.scalar.db.dataloader.core.dataimport.dao.ScalarDbDao;
@@ -13,18 +14,40 @@
 
 /** Export manager implementation which manages the export task that exports data in CSV format */
 public class CsvExportManager extends ExportManager {
+  /**
+   * Constructs a {@code CsvExportManager} for exporting data using a {@link DistributedStorage}
+   * instance.
+   *
+   * <p>This constructor is used when exporting data in non-transactional (storage) mode.
+   *
+   * @param distributedStorage the {@link DistributedStorage} used to read data directly from
+   *     storage
+   * @param dao the {@link ScalarDbDao} used to interact with ScalarDB for exporting data
+   * @param producerTaskFactory the factory used to create producer tasks for generating
+   *     CSV-formatted output
+   */
+  public CsvExportManager(
+      DistributedStorage distributedStorage,
+      ScalarDbDao dao,
+      ProducerTaskFactory producerTaskFactory) {
+    super(distributedStorage, dao, producerTaskFactory);
+  }
 
   /**
-   * Constructs a {@code CsvExportManager} with the specified {@link DistributedStorage}, {@link
-   * ScalarDbDao}, and {@link ProducerTaskFactory}.
+   * Constructs a {@code CsvExportManager} for exporting data using a {@link
+   * DistributedTransactionManager}.
    *
-   * @param storage the {@code DistributedStorage} instance used to read data from the database
-   * @param dao the {@code ScalarDbDao} used to execute export-related database operations
-   * @param producerTaskFactory the factory used to create producer tasks for exporting data
+   * @param distributedTransactionManager the transaction manager used to read data with
+   *     transactional guarantees
+   * @param dao the {@link ScalarDbDao} used to interact with ScalarDB for exporting data
+   * @param producerTaskFactory the factory used to create producer tasks for generating
+   *     CSV-formatted output
    */
   public CsvExportManager(
-      DistributedStorage storage, ScalarDbDao dao, ProducerTaskFactory producerTaskFactory) {
-    super(storage, dao, producerTaskFactory);
+      DistributedTransactionManager distributedTransactionManager,
+      ScalarDbDao dao,
+      ProducerTaskFactory producerTaskFactory) {
+    super(distributedTransactionManager, dao, producerTaskFactory);
   }
 
   /**