Removed unused code and udpated java doc comments

Author: inv-jishnu

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

@@ -1,6 +1,5 @@
 package com.scalar.db.dataloader.core.dataimport.dao;
 
-import com.scalar.db.api.DistributedStorage;
 import com.scalar.db.api.DistributedTransaction;
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.Get;
@@ -10,16 +9,13 @@
 import com.scalar.db.api.Result;
 import com.scalar.db.api.Scan;
 import com.scalar.db.api.ScanBuilder;
-import com.scalar.db.api.Scanner;
 import com.scalar.db.api.TransactionManagerCrudOperable;
 import com.scalar.db.dataloader.core.DataLoaderError;
 import com.scalar.db.dataloader.core.ScanRange;
-import com.scalar.db.exception.storage.ExecutionException;
 import com.scalar.db.exception.transaction.CrudException;
 import com.scalar.db.exception.transaction.UnknownTransactionStatusException;
 import com.scalar.db.io.Column;
 import com.scalar.db.io.Key;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.NoSuchElementException;
@@ -162,43 +158,6 @@ public void put(
     }
   }
 
-  /**
-   * Scan a ScalarDB table
-   *
-   * @param namespace ScalarDB namespace
-   * @param table ScalarDB table name
-   * @param partitionKey Partition key used in ScalarDB scan
-   * @param range Optional range to set ScalarDB scan start and end values
-   * @param sorts Optional scan clustering key sorting values
-   * @param projections List of column projection to use during scan
-   * @param limit Scan limit value
-   * @param storage Distributed storage for ScalarDB connection that is running in storage mode
-   * @return List of ScalarDB scan results
-   * @throws ScalarDbDaoException if scan fails
-   */
-  public List<Result> scan(
-      String namespace,
-      String table,
-      Key partitionKey,
-      ScanRange range,
-      List<Scan.Ordering> sorts,
-      List<String> projections,
-      int limit,
-      DistributedStorage storage)
-      throws ScalarDbDaoException {
-    // Create scan
-    Scan scan = createScan(namespace, table, partitionKey, range, sorts, projections, limit);
-
-    // scan data
-    try {
-      try (Scanner scanner = storage.scan(scan)) {
-        return scanner.all();
-      }
-    } catch (ExecutionException | IOException e) {
-      throw new ScalarDbDaoException(DataLoaderError.ERROR_SCAN.buildMessage(e.getMessage()), e);
-    }
-  }
-
   /**
    * Scan a ScalarDB table
    *

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

@@ -1,6 +1,5 @@
 package com.scalar.db.dataloader.core.dataimport.task;
 
-import com.scalar.db.api.DistributedStorage;
 import com.scalar.db.api.DistributedTransactionManager;
 import com.scalar.db.api.Result;
 import com.scalar.db.dataloader.core.dataimport.dao.ScalarDbDaoException;
@@ -10,54 +9,56 @@
 import java.util.Optional;
 
 /**
- * An import task that interacts with a {@link DistributedStorage} for data retrieval and manager
- * operations.
+ * An import task that performs data operations using a {@link DistributedTransactionManager}.
  *
- * <p>This class extends {@link ImportTask} and provides concrete implementations for fetching and
- * storing records using a {@link DistributedStorage} instance. It acts as a bridge between the
- * import process and the underlying distributed manager system.
+ * <p>This class extends {@link ImportTask} and provides concrete implementations for retrieving and
+ * storing records using a {@link DistributedTransactionManager} instance. It serves as a bridge
+ * between the import process and the underlying transactional data management layer in ScalarDB.
  *
- * <p>The task handles both read and write operations:
+ * <p>The task supports both read and write operations:
  *
  * <ul>
- *   <li>Reading existing records using partition and clustering keys
- *   <li>Storing new or updated records with their associated columns
+ *   <li>Retrieving existing records using partition and optional clustering keys.
+ *   <li>Inserting or updating records with their associated column values.
  * </ul>
  *
- * <p>All manager operations are performed through the provided {@link DistributedStorage} instance,
- * which must be properly initialized before creating this task.
+ * <p>All data operations are delegated to the DAO configured within {@link ImportTaskParams},
+ * executed through the provided {@link DistributedTransactionManager}. The manager must be properly
+ * initialized and connected before creating an instance of this class.
  */
 public class ImportStorageTask extends ImportTask {
 
   private final DistributedTransactionManager manager;
 
   /**
-   * Constructs an {@code ImportStorageTask} with the specified parameters and manager.
+   * Constructs an {@code ImportStorageTask} with the specified parameters and transaction manager.
    *
    * @param params the import task parameters containing configuration and DAO objects
-   * @param manager the distributed manager instance to be used for data operations
-   * @throws NullPointerException if either params or manager is null
+   * @param manager the {@link DistributedTransactionManager} instance used for transactional data
+   *     operations
+   * @throws NullPointerException if either {@code params} or {@code manager} is {@code null}
    */
   public ImportStorageTask(ImportTaskParams params, DistributedTransactionManager manager) {
     super(params);
     this.manager = manager;
   }
 
   /**
-   * Retrieves a data record from the distributed manager using the specified keys.
+   * Retrieves a data record from the database using the specified keys.
    *
-   * <p>This method attempts to fetch a single record from the specified table using both partition
-   * and clustering keys. The operation is performed through the configured DAO using the associated
-   * manager instance.
+   * <p>This method attempts to fetch a single record from the given table using the provided
+   * partition and optional clustering keys. The retrieval is executed through the DAO configured in
+   * {@link ImportTaskParams}, utilizing the associated {@link DistributedTransactionManager}.
    *
-   * @param namespace the namespace of the table to query
-   * @param tableName the name of the table to query
+   * @param namespace the ScalarDB namespace of the target table
+   * @param tableName the name of the target table
    * @param partitionKey the partition key identifying the record's partition
-   * @param clusteringKey the clustering key for further record identification within the partition
-   * @return an {@link Optional} containing the {@link Result} if the record exists, otherwise an
-   *     empty {@link Optional}
-   * @throws ScalarDbDaoException if an error occurs during the retrieval operation, such as
-   *     connection issues or invalid table/namespace
+   * @param clusteringKey the clustering key for uniquely identifying the record within the
+   *     partition
+   * @return an {@link Optional} containing the {@link Result} if a record exists, or an empty
+   *     {@link Optional} if no matching record is found
+   * @throws ScalarDbDaoException if an error occurs during the retrieval operation, such as a
+   *     connection failure or invalid table/namespace
    */
   @Override
   protected Optional<Result> getDataRecord(
@@ -67,17 +68,18 @@ protected Optional<Result> getDataRecord(
   }
 
   /**
-   * Saves a record into the distributed manager with the specified keys and columns.
+   * Saves or updates a record in the database using the specified keys and column values.
    *
    * <p>This method writes or updates a record in the specified table using the provided keys and
-   * column values. The operation is performed through the configured DAO using the associated
-   * manager instance.
+   * columns. The operation is performed through the DAO configured in {@link ImportTaskParams},
+   * utilizing the associated {@link DistributedTransactionManager}.
    *
-   * @param namespace the namespace of the target table
+   * @param namespace the ScalarDB namespace of the target table
    * @param tableName the name of the target table
    * @param partitionKey the partition key determining where the record will be stored
-   * @param clusteringKey the clustering key for organizing records within the partition
-   * @param columns the list of columns containing the record's data to be saved
+   * @param clusteringKey the clustering key for uniquely identifying the record within the
+   *     partition
+   * @param columns the list of columns containing the data to be stored
    * @throws ScalarDbDaoException if an error occurs during the save operation, such as connection
    *     issues, invalid data types, or constraint violations
    */