From 8da01f7f42e6c20b62cbd6a68436a14df5dfc31b Mon Sep 17 00:00:00 2001
From: Peckstadt Yves <peckstadt.yves@gmail.com>
Date: Wed, 5 Nov 2025 19:59:22 +0900
Subject: [PATCH] Add deprecated Data Loader CLI arguments (#3041)

---
 .../cli/command/dataexport/ExportCommand.java |  21 +++
 .../dataexport/ExportCommandOptions.java      |  41 +++++
 .../cli/command/dataimport/ImportCommand.java |  16 ++
 .../dataimport/ImportCommandOptions.java      |  26 ++++
 .../cli/util/CommandLineInputUtils.java       |  26 ++++
 .../command/dataexport/ExportCommandTest.java | 147 +++++++++++++++++-
 .../command/dataimport/ImportCommandTest.java |  82 ++++++++++
 .../cli/util/CommandLineInputUtilsTest.java   | 125 +++++++++++++++
 .../db/dataloader/core/DataLoaderError.java   |   6 +
 9 files changed, 484 insertions(+), 6 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..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;
@@ -51,6 +52,8 @@ public class ExportCommand extends ExportCommandOptions implements Callable<Inte
 
   @Override
   public Integer call() throws Exception {
+    validateDeprecatedOptions();
+    applyDeprecatedOptions();
     String scalarDbPropertiesFilePath = getScalarDbPropertiesFilePath();
 
     try {
@@ -107,6 +110,24 @@ 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() {
+    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() {
     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..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;
@@ -52,6 +53,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 +275,19 @@ 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() {
+    validateDeprecatedOptionPair(
+        spec.commandLine(),
+        DEPRECATED_THREADS_OPTION,
+        MAX_THREADS_OPTION,
+        MAX_THREADS_OPTION_SHORT);
+  }
+
   /**
    * 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/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/command/dataexport/ExportCommandTest.java b/data-loader/cli/src/test/java/com/scalar/db/dataloader/cli/command/dataexport/ExportCommandTest.java
index 56518f8e71..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
@@ -1,17 +1,35 @@
 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;
 
 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 +42,6 @@ void removeFileIfCreated() {
 
   @Test
   void call_withBlankScalarDBConfigurationFile_shouldThrowException() {
-    ExportCommand exportCommand = new ExportCommand();
     exportCommand.configFilePath = "";
     exportCommand.dataChunkSize = 100;
     exportCommand.maxThreads = 4;
@@ -38,13 +55,11 @@ 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
   void call_withInvalidScalarDBConfigurationFile_shouldReturnOne() throws Exception {
-    ExportCommand exportCommand = new ExportCommand();
     exportCommand.configFilePath = "scalardb.properties";
     exportCommand.dataChunkSize = 100;
     exportCommand.maxThreads = 4;
@@ -53,6 +68,126 @@ 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
+  void call_withBothStartExclusiveAndStartInclusive_shouldThrowException() {
+    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",
+      "scalardb.properties",
+      "--namespace",
+      "scalar",
+      "--table",
+      "asset",
+      "--format",
+      "JSON",
+      deprecatedOptionArg,
+      newOptionArg
+    };
+    ExportCommand command = new ExportCommand();
+    CommandLine cmd = new CommandLine(command);
+    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 '"
+                    + deprecatedOptionName
+                    + "' and new option '"
+                    + newOptionName
+                    + "'"));
+  }
+
+  @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 1f24c8d86f..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;
@@ -27,6 +29,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 +75,78 @@ 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");
+    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);
+  }
 }
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")));
+  }
 }
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..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
@@ -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 only '%s'",
+      "",
+      ""),
 
   //
   // Errors for the internal error category