From cb6058fb16f86c3468f7a04284951489d8c50760 Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Tue, 14 Oct 2025 12:46:01 +0900
Subject: [PATCH 1/5] Re-add deprecated CLI arguments

---
 .../cli/command/dataexport/ExportCommand.java | 35 ++++++++
 .../dataexport/ExportCommandOptions.java      | 41 +++++++++
 .../cli/command/dataimport/ImportCommand.java | 25 ++++++
 .../dataimport/ImportCommandOptions.java      | 26 ++++++
 .../command/dataexport/ExportCommandTest.java | 85 ++++++++++++++++++-
 .../command/dataimport/ImportCommandTest.java | 46 ++++++++++
 .../db/dataloader/core/DataLoaderError.java   |  6 ++
 7 files changed, 262 insertions(+), 2 deletions(-)

diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
index c3aaeee3af..4bd94c36d7 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
@@ -51,6 +51,8 @@ public class ExportCommand extends ExportCommandOptions implements Callable<Inte
 
   @Override
   public Integer call() throws Exception {
+    validateDeprecatedOptions();
+    applyDeprecatedOptions();
     String scalarDbPropertiesFilePath = getScalarDbPropertiesFilePath();
 
     try {
@@ -107,6 +109,39 @@ public Integer call() throws Exception {
     return 0;
   }
 
+  /**
+   * Validates that deprecated and new options are not both specified.
+   *
+   * @throws CommandLine.ParameterException if both old and new options are specified
+   */
+  private void validateDeprecatedOptions() {
+    boolean hasDeprecatedStartExclusive =
+        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_START_EXCLUSIVE_OPTION);
+    boolean hasNewStartInclusive =
+        spec.commandLine().getParseResult().hasMatchedOption(START_INCLUSIVE_OPTION)
+            || spec.commandLine().getParseResult().hasMatchedOption(START_INCLUSIVE_OPTION_SHORT);
+
+    if (hasDeprecatedStartExclusive && hasNewStartInclusive) {
+      throw new CommandLine.ParameterException(
+          spec.commandLine(),
+          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+              DEPRECATED_START_EXCLUSIVE_OPTION, START_INCLUSIVE_OPTION, START_INCLUSIVE_OPTION));
+    }
+
+    boolean hasDeprecatedEndExclusive =
+        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_END_EXCLUSIVE_OPTION);
+    boolean hasNewEndInclusive =
+        spec.commandLine().getParseResult().hasMatchedOption(END_INCLUSIVE_OPTION)
+            || spec.commandLine().getParseResult().hasMatchedOption(END_INCLUSIVE_OPTION_SHORT);
+
+    if (hasDeprecatedEndExclusive && hasNewEndInclusive) {
+      throw new CommandLine.ParameterException(
+          spec.commandLine(),
+          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+              DEPRECATED_END_EXCLUSIVE_OPTION, END_INCLUSIVE_OPTION, END_INCLUSIVE_OPTION));
+    }
+  }
+
   private String getScalarDbPropertiesFilePath() {
     if (StringUtils.isBlank(configFilePath)) {
       throw new IllegalArgumentException(DataLoaderError.CONFIG_FILE_PATH_BLANK.buildMessage());
diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandOptions.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandOptions.java
index 5cbe8f6c78..617338fb03 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandOptions.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandOptions.java
@@ -10,6 +10,12 @@
 public class ExportCommandOptions {
 
   protected static final String DEFAULT_CONFIG_FILE_NAME = "scalardb.properties";
+  public static final String START_INCLUSIVE_OPTION = "--start-inclusive";
+  public static final String START_INCLUSIVE_OPTION_SHORT = "-si";
+  public static final String DEPRECATED_START_EXCLUSIVE_OPTION = "--start-exclusive";
+  public static final String END_INCLUSIVE_OPTION = "--end-inclusive";
+  public static final String END_INCLUSIVE_OPTION_SHORT = "-ei";
+  public static final String DEPRECATED_END_EXCLUSIVE_OPTION = "--end-exclusive";
 
   @CommandLine.Option(
       names = {"--config", "-c"},
@@ -87,6 +93,14 @@ public class ExportCommandOptions {
   // TODO: test that -si false, works
   protected boolean scanStartInclusive;
 
+  // Deprecated option - kept for backward compatibility
+  @CommandLine.Option(
+      names = {DEPRECATED_START_EXCLUSIVE_OPTION},
+      description = "Deprecated: Use --start-inclusive instead (inverted logic)",
+      hidden = true)
+  @Deprecated
+  protected Boolean startExclusiveDeprecated;
+
   @CommandLine.Option(
       names = {"--end-key", "-ek"},
       paramLabel = "<KEY=VALUE>",
@@ -100,6 +114,14 @@ public class ExportCommandOptions {
       defaultValue = "true")
   protected boolean scanEndInclusive;
 
+  // Deprecated option - kept for backward compatibility
+  @CommandLine.Option(
+      names = {DEPRECATED_END_EXCLUSIVE_OPTION},
+      description = "Deprecated: Use --end-inclusive instead (inverted logic)",
+      hidden = true)
+  @Deprecated
+  protected Boolean endExclusiveDeprecated;
+
   @CommandLine.Option(
       names = {"--sort-by", "-s"},
       paramLabel = "<SORT_ORDER>",
@@ -144,4 +166,23 @@ public class ExportCommandOptions {
       description = "Size of the data chunk to process in a single task (default: 200)",
       defaultValue = "200")
   protected int dataChunkSize;
+
+  /**
+   * Applies deprecated option values if they are set.
+   *
+   * <p>This method is called AFTER validateDeprecatedOptions(), so we are guaranteed that both the
+   * deprecated and new options were not specified together. If we reach this point, only the
+   * deprecated option was provided by the user.
+   */
+  public void applyDeprecatedOptions() {
+    // If the deprecated option is set, use its value (inverted logic)
+    if (startExclusiveDeprecated != null) {
+      scanStartInclusive = !startExclusiveDeprecated;
+    }
+
+    // If the deprecated option is set, use its value (inverted logic)
+    if (endExclusiveDeprecated != null) {
+      scanEndInclusive = !endExclusiveDeprecated;
+    }
+  }
 }
diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
index bc78514b53..3701330be1 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
@@ -52,6 +52,8 @@ public class ImportCommand extends ImportCommandOptions implements Callable<Inte
 
   @Override
   public Integer call() throws Exception {
+    validateDeprecatedOptions();
+    applyDeprecatedOptions();
     validateImportTarget(controlFilePath, namespace, tableName);
     validateLogDirectory(logDirectory);
     validatePositiveValue(
@@ -272,6 +274,29 @@ private Optional<ControlFile> parseControlFileFromPath(String controlFilePath) {
     }
   }
 
+  /**
+   * Validates that deprecated and new options are not both specified.
+   *
+   * @throws ParameterException if both old and new options are specified
+   */
+  private void validateDeprecatedOptions() {
+    // Using getParseResult allows us to check if the argument was specified or not, regardless of
+    // the default option
+    boolean hasDeprecatedThreads =
+        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_THREADS_OPTION);
+    boolean hasNewMaxThreads =
+        spec.commandLine().getParseResult().hasMatchedOption(MAX_THREADS_OPTION)
+            || spec.commandLine().getParseResult().hasMatchedOption(MAX_THREADS_OPTION_SHORT);
+
+    // Throw exception if both are specified
+    if (hasDeprecatedThreads && hasNewMaxThreads) {
+      throw new ParameterException(
+          spec.commandLine(),
+          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+              DEPRECATED_THREADS_OPTION, MAX_THREADS_OPTION, MAX_THREADS_OPTION));
+    }
+  }
+
   /**
    * Generate import options object from provided cli parameter data
    *
diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandOptions.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandOptions.java
index d0cd2871ce..aa8ecd5a88 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandOptions.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandOptions.java
@@ -9,6 +9,9 @@
 public class ImportCommandOptions {
 
   public static final String FILE_OPTION_NAME_LONG_FORMAT = "--file";
+  public static final String MAX_THREADS_OPTION = "--max-threads";
+  public static final String MAX_THREADS_OPTION_SHORT = "-mt";
+  public static final String DEPRECATED_THREADS_OPTION = "--threads";
 
   @CommandLine.Option(
       names = {"--mode", "-m"},
@@ -39,6 +42,15 @@ public class ImportCommandOptions {
       defaultValue = "16")
   protected int maxThreads;
 
+  // Deprecated option - kept for backward compatibility
+  @CommandLine.Option(
+      names = {DEPRECATED_THREADS_OPTION},
+      paramLabel = "<THREADS>",
+      description = "Deprecated: Use --max-threads instead",
+      hidden = true)
+  @Deprecated
+  protected Integer threadsDeprecated;
+
   @CommandLine.Option(
       names = {"--namespace", "-ns"},
       paramLabel = "<NAMESPACE>",
@@ -158,4 +170,18 @@ public class ImportCommandOptions {
       description = "Maximum number of data chunks that can be kept at a time for processing",
       defaultValue = "256")
   protected int dataChunkQueueSize;
+
+  /**
+   * Applies deprecated option values if they are set.
+   *
+   * <p>This method is called AFTER validateDeprecatedOptions(), so we are guaranteed that both the
+   * deprecated and new options were not specified together. If we reach this point, only the
+   * deprecated option was provided by the user.
+   */
+  public void applyDeprecatedOptions() {
+    // If the deprecated option is set, use its value
+    if (threadsDeprecated != null) {
+      maxThreads = threadsDeprecated;
+    }
+  }
 }
diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
index 56518f8e71..a7382516be 100755
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
@@ -8,10 +8,27 @@
 import java.nio.file.Paths;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import picocli.CommandLine;
 
 class ExportCommandTest {
 
+  private ExportCommand exportCommand;
+
+  @BeforeEach
+  void setUp() {
+    exportCommand = new ExportCommand();
+    CommandLine cmd = new CommandLine(exportCommand);
+    // Parse empty args to properly initialize spec.commandLine() reference
+    try {
+      cmd.parseArgs();
+    } catch (Exception e) {
+      // Ignore parse errors for missing required options - we'll set fields directly in tests
+    }
+    exportCommand.spec = cmd.getCommandSpec();
+  }
+
   @AfterEach
   void removeFileIfCreated() {
     // To remove generated file if it is present
@@ -24,7 +41,6 @@ void removeFileIfCreated() {
 
   @Test
   void call_withBlankScalarDBConfigurationFile_shouldThrowException() {
-    ExportCommand exportCommand = new ExportCommand();
     exportCommand.configFilePath = "";
     exportCommand.dataChunkSize = 100;
     exportCommand.maxThreads = 4;
@@ -44,7 +60,6 @@ void call_withBlankScalarDBConfigurationFile_shouldThrowException() {
 
   @Test
   void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exception {
-    ExportCommand exportCommand = new ExportCommand();
     exportCommand.configFilePath = "scalardb.properties";
     exportCommand.dataChunkSize = 100;
     exportCommand.maxThreads = 4;
@@ -55,4 +70,70 @@ void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exceptio
     exportCommand.outputFormat = FileFormat.JSON;
     Assertions.assertEquals(1, exportCommand.call());
   }
+
+  @Test
+  void call_withBothStartExclusiveAndStartInclusive_shouldThrowException() {
+    // Simulate command line parsing with both deprecated and new options
+    String[] args = {
+      "--config",
+      "scalardb.properties",
+      "--namespace",
+      "scalar",
+      "--table",
+      "asset",
+      "--format",
+      "JSON",
+      "--start-exclusive=false",
+      "--start-inclusive=false"
+    };
+    ExportCommand command = new ExportCommand();
+    CommandLine cmd = new CommandLine(command);
+    // Parse args - this will trigger our validation
+    cmd.parseArgs(args);
+
+    // Now call the command, which should throw the validation error
+    CommandLine.ParameterException thrown =
+        assertThrows(
+            CommandLine.ParameterException.class,
+            command::call,
+            "Expected to throw ParameterException when both deprecated and new options are specified");
+    Assertions.assertTrue(
+        thrown
+            .getMessage()
+            .contains(
+                "Cannot specify both deprecated option '--start-exclusive' and new option '--start-inclusive'"));
+  }
+
+  @Test
+  void call_withBothEndExclusiveAndEndInclusive_shouldThrowException() {
+    // Simulate command line parsing with both deprecated and new options
+    String[] args = {
+      "--config",
+      "scalardb.properties",
+      "--namespace",
+      "scalar",
+      "--table",
+      "asset",
+      "--format",
+      "JSON",
+      "--end-exclusive=false",
+      "--end-inclusive=false"
+    };
+    ExportCommand command = new ExportCommand();
+    CommandLine cmd = new CommandLine(command);
+    // Parse args - this will trigger our validation
+    cmd.parseArgs(args);
+
+    // Now call the command, which should throw the validation error
+    CommandLine.ParameterException thrown =
+        assertThrows(
+            CommandLine.ParameterException.class,
+            command::call,
+            "Expected to throw ParameterException when both deprecated and new options are specified");
+    Assertions.assertTrue(
+        thrown
+            .getMessage()
+            .contains(
+                "Cannot specify both deprecated option '--end-exclusive' and new option '--end-inclusive'"));
+  }
 }
diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
index 1f24c8d86f..5737b5dfb9 100755
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
@@ -27,6 +27,12 @@ public class ImportCommandTest {
   void setUp() {
     importCommand = new ImportCommand();
     CommandLine cmd = new CommandLine(importCommand);
+    // Parse empty args to properly initialize spec.commandLine() reference
+    try {
+      cmd.parseArgs();
+    } catch (Exception e) {
+      // Ignore parse errors for missing required options - we'll set fields directly in tests
+    }
     importCommand.spec = cmd.getCommandSpec();
   }
 
@@ -67,4 +73,44 @@ private void deleteFile(Path file) {
       LOGGER.error("Failed to delete file: {}", file, e);
     }
   }
+
+  @Test
+  void call_withBothThreadsAndMaxThreads_shouldThrowException() throws Exception {
+    Path configFile = tempDir.resolve("config.properties");
+    Files.createFile(configFile);
+    Path importFile = tempDir.resolve("import.json");
+    Files.createFile(importFile);
+
+    // Simulate command line parsing with both deprecated and new options
+    String[] args = {
+      "--config",
+      configFile.toString(),
+      "--file",
+      importFile.toString(),
+      "--namespace",
+      "sample",
+      "--table",
+      "table",
+      "--threads",
+      "8",
+      "--max-threads",
+      "16"
+    };
+    ImportCommand command = new ImportCommand();
+    CommandLine cmd = new CommandLine(command);
+    // Parse args - this will trigger our validation
+    cmd.parseArgs(args);
+
+    // Now call the command, which should throw the validation error
+    CommandLine.ParameterException thrown =
+        assertThrows(
+            CommandLine.ParameterException.class,
+            command::call,
+            "Expected to throw ParameterException when both deprecated and new options are specified");
+    org.junit.jupiter.api.Assertions.assertTrue(
+        thrown
+            .getMessage()
+            .contains(
+                "Cannot specify both deprecated option '--threads' and new option '--max-threads'"));
+  }
 }
diff --git a/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java b/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
index d150d4df00..9936b9b2a6 100644
--- a/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
+++ b/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
@@ -210,6 +210,12 @@ public enum DataLoaderError implements ScalarDbError {
       Category.USER_ERROR, "0055", "Transaction size must be greater than 0", "", ""),
   INVALID_MAX_THREADS(
       Category.USER_ERROR, "0056", "Number of max threads must be greater than 0", "", ""),
+  DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED(
+      Category.USER_ERROR,
+      "0057",
+      "Cannot specify both deprecated option '%s' and new option '%s'. Please use '%s' instead",
+      "",
+      ""),
 
   //
   // Errors for the internal error category

From c60743576e6d01c4e18ef351297d1888410685b2 Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Tue, 14 Oct 2025 13:04:02 +0900
Subject: [PATCH 2/5] Add more unit test cases

---
 .../command/dataexport/ExportCommandTest.java | 70 +++++++++++++++++--
 .../command/dataimport/ImportCommandTest.java | 38 +++++++++-
 2 files changed, 101 insertions(+), 7 deletions(-)

diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
index a7382516be..c2e79374f4 100755
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
@@ -1,13 +1,14 @@
 package com.scalar.db.dataloader.cli.command.dataexport;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.scalar.db.dataloader.core.DataLoaderError;
 import com.scalar.db.dataloader.core.FileFormat;
 import java.io.File;
 import java.nio.file.Paths;
 import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import picocli.CommandLine;
@@ -54,8 +55,7 @@ void call_withBlankScalarDBConfigurationFile_shouldThrowException() {
             IllegalArgumentException.class,
             exportCommand::call,
             "Expected to throw FileNotFound exception as configuration path is invalid");
-    Assertions.assertEquals(
-        DataLoaderError.CONFIG_FILE_PATH_BLANK.buildMessage(), thrown.getMessage());
+    assertEquals(DataLoaderError.CONFIG_FILE_PATH_BLANK.buildMessage(), thrown.getMessage());
   }
 
   @Test
@@ -68,7 +68,7 @@ void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exceptio
     exportCommand.outputDirectory = "";
     exportCommand.outputFileName = "sample.json";
     exportCommand.outputFormat = FileFormat.JSON;
-    Assertions.assertEquals(1, exportCommand.call());
+    assertEquals(1, exportCommand.call());
   }
 
   @Test
@@ -97,7 +97,7 @@ void call_withBothStartExclusiveAndStartInclusive_shouldThrowException() {
             CommandLine.ParameterException.class,
             command::call,
             "Expected to throw ParameterException when both deprecated and new options are specified");
-    Assertions.assertTrue(
+    assertTrue(
         thrown
             .getMessage()
             .contains(
@@ -130,10 +130,68 @@ void call_withBothEndExclusiveAndEndInclusive_shouldThrowException() {
             CommandLine.ParameterException.class,
             command::call,
             "Expected to throw ParameterException when both deprecated and new options are specified");
-    Assertions.assertTrue(
+    assertTrue(
         thrown
             .getMessage()
             .contains(
                 "Cannot specify both deprecated option '--end-exclusive' and new option '--end-inclusive'"));
   }
+
+  @Test
+  void call_withOnlyDeprecatedStartExclusive_shouldApplyInvertedValue() {
+    // Simulate command line parsing with only deprecated option
+    String[] args = {
+      "--config",
+      "scalardb.properties",
+      "--namespace",
+      "scalar",
+      "--table",
+      "asset",
+      "--format",
+      "JSON",
+      "--start-exclusive=true"
+    };
+    ExportCommand command = new ExportCommand();
+    CommandLine cmd = new CommandLine(command);
+    cmd.parseArgs(args);
+
+    // Verify the deprecated value was parsed
+    assertEquals(true, command.startExclusiveDeprecated);
+
+    // Apply deprecated options (this is what the command does after validation)
+    command.applyDeprecatedOptions();
+
+    // Verify the value was applied with inverted logic
+    // start-exclusive=true should become start-inclusive=false
+    assertEquals(false, command.scanStartInclusive);
+  }
+
+  @Test
+  void call_withOnlyDeprecatedEndExclusive_shouldApplyInvertedValue() {
+    // Simulate command line parsing with only deprecated option
+    String[] args = {
+      "--config",
+      "scalardb.properties",
+      "--namespace",
+      "scalar",
+      "--table",
+      "asset",
+      "--format",
+      "JSON",
+      "--end-exclusive=false"
+    };
+    ExportCommand command = new ExportCommand();
+    CommandLine cmd = new CommandLine(command);
+    cmd.parseArgs(args);
+
+    // Verify the deprecated value was parsed
+    assertEquals(false, command.endExclusiveDeprecated);
+
+    // Apply deprecated options (this is what the command does after validation)
+    command.applyDeprecatedOptions();
+
+    // Verify the value was applied with inverted logic
+    // end-exclusive=false should become end-inclusive=true
+    assertEquals(true, command.scanEndInclusive);
+  }
 }
diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
index 5737b5dfb9..cfe1a8af48 100755
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommandTest.java
@@ -1,6 +1,8 @@
 package com.scalar.db.dataloader.cli.command.dataimport;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.scalar.db.dataloader.core.FileFormat;
 import com.scalar.db.dataloader.core.dataimport.ImportMode;
@@ -107,10 +109,44 @@ void call_withBothThreadsAndMaxThreads_shouldThrowException() throws Exception {
             CommandLine.ParameterException.class,
             command::call,
             "Expected to throw ParameterException when both deprecated and new options are specified");
-    org.junit.jupiter.api.Assertions.assertTrue(
+    assertTrue(
         thrown
             .getMessage()
             .contains(
                 "Cannot specify both deprecated option '--threads' and new option '--max-threads'"));
   }
+
+  @Test
+  void call_withOnlyDeprecatedThreads_shouldApplyValue() throws Exception {
+    Path configFile = tempDir.resolve("config.properties");
+    Files.createFile(configFile);
+    Path importFile = tempDir.resolve("import.json");
+    Files.createFile(importFile);
+
+    // Simulate command line parsing with only deprecated option
+    String[] args = {
+      "--config",
+      configFile.toString(),
+      "--file",
+      importFile.toString(),
+      "--namespace",
+      "sample",
+      "--table",
+      "table",
+      "--threads",
+      "12"
+    };
+    ImportCommand command = new ImportCommand();
+    CommandLine cmd = new CommandLine(command);
+    cmd.parseArgs(args);
+
+    // Verify the deprecated value was parsed
+    assertEquals(12, command.threadsDeprecated);
+
+    // Apply deprecated options (this is what the command does after validation)
+    command.applyDeprecatedOptions();
+
+    // Verify the value was applied to maxThreads
+    assertEquals(12, command.maxThreads);
+  }
 }

From 5ba96eaafa252015a882aba6e5b6589ecda6e6b1 Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Tue, 14 Oct 2025 13:14:58 +0900
Subject: [PATCH 3/5] Move repeated validation to util class method

---
 .../cli/command/dataexport/ExportCommand.java |  36 ++---
 .../cli/command/dataimport/ImportCommand.java |  21 +--
 .../cli/util/CommandLineInputUtils.java       |  26 ++++
 .../cli/util/CommandLineInputUtilsTest.java   | 125 ++++++++++++++++++
 4 files changed, 168 insertions(+), 40 deletions(-)

diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
index 4bd94c36d7..712a57c12c 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommand.java
@@ -1,5 +1,6 @@
 package com.scalar.db.dataloader.cli.command.dataexport;
 
+import static com.scalar.db.dataloader.cli.util.CommandLineInputUtils.validateDeprecatedOptionPair;
 import static com.scalar.db.dataloader.cli.util.CommandLineInputUtils.validatePositiveValue;
 import static java.nio.file.StandardOpenOption.APPEND;
 import static java.nio.file.StandardOpenOption.CREATE;
@@ -115,31 +116,16 @@ public Integer call() throws Exception {
    * @throws CommandLine.ParameterException if both old and new options are specified
    */
   private void validateDeprecatedOptions() {
-    boolean hasDeprecatedStartExclusive =
-        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_START_EXCLUSIVE_OPTION);
-    boolean hasNewStartInclusive =
-        spec.commandLine().getParseResult().hasMatchedOption(START_INCLUSIVE_OPTION)
-            || spec.commandLine().getParseResult().hasMatchedOption(START_INCLUSIVE_OPTION_SHORT);
-
-    if (hasDeprecatedStartExclusive && hasNewStartInclusive) {
-      throw new CommandLine.ParameterException(
-          spec.commandLine(),
-          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
-              DEPRECATED_START_EXCLUSIVE_OPTION, START_INCLUSIVE_OPTION, START_INCLUSIVE_OPTION));
-    }
-
-    boolean hasDeprecatedEndExclusive =
-        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_END_EXCLUSIVE_OPTION);
-    boolean hasNewEndInclusive =
-        spec.commandLine().getParseResult().hasMatchedOption(END_INCLUSIVE_OPTION)
-            || spec.commandLine().getParseResult().hasMatchedOption(END_INCLUSIVE_OPTION_SHORT);
-
-    if (hasDeprecatedEndExclusive && hasNewEndInclusive) {
-      throw new CommandLine.ParameterException(
-          spec.commandLine(),
-          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
-              DEPRECATED_END_EXCLUSIVE_OPTION, END_INCLUSIVE_OPTION, END_INCLUSIVE_OPTION));
-    }
+    validateDeprecatedOptionPair(
+        spec.commandLine(),
+        DEPRECATED_START_EXCLUSIVE_OPTION,
+        START_INCLUSIVE_OPTION,
+        START_INCLUSIVE_OPTION_SHORT);
+    validateDeprecatedOptionPair(
+        spec.commandLine(),
+        DEPRECATED_END_EXCLUSIVE_OPTION,
+        END_INCLUSIVE_OPTION,
+        END_INCLUSIVE_OPTION_SHORT);
   }
 
   private String getScalarDbPropertiesFilePath() {
diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
index 3701330be1..73f40b0577 100755
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/dataimport/ImportCommand.java
@@ -1,5 +1,6 @@
 package com.scalar.db.dataloader.cli.command.dataimport;
 
+import static com.scalar.db.dataloader.cli.util.CommandLineInputUtils.validateDeprecatedOptionPair;
 import static com.scalar.db.dataloader.cli.util.CommandLineInputUtils.validatePositiveValue;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -280,21 +281,11 @@ private Optional<ControlFile> parseControlFileFromPath(String controlFilePath) {
    * @throws ParameterException if both old and new options are specified
    */
   private void validateDeprecatedOptions() {
-    // Using getParseResult allows us to check if the argument was specified or not, regardless of
-    // the default option
-    boolean hasDeprecatedThreads =
-        spec.commandLine().getParseResult().hasMatchedOption(DEPRECATED_THREADS_OPTION);
-    boolean hasNewMaxThreads =
-        spec.commandLine().getParseResult().hasMatchedOption(MAX_THREADS_OPTION)
-            || spec.commandLine().getParseResult().hasMatchedOption(MAX_THREADS_OPTION_SHORT);
-
-    // Throw exception if both are specified
-    if (hasDeprecatedThreads && hasNewMaxThreads) {
-      throw new ParameterException(
-          spec.commandLine(),
-          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
-              DEPRECATED_THREADS_OPTION, MAX_THREADS_OPTION, MAX_THREADS_OPTION));
-    }
+    validateDeprecatedOptionPair(
+        spec.commandLine(),
+        DEPRECATED_THREADS_OPTION,
+        MAX_THREADS_OPTION,
+        MAX_THREADS_OPTION_SHORT);
   }
 
   /**
diff --git a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtils.java b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtils.java
index baea5e1970..4667b40615 100644
--- a/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtils.java
+++ b/data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtils.java
@@ -61,4 +61,30 @@ public static void validatePositiveValue(
       throw new CommandLine.ParameterException(commandLine, error.buildMessage());
     }
   }
+
+  /**
+   * Validates that a deprecated option and its replacement are not both specified. If both options
+   * are detected, it throws a {@link picocli.CommandLine.ParameterException} with an appropriate
+   * error message.
+   *
+   * @param commandLine the {@link CommandLine} instance used to provide context for the exception
+   * @param deprecatedOption the deprecated option name
+   * @param newOption the new option name
+   * @param newOptionShort the short form of the new option name
+   * @throws CommandLine.ParameterException if both deprecated and new options are specified
+   */
+  public static void validateDeprecatedOptionPair(
+      CommandLine commandLine, String deprecatedOption, String newOption, String newOptionShort) {
+    boolean hasDeprecated = commandLine.getParseResult().hasMatchedOption(deprecatedOption);
+    boolean hasNew =
+        commandLine.getParseResult().hasMatchedOption(newOption)
+            || commandLine.getParseResult().hasMatchedOption(newOptionShort);
+
+    if (hasDeprecated && hasNew) {
+      throw new CommandLine.ParameterException(
+          commandLine,
+          DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+              deprecatedOption, newOption, newOption));
+    }
+  }
 }
diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtilsTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtilsTest.java
index 3a07c267d5..3fd774a6d0 100644
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtilsTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/util/CommandLineInputUtilsTest.java
@@ -6,6 +6,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import com.scalar.db.dataloader.core.DataLoaderError;
 import java.util.Map;
@@ -185,4 +186,128 @@ public void validatePositiveValue_differentErrorTypes_shouldUseCorrectErrorMessa
             .getMessage()
             .contains(DataLoaderError.INVALID_DATA_CHUNK_QUEUE_SIZE.buildMessage()));
   }
+
+  @Test
+  public void validateDeprecatedOptionPair_onlyDeprecatedSpecified_shouldNotThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(true);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(false);
+
+    // Act & Assert - No exception should be thrown
+    assertDoesNotThrow(
+        () ->
+            CommandLineInputUtils.validateDeprecatedOptionPair(
+                commandLine, "--old-option", "--new-option", "-n"));
+  }
+
+  @Test
+  public void validateDeprecatedOptionPair_onlyNewOptionSpecified_shouldNotThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(true);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(false);
+
+    // Act & Assert - No exception should be thrown
+    assertDoesNotThrow(
+        () ->
+            CommandLineInputUtils.validateDeprecatedOptionPair(
+                commandLine, "--old-option", "--new-option", "-n"));
+  }
+
+  @Test
+  public void
+      validateDeprecatedOptionPair_onlyNewOptionShortFormSpecified_shouldNotThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(true);
+
+    // Act & Assert - No exception should be thrown
+    assertDoesNotThrow(
+        () ->
+            CommandLineInputUtils.validateDeprecatedOptionPair(
+                commandLine, "--old-option", "--new-option", "-n"));
+  }
+
+  @Test
+  public void validateDeprecatedOptionPair_neitherSpecified_shouldNotThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(false);
+
+    // Act & Assert - No exception should be thrown
+    assertDoesNotThrow(
+        () ->
+            CommandLineInputUtils.validateDeprecatedOptionPair(
+                commandLine, "--old-option", "--new-option", "-n"));
+  }
+
+  @Test
+  public void validateDeprecatedOptionPair_bothSpecified_shouldThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(true);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(true);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(false);
+
+    // Act & Assert
+    CommandLine.ParameterException exception =
+        assertThrows(
+            CommandLine.ParameterException.class,
+            () ->
+                CommandLineInputUtils.validateDeprecatedOptionPair(
+                    commandLine, "--old-option", "--new-option", "-n"));
+
+    // Verify the exception message contains the error message
+    assertTrue(
+        exception
+            .getMessage()
+            .contains(
+                DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+                    "--old-option", "--new-option", "--new-option")));
+  }
+
+  @Test
+  public void
+      validateDeprecatedOptionPair_deprecatedAndNewShortFormSpecified_shouldThrowException() {
+    // Arrange
+    CommandLine commandLine = mock(CommandLine.class);
+    CommandLine.ParseResult parseResult = mock(CommandLine.ParseResult.class);
+    when(commandLine.getParseResult()).thenReturn(parseResult);
+    when(parseResult.hasMatchedOption("--old-option")).thenReturn(true);
+    when(parseResult.hasMatchedOption("--new-option")).thenReturn(false);
+    when(parseResult.hasMatchedOption("-n")).thenReturn(true);
+
+    // Act & Assert
+    CommandLine.ParameterException exception =
+        assertThrows(
+            CommandLine.ParameterException.class,
+            () ->
+                CommandLineInputUtils.validateDeprecatedOptionPair(
+                    commandLine, "--old-option", "--new-option", "-n"));
+
+    // Verify the exception message contains the error message
+    assertTrue(
+        exception
+            .getMessage()
+            .contains(
+                DataLoaderError.DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED.buildMessage(
+                    "--old-option", "--new-option", "--new-option")));
+  }
 }

From a2563dc769de14b232be181b5589ac4fb4df26db Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Tue, 14 Oct 2025 13:21:32 +0900
Subject: [PATCH 4/5] Convert test to ParameterizedTest

---
 .../command/dataexport/ExportCommandTest.java | 62 +++++++++----------
 1 file changed, 29 insertions(+), 33 deletions(-)

diff --git a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
index c2e79374f4..907140e46f 100755
--- a/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
+++ b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
@@ -73,39 +73,32 @@ void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exceptio
 
   @Test
   void call_withBothStartExclusiveAndStartInclusive_shouldThrowException() {
-    // Simulate command line parsing with both deprecated and new options
-    String[] args = {
-      "--config",
-      "scalardb.properties",
-      "--namespace",
-      "scalar",
-      "--table",
-      "asset",
-      "--format",
-      "JSON",
-      "--start-exclusive=false",
-      "--start-inclusive=false"
-    };
-    ExportCommand command = new ExportCommand();
-    CommandLine cmd = new CommandLine(command);
-    // Parse args - this will trigger our validation
-    cmd.parseArgs(args);
-
-    // Now call the command, which should throw the validation error
-    CommandLine.ParameterException thrown =
-        assertThrows(
-            CommandLine.ParameterException.class,
-            command::call,
-            "Expected to throw ParameterException when both deprecated and new options are specified");
-    assertTrue(
-        thrown
-            .getMessage()
-            .contains(
-                "Cannot specify both deprecated option '--start-exclusive' and new option '--start-inclusive'"));
+    assertBothDeprecatedAndNewOptionsThrowException(
+        "--start-exclusive=false",
+        "--start-inclusive=false",
+        "--start-exclusive",
+        "--start-inclusive");
   }
 
   @Test
   void call_withBothEndExclusiveAndEndInclusive_shouldThrowException() {
+    assertBothDeprecatedAndNewOptionsThrowException(
+        "--end-exclusive=false", "--end-inclusive=false", "--end-exclusive", "--end-inclusive");
+  }
+
+  /**
+   * Helper method to test that using both deprecated and new options together throws an exception.
+   *
+   * @param deprecatedOptionArg the deprecated option with value (e.g., "--start-exclusive=false")
+   * @param newOptionArg the new option with value (e.g., "--start-inclusive=false")
+   * @param deprecatedOptionName the deprecated option name for error message verification
+   * @param newOptionName the new option name for error message verification
+   */
+  private void assertBothDeprecatedAndNewOptionsThrowException(
+      String deprecatedOptionArg,
+      String newOptionArg,
+      String deprecatedOptionName,
+      String newOptionName) {
     // Simulate command line parsing with both deprecated and new options
     String[] args = {
       "--config",
@@ -116,12 +109,11 @@ void call_withBothEndExclusiveAndEndInclusive_shouldThrowException() {
       "asset",
       "--format",
       "JSON",
-      "--end-exclusive=false",
-      "--end-inclusive=false"
+      deprecatedOptionArg,
+      newOptionArg
     };
     ExportCommand command = new ExportCommand();
     CommandLine cmd = new CommandLine(command);
-    // Parse args - this will trigger our validation
     cmd.parseArgs(args);
 
     // Now call the command, which should throw the validation error
@@ -134,7 +126,11 @@ void call_withBothEndExclusiveAndEndInclusive_shouldThrowException() {
         thrown
             .getMessage()
             .contains(
-                "Cannot specify both deprecated option '--end-exclusive' and new option '--end-inclusive'"));
+                "Cannot specify both deprecated option '"
+                    + deprecatedOptionName
+                    + "' and new option '"
+                    + newOptionName
+                    + "'"));
   }
 
   @Test

From 47524ad891392f079b9c6b107686078e94d72680 Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Tue, 14 Oct 2025 16:37:58 +0900
Subject: [PATCH 5/5] Update
 data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java

Co-authored-by: Mitsunori Komatsu <komamitsu@gmail.com>
---
 .../java/com/scalar/db/dataloader/core/DataLoaderError.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java b/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
index 9936b9b2a6..605da3bc94 100644
--- a/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
+++ b/data-loader/core/src/main/java/com/scalar/db/dataloader/core/DataLoaderError.java
@@ -213,7 +213,7 @@ public enum DataLoaderError implements ScalarDbError {
   DEPRECATED_AND_NEW_OPTION_BOTH_SPECIFIED(
       Category.USER_ERROR,
       "0057",
-      "Cannot specify both deprecated option '%s' and new option '%s'. Please use '%s' instead",
+      "Cannot specify both deprecated option '%s' and new option '%s'. Please use only '%s'",
       "",
       ""),