Add TableMetadataService and utils

core/src/main/java/com/scalar/db/common/error/CoreError.java

@@ -610,6 +610,16 @@ public enum CoreError implements ScalarDbError {
       "Invalid file extension: %s. Allowed extensions are: %s",
       "",
       ""),
+  DATA_LOADER_INVALID_COLUMN_KEY_PARSING_FAILED(
+      Category.USER_ERROR, "0136", "Invalid key: Column %s does not exist in the table.", "", ""),
+  DATA_LOADER_INVALID_VALUE_KEY_PARSING_FAILED(
+      Category.USER_ERROR, "0137", "Parsing of key value %s failed. Details:%s.", "", ""),
+  DATA_LOADER_INVALID_BASE64_ENCODING_FOR_COLUMN_VALUE(
+      Category.USER_ERROR, "0138", "Invalid base64 encoding for blob value for column %s", "", ""),
+  DATA_LOADER_INVALID_NUMBER_FORMAT_FOR_COLUMN_VALUE(
+      Category.USER_ERROR, "0139", "Invalid number specified for column %s", "", ""),
+  DATA_LOADER_MISSING_NAMESPACE_OR_TABLE(
+      Category.USER_ERROR, "0140", "Missing namespace or table: %s, %s.", "", ""),
 
   //
   // Errors for the concurrency error category

data-loader/build.gradle

@@ -18,5 +18,10 @@ subprojects {
         // Apache Commons
         implementation("org.apache.commons:commons-lang3:${apacheCommonsLangVersion}")
         implementation("commons-io:commons-io:${apacheCommonsIoVersion}")
+
+        // Mockito
+        testImplementation "org.mockito:mockito-core:${mockitoVersion}"
+        testImplementation "org.mockito:mockito-inline:${mockitoVersion}"
+        testImplementation "org.mockito:mockito-junit-jupiter:${mockitoVersion}"
     }
 }

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

@@ -1,5 +1,6 @@
 package com.scalar.db.dataloader.cli.command;
 
