Replace ScalarDbMode with core TransactionMode for clarity

Author: ypeckstadt

data-loader/core/src/main/java/com/scalar/db/dataloader/core/ScalarDbMode.java renamed to data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/ScalarDbMode.java

@@ -1,20 +1,31 @@
-package com.scalar.db.dataloader.core;
+package com.scalar.db.dataloader.cli;
 
 /**
  * The available modes a ScalarDB instance can run in. Determines how ScalarDB interacts with the
  * underlying database.
+ *
+ * @deprecated As of release 3.17.0. Will be removed in release 4.0.0. This enum is maintained for
+ *     CLI backward compatibility only. Internally, values are converted to {@code TransactionMode}
+ *     in the core module.
  */
+@Deprecated
 public enum ScalarDbMode {
 
   /**
    * Storage mode: Operates directly on the underlying storage engine without transactional
    * guarantees. Suitable for raw data access and simple CRUD operations.
+   *
+   * @deprecated As of release 3.17.0. Will be removed in release 4.0.0.
    */
+  @Deprecated
   STORAGE,
 
   /**
    * Transaction mode: Provides transaction management with ACID guarantees across multiple
    * operations. Suitable for applications that require consistency and atomicity.
+   *
+   * @deprecated As of release 3.17.0 Will be removed in release 4.0.0.
    */
+  @Deprecated
   TRANSACTION
 }

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

@@ -6,8 +6,10 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.scalar.db.api.DistributedTransactionAdmin;
 import com.scalar.db.api.TableMetadata;
+import com.scalar.db.dataloader.cli.ScalarDbMode;
 import com.scalar.db.dataloader.core.DataLoaderError;
 import com.scalar.db.dataloader.core.FileFormat;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.dataimport.ImportManager;
 import com.scalar.db.dataloader.core.dataimport.ImportOptions;
 import com.scalar.db.dataloader.core.dataimport.controlfile.ControlFile;
@@ -41,6 +43,7 @@
 import picocli.CommandLine.ParameterException;
 import picocli.CommandLine.Spec;
 
+@SuppressWarnings("deprecation")
 @CommandLine.Command(name = "import", description = "Import data into a ScalarDB table")
 public class ImportCommand extends ImportCommandOptions implements Callable<Integer> {
 
@@ -127,6 +130,23 @@ private Map<String, TableMetadata> createTableMetadataMap(
     }
   }
 
+  /**
+   * Converts CLI ScalarDbMode to core TransactionMode.
+   *
+   * @param scalarDbMode the ScalarDB mode from CLI
+   * @return the corresponding TransactionMode for core
+   */
+  private TransactionMode convertToTransactionMode(ScalarDbMode scalarDbMode) {
+    switch (scalarDbMode) {
+      case STORAGE:
+        return TransactionMode.SINGLE_CRUD;
+      case TRANSACTION:
+        return TransactionMode.CONSENSUS_COMMIT;
+      default:
+        throw new IllegalArgumentException("Unknown ScalarDbMode: " + scalarDbMode);
+    }
+  }
+
   /**
    * Create ImportManager object from data
    *
@@ -146,13 +166,14 @@ private ImportManager createImportManager(
       throws IOException {
     File configFile = new File(configFilePath);
     ImportProcessorFactory importProcessorFactory = new DefaultImportProcessorFactory();
+    TransactionMode transactionMode = convertToTransactionMode(scalarDbMode);
     ImportManager importManager =
         new ImportManager(
             tableMetadataMap,
             reader,
             importOptions,
             importProcessorFactory,
-            scalarDbMode,
+            transactionMode,
             TransactionFactory.create(configFile).getTransactionManager());
     if (importOptions.getLogMode().equals(LogMode.SPLIT_BY_DATA_CHUNK)) {
       importManager.addListener(new SplitByDataChunkImportLogger(config, logWriterFactory));

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

@@ -1,11 +1,12 @@
 package com.scalar.db.dataloader.cli.command.dataimport;
 
+import com.scalar.db.dataloader.cli.ScalarDbMode;
 import com.scalar.db.dataloader.core.FileFormat;
-import com.scalar.db.dataloader.core.ScalarDbMode;
 import com.scalar.db.dataloader.core.dataimport.ImportMode;
 import com.scalar.db.dataloader.core.dataimport.controlfile.ControlFileValidationLevel;
 import picocli.CommandLine;
 
+@SuppressWarnings("deprecation")
 public class ImportCommandOptions {
 
   public static final String FILE_OPTION_NAME_LONG_FORMAT = "--file";

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

@@ -0,0 +1,21 @@
+package com.scalar.db.dataloader.core;
+
+/**
+ * Defines the transaction mode for data loader operations. This determines how data operations are
+ * executed within ScalarDB.
+ */
+public enum TransactionMode {
+
+  /**
+   * Single CRUD mode: Executes each operation independently without transactional context. Each
+   * operation is atomic but there are no guarantees across multiple operations.
+   */
+  SINGLE_CRUD,
+
+  /**
+   * Consensus commit mode: Groups multiple operations into distributed transactions with ACID
+   * guarantees. Ensures atomicity and consistency across multiple operations through consensus
+   * commit protocol.
+   */
+  CONSENSUS_COMMIT
+}

data-loader/core/src/main/java/com/scalar/db/dataloader/core/dataimport/ImportManager.java

@@ -2,7 +2,7 @@
 
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.dataimport.dao.ScalarDbDao;
 import com.scalar.db.dataloader.core.dataimport.datachunk.ImportDataChunkStatus;
 import com.scalar.db.dataloader.core.dataimport.processor.ImportProcessor;
@@ -42,7 +42,7 @@ public class ImportManager implements ImportEventListener {
   @NonNull private final ImportOptions importOptions;
   private final ImportProcessorFactory importProcessorFactory;
   private final List<ImportEventListener> listeners = new ArrayList<>();
-  private final ScalarDbMode scalarDbMode;
+  private final TransactionMode transactionMode;
   private final DistributedTransactionManager distributedTransactionManager;
 
   /**
@@ -55,7 +55,7 @@ public class ImportManager implements ImportEventListener {
   public void startImport() {
     ImportProcessorParams params =
         ImportProcessorParams.builder()
-            .scalarDbMode(scalarDbMode)
+            .transactionMode(transactionMode)
             .importOptions(importOptions)
             .tableMetadataByTableName(tableMetadata)
             .dao(new ScalarDbDao())

data-loader/core/src/main/java/com/scalar/db/dataloader/core/dataimport/processor/ImportProcessor.java

@@ -2,7 +2,7 @@
 
 import com.scalar.db.api.DistributedTransaction;
 import com.scalar.db.dataloader.core.DataLoaderError;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.dataimport.ImportEventListener;
 import com.scalar.db.dataloader.core.dataimport.datachunk.ImportDataChunk;
 import com.scalar.db.dataloader.core.dataimport.datachunk.ImportDataChunkStatus;
@@ -54,12 +54,12 @@ public abstract class ImportProcessor {
    *
    * <p>This method reads data from the provided {@link BufferedReader}, processes it in chunks, and
    * batches transactions according to the specified sizes. The processing can be done in either
-   * transactional or storage mode, depending on the configured {@link ScalarDbMode}.
+   * single CRUD or consensus commit mode, depending on the configured {@link TransactionMode}.
    *
    * @param dataChunkSize the number of records to include in each data chunk for parallel
    *     processing
    * @param transactionBatchSize the number of records to group together in a single transaction
-   *     (only used in transaction mode)
+   *     (only used in consensus commit mode)
    * @param reader the {@link BufferedReader} used to read the source file
    */
   public void process(int dataChunkSize, int transactionBatchSize, BufferedReader reader) {
@@ -374,11 +374,12 @@ private ImportTaskResult processStorageRecord(int dataChunkId, ImportRow importR
   }
 
   /**
-   * Processes a complete data chunk using parallel execution. The processing mode (transactional or
-   * storage) is determined by the configured {@link ScalarDbMode}.
+   * Processes a complete data chunk using parallel execution. The processing mode (consensus commit
+   * or single CRUD) is determined by the configured {@link TransactionMode}.
    *
    * @param dataChunk the data chunk to process
-   * @param transactionBatchSize the size of transaction batches (used only in transaction mode)
+   * @param transactionBatchSize the size of transaction batches (used only in consensus commit
+   *     mode)
    */
   private void processDataChunk(ImportDataChunk dataChunk, int transactionBatchSize) {
     ImportDataChunkStatus status =
@@ -389,7 +390,7 @@ private void processDataChunk(ImportDataChunk dataChunk, int transactionBatchSiz
             .build();
     notifyDataChunkStarted(status);
     ImportDataChunkStatus importDataChunkStatus;
-    if (params.getScalarDbMode() == ScalarDbMode.TRANSACTION) {
+    if (params.getTransactionMode() == TransactionMode.CONSENSUS_COMMIT) {
       importDataChunkStatus = processDataChunkWithTransactions(dataChunk, transactionBatchSize);
     } else {
       importDataChunkStatus = processDataChunkWithoutTransactions(dataChunk);
@@ -398,7 +399,7 @@ private void processDataChunk(ImportDataChunk dataChunk, int transactionBatchSiz
   }
 
   /**
-   * Processes a data chunk using transaction mode with parallel batch processing. Multiple
+   * Processes a data chunk using consensus commit mode with parallel batch processing. Multiple
    * transaction batches are processed concurrently using a thread pool.
    *
    * @param dataChunk the data chunk to process
@@ -439,8 +440,8 @@ private ImportDataChunkStatus processDataChunkWithTransactions(
   }
 
   /**
-   * Processes a data chunk using storage mode with parallel record processing. Individual records
-   * are processed concurrently without transaction guarantees.
+   * Processes a data chunk using single CRUD mode with parallel record processing. Individual
+   * records are processed concurrently without transaction guarantees.
    *
    * @param dataChunk the data chunk to process
    * @return an {@link ImportDataChunkStatus} containing processing results and metrics

data-loader/core/src/main/java/com/scalar/db/dataloader/core/dataimport/processor/ImportProcessorParams.java

@@ -2,7 +2,7 @@
 
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.dataimport.ImportOptions;
 import com.scalar.db.dataloader.core.dataimport.dao.ScalarDbDao;
 import java.util.Map;
@@ -20,8 +20,8 @@
 @Builder
 @Value
 public class ImportProcessorParams {
-  /** The operational mode of ScalarDB (transaction or storage mode). */
-  ScalarDbMode scalarDbMode;
+  /** The transaction mode for data operations. */
+  TransactionMode transactionMode;
 
   /** Configuration options for the import operation. */
   ImportOptions importOptions;

data-loader/core/src/test/java/com/scalar/db/dataloader/core/dataimport/ImportManagerTest.java

@@ -9,7 +9,7 @@
 
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.dataimport.processor.ImportProcessorFactory;
 import java.io.BufferedReader;
 import java.util.HashMap;
@@ -41,7 +41,7 @@ void setUp() {
             reader,
             options,
             processorFactory,
-            ScalarDbMode.STORAGE,
+            TransactionMode.SINGLE_CRUD,
             distributedTransactionManager);
     importManager.addListener(listener1);
     importManager.addListener(listener2);
@@ -76,7 +76,7 @@ void closeResources_shouldCloseTransactionManagerIfStorageIsNull() {
             mock(BufferedReader.class),
             mock(ImportOptions.class),
             mock(ImportProcessorFactory.class),
-            ScalarDbMode.TRANSACTION,
+            TransactionMode.CONSENSUS_COMMIT,
             distributedTransactionManager);
 
     managerWithTx.closeResources();

data-loader/core/src/test/java/com/scalar/db/dataloader/core/dataimport/processor/CsvImportProcessorTest.java

@@ -7,7 +7,7 @@
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
 import com.scalar.db.dataloader.core.FileFormat;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.UnitTestUtils;
 import com.scalar.db.dataloader.core.dataimport.ImportMode;
 import com.scalar.db.dataloader.core.dataimport.ImportOptions;
@@ -76,10 +76,10 @@ void setup() throws ScalarDbDaoException, TransactionException {
   }
 
   @Test
-  void test_importProcessWithStorage() {
+  void test_importProcessWithSingleCrud() {
     params =
         ImportProcessorParams.builder()
-            .scalarDbMode(ScalarDbMode.STORAGE)
+            .transactionMode(TransactionMode.SINGLE_CRUD)
             .importOptions(importOptions)
             .dao(dao)
             .distributedTransactionManager(distributedTransactionManager)
@@ -94,10 +94,10 @@ void test_importProcessWithStorage() {
   }
 
   @Test
-  void test_importProcessWithTransaction() {
+  void test_importProcessWithConsensusCommit() {
     params =
         ImportProcessorParams.builder()
-            .scalarDbMode(ScalarDbMode.TRANSACTION)
+            .transactionMode(TransactionMode.CONSENSUS_COMMIT)
             .importOptions(importOptions)
             .dao(dao)
             .distributedTransactionManager(distributedTransactionManager)

data-loader/core/src/test/java/com/scalar/db/dataloader/core/dataimport/processor/ImportProcessorTest.java

@@ -13,7 +13,7 @@
 import com.scalar.db.api.DistributedTransaction;
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.TableMetadata;
-import com.scalar.db.dataloader.core.ScalarDbMode;
+import com.scalar.db.dataloader.core.TransactionMode;
 import com.scalar.db.dataloader.core.UnitTestUtils;
 import com.scalar.db.dataloader.core.dataimport.ImportEventListener;
 import com.scalar.db.dataloader.core.dataimport.ImportOptions;
@@ -49,7 +49,7 @@
  * Unit tests for the ImportProcessor class.
  *
  * <p>These tests verify that the process method correctly handles different scenarios including
- * storage mode, transaction mode, empty data, and large data chunks.
+ * single CRUD mode, consensus commit mode, empty data, and large data chunks.
  *
  * <p>Additionally, this class tests the thread executor behavior in ImportProcessor, including
  * proper shutdown, waiting for tasks to complete, handling interruptions, and task distribution.
@@ -80,10 +80,10 @@ void setUp() {
   }
 
   @Test
-  void process_withStorageMode_shouldProcessAllDataChunks() {
+  void process_withSingleCrudMode_shouldProcessAllDataChunks() {
     // Arrange
     BufferedReader reader = new BufferedReader(new StringReader("test data"));
-    when(params.getScalarDbMode()).thenReturn(ScalarDbMode.STORAGE);
+    when(params.getTransactionMode()).thenReturn(TransactionMode.SINGLE_CRUD);
     when(params.getDao()).thenReturn(dao);
     when(params.getTableColumnDataTypes()).thenReturn(tableColumnDataTypes);
 
@@ -100,10 +100,10 @@ void process_withStorageMode_shouldProcessAllDataChunks() {
   }
 
   @Test
-  void process_withTransactionMode_shouldProcessAllDataChunks() throws TransactionException {
+  void process_withConsensusCommitMode_shouldProcessAllDataChunks() throws TransactionException {
     // Arrange
     BufferedReader reader = new BufferedReader(new StringReader("test data"));
-    when(params.getScalarDbMode()).thenReturn(ScalarDbMode.TRANSACTION);
+    when(params.getTransactionMode()).thenReturn(TransactionMode.CONSENSUS_COMMIT);
     when(params.getDao()).thenReturn(dao);
     when(params.getTableColumnDataTypes()).thenReturn(tableColumnDataTypes);
     when(params.getTableMetadataByTableName()).thenReturn(tableMetadataByTableName);
@@ -228,7 +228,7 @@ void process_withLargeNumberOfTasks_shouldWaitForAllTasksToComplete() {
   @Test
   void process_withShutdown_shouldShutdownExecutorsGracefully() {
     // Arrange
-    when(params.getScalarDbMode()).thenReturn(ScalarDbMode.STORAGE);
+    when(params.getTransactionMode()).thenReturn(TransactionMode.SINGLE_CRUD);
     when(params.getDao()).thenReturn(dao);
     when(params.getTableColumnDataTypes()).thenReturn(tableColumnDataTypes);
     when(params.getTableMetadataByTableName()).thenReturn(tableMetadataByTableName);