+import com.scalar.db.dataloader.core.ColumnKeyValue;
 import picocli.CommandLine;
 
 /**

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

@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import com.scalar.db.dataloader.core.ColumnKeyValue;
 import org.junit.jupiter.api.Test;
 
 class ColumnKeyValueConverterTest {

data-loader/core/build.gradle

@@ -7,6 +7,9 @@ plugins {
 archivesBaseName = "scalardb-data-loader-core"
 
 dependencies {
+    // ScalarDB core
+    implementation project(':core')
+
     // for SpotBugs
     compileOnly "com.github.spotbugs:spotbugs-annotations:${spotbugsVersion}"
     testCompileOnly "com.github.spotbugs:spotbugs-annotations:${spotbugsVersion}"

data-loader/cli/src/main/java/com/scalar/db/dataloader/cli/command/ColumnKeyValue.java → data-loader/core/src/main/java/com/scalar/db/dataloader/core/ColumnKeyValue.java

@@ -1,4 +1,4 @@
-package com.scalar.db.dataloader.cli.command;
+package com.scalar.db.dataloader.core;
 
 /** Represents a key-value pair for a column and its corresponding value. */
 public class ColumnKeyValue {

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

@@ -0,0 +1,14 @@
+package com.scalar.db.dataloader.core.exception;
+
+/** Exception thrown when an error occurs while trying to encode or decode base64 values. */
+public class Base64Exception extends Exception {
+
+  /**
+   * Class constructor
+   *
+   * @param message Exception message
+   */
+  public Base64Exception(String message) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,12 @@
+package com.scalar.db.dataloader.core.exception;
+
+public class KeyParsingException extends Exception {
+
+  public KeyParsingException(String message) {
+    super(message);
+  }
+
+  public KeyParsingException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

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

@@ -0,0 +1,24 @@
+package com.scalar.db.dataloader.core.tablemetadata;
+
+/** A custom exception that encapsulates errors thrown by the TableMetaDataService */
+public class TableMetadataException extends Exception {
+
+  /**
+   * Class constructor
+   *
+   * @param message error message
+   * @param cause reason for exception
+   */
+  public TableMetadataException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  /**
+   * Class constructor
+   *
+   * @param message error message
+   */
+  public TableMetadataException(String message) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.scalar.db.dataloader.core.tablemetadata;
+
+/** Represents the request for metadata for a single ScalarDB table */
+public class TableMetadataRequest {
+
+  private final String namespace;
+  private final String tableName;
+
+  /**
+   * Class constructor
+   *
+   * @param namespace ScalarDB namespace
+   * @param tableName ScalarDB table name
+   */
+  public TableMetadataRequest(String namespace, String tableName) {
+    this.namespace = namespace;
+    this.tableName = tableName;
+  }
+
+  public String getNamespace() {
+    return namespace;
+  }
+
+  public String getTableName() {
+    return tableName;
+  }
+}

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

@@ -0,0 +1,73 @@
+package com.scalar.db.dataloader.core.tablemetadata;
+
+import com.scalar.db.api.TableMetadata;
+import com.scalar.db.common.error.CoreError;
+import com.scalar.db.dataloader.core.util.TableMetadataUtils;
+import com.scalar.db.exception.storage.ExecutionException;
+import com.scalar.db.service.StorageFactory;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A service class that provides methods to get TableMetadata for a given namespace and table name.
+ */
+public class TableMetadataService {
+
+  private final StorageFactory storageFactory;
+
+  /**
+   * Class constructor
+   *
+   * @param storageFactory a distributed storage admin
+   */
+  public TableMetadataService(StorageFactory storageFactory) {
+    this.storageFactory = storageFactory;
+  }
+
+  /**
+   * Returns the TableMetadata for the given namespace and table name.
+   *
+   * @param namespace ScalarDb namespace
+   * @param tableName ScalarDb table name
+   * @return TableMetadata
+   * @throws TableMetadataException if the namespace or table is missing
+   */
+  public TableMetadata getTableMetadata(String namespace, String tableName)
+      throws TableMetadataException {
+    try {
+      TableMetadata tableMetadata =
+          storageFactory.getStorageAdmin().getTableMetadata(namespace, tableName);
+      if (tableMetadata == null) {
+        throw new TableMetadataException(
+            CoreError.DATA_LOADER_MISSING_NAMESPACE_OR_TABLE.buildMessage(namespace, tableName));
+      }
+      return tableMetadata;
+    } catch (ExecutionException e) {
+      throw new TableMetadataException(
+          CoreError.DATA_LOADER_MISSING_NAMESPACE_OR_TABLE.buildMessage(namespace, tableName));
+    }
+  }
+
+  /**
+   * Returns the TableMetadata for the given list of TableMetadataRequest.
+   *
+   * @param requests List of TableMetadataRequest
+   * @return Map of TableMetadata
+   * @throws TableMetadataException if the namespace or table is missing
+   */
+  public Map<String, TableMetadata> getTableMetadata(Collection<TableMetadataRequest> requests)
+      throws TableMetadataException {
+    Map<String, TableMetadata> metadataMap = new HashMap<>();
+
+    for (TableMetadataRequest request : requests) {
+      String namespace = request.getNamespace();
+      String tableName = request.getTableName();
+      TableMetadata tableMetadata = getTableMetadata(namespace, tableName);
+      String key = TableMetadataUtils.getTableLookupKey(namespace, tableName);
+      metadataMap.put(key, tableMetadata);
+    }
+
+    return metadataMap;
+  }
+}

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

@@ -0,0 +1,74 @@
+package com.scalar.db.dataloader.core.util;
+
+import com.scalar.db.common.error.CoreError;
+import com.scalar.db.dataloader.core.exception.Base64Exception;
+import com.scalar.db.io.BigIntColumn;
+import com.scalar.db.io.BlobColumn;
+import com.scalar.db.io.BooleanColumn;
+import com.scalar.db.io.Column;
+import com.scalar.db.io.DataType;
+import com.scalar.db.io.DoubleColumn;
+import com.scalar.db.io.FloatColumn;
+import com.scalar.db.io.IntColumn;
+import com.scalar.db.io.TextColumn;
+import java.util.Base64;
+
+/** Utility class for dealing and creating ScalarDB Columns */
+public final class ColumnUtils {
+  private ColumnUtils() {
+    // restrict instantiation
+  }
+
+  /**
+   * Create a ScalarDB column from the given data type, column name, and value. Blob source values
+   * need to be base64 encoded.
+   *
+   * @param dataType Data type of the specified column
+   * @param columnName ScalarDB table column name
+   * @param value Value for the ScalarDB column
+   * @return ScalarDB column
+   * @throws Base64Exception if an error occurs while base64 decoding
+   */
+  public static Column<?> createColumnFromValue(DataType dataType, String columnName, String value)
+      throws Base64Exception {
+    try {
+      switch (dataType) {
+        case BOOLEAN:
+          return value != null
+              ? BooleanColumn.of(columnName, Boolean.parseBoolean(value))
+              : BooleanColumn.ofNull(columnName);
+        case INT:
+          return value != null
+              ? IntColumn.of(columnName, Integer.parseInt(value))
+              : IntColumn.ofNull(columnName);
+        case BIGINT:
+          return value != null
+              ? BigIntColumn.of(columnName, Long.parseLong(value))
+              : BigIntColumn.ofNull(columnName);
+        case FLOAT:
+          return value != null
+              ? FloatColumn.of(columnName, Float.parseFloat(value))
+              : FloatColumn.ofNull(columnName);
+        case DOUBLE:
+          return value != null
+              ? DoubleColumn.of(columnName, Double.parseDouble(value))
+              : DoubleColumn.ofNull(columnName);
+        case TEXT:
+          return value != null ? TextColumn.of(columnName, value) : TextColumn.ofNull(columnName);
+        case BLOB:
+          // Source blob values need to be base64 encoded
+          return value != null
+              ? BlobColumn.of(columnName, Base64.getDecoder().decode(value))
+              : BlobColumn.ofNull(columnName);
+        default:
+          throw new AssertionError();
+      }
+    } catch (NumberFormatException e) {
+      throw new NumberFormatException(
+          CoreError.DATA_LOADER_INVALID_NUMBER_FORMAT_FOR_COLUMN_VALUE.buildMessage(columnName));
+    } catch (IllegalArgumentException e) {
+      throw new Base64Exception(
+          CoreError.DATA_LOADER_INVALID_BASE64_ENCODING_FOR_COLUMN_VALUE.buildMessage(columnName));
+    }
+  }
+}

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

@@ -0,0 +1,63 @@
+package com.scalar.db.dataloader.core.util;
+
+import com.scalar.db.api.TableMetadata;
+import com.scalar.db.common.error.CoreError;
+import com.scalar.db.dataloader.core.ColumnKeyValue;
+import com.scalar.db.dataloader.core.exception.Base64Exception;
+import com.scalar.db.dataloader.core.exception.KeyParsingException;
+import com.scalar.db.io.Column;
+import com.scalar.db.io.DataType;
+import com.scalar.db.io.Key;
+import javax.annotation.Nullable;
+
+/** Utility class for creating and dealing with ScalarDB keys. */
+public final class KeyUtils {
+
+  private KeyUtils() {
+    // restrict instantiation
+  }
+
+  /**
+   * Convert a keyValue, in the format of <key>=<value>, to a ScalarDB Key instance.
+   *
+   * @param columnKeyValue A key value in the format of <key>=<value>
+   * @param tableMetadata Metadata for one ScalarDB table
+   * @return A new ScalarDB Key instance formatted by data type
+   * @throws KeyParsingException if there is an error parsing the key value
+   */
+  public static Key parseKeyValue(
+      @Nullable ColumnKeyValue columnKeyValue, TableMetadata tableMetadata)
+      throws KeyParsingException {
+    if (columnKeyValue == null) {
+      return null;
+    }
+    String columnName = columnKeyValue.getColumnName();
+    DataType columnDataType = tableMetadata.getColumnDataType(columnName);
+    if (columnDataType == null) {
+      throw new KeyParsingException(
+          CoreError.DATA_LOADER_INVALID_COLUMN_KEY_PARSING_FAILED.buildMessage(columnName));
+    }
+    try {
+      return createKey(columnDataType, columnName, columnKeyValue.getColumnValue());
+    } catch (Base64Exception e) {
+      throw new KeyParsingException(
+          CoreError.DATA_LOADER_INVALID_VALUE_KEY_PARSING_FAILED.buildMessage(
+              columnKeyValue.getColumnValue(), e.getMessage()));
+    }
+  }
+
+  /**
+   * Create a ScalarDB key based on the provided data type, column name, and value.
+   *
+   * @param dataType Data type of the specified column
+   * @param columnName ScalarDB table column name
+   * @param value Value for ScalarDB key
+   * @return ScalarDB Key instance
+   * @throws Base64Exception if there is an error creating the key value
+   */
+  public static Key createKey(DataType dataType, String columnName, String value)
+      throws Base64Exception {
+    Column<?> keyValue = ColumnUtils.createColumnFromValue(dataType, columnName, value);
+    return Key.newBuilder().add(keyValue).build();
+  }
+}