embulk-output-kintone 1.0.0 → 1.1.0

data/src/main/java/org/embulk/output/kintone/reducer/ReduceType.java

@@ -0,0 +1,190 @@
+package org.embulk.output.kintone.reducer;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+import org.embulk.output.kintone.KintoneColumnOption;
+import org.embulk.output.kintone.KintoneColumnType;
+import org.embulk.output.kintone.KintoneSortColumn;
+import org.embulk.spi.Column;
+import org.embulk.spi.time.Timestamp;
+import org.msgpack.value.ArrayValue;
+import org.msgpack.value.MapValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+
+public enum ReduceType {
+  BOOLEAN {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.NUMBER);
+      Supplier<Value> supplier =
+          () -> type.asValue(type.getFieldValue(Boolean.parseBoolean(value), option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return Comparator.comparing(Boolean::parseBoolean, order(order));
+    }
+  },
+  LONG {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.NUMBER);
+      Supplier<Value> supplier =
+          () -> type.asValue(type.getFieldValue(Long.parseLong(value), option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return Comparator.comparing(Long::parseLong, order(order));
+    }
+  },
+  DOUBLE {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.NUMBER);
+      Supplier<Value> supplier =
+          () -> type.asValue(type.getFieldValue(Double.parseDouble(value), option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return Comparator.comparing(Double::parseDouble, order(order));
+    }
+  },
+  STRING {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.MULTI_LINE_TEXT);
+      Supplier<Value> supplier = () -> type.asValue(type.getFieldValue(value, option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return order(order);
+    }
+  },
+  TIMESTAMP {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.DATETIME);
+      Supplier<Value> supplier =
+          () -> type.asValue(type.getFieldValue(Timestamp.ofInstant(Instant.parse(value)), option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return Comparator.comparing(Instant::parse, order(order));
+    }
+  },
+  JSON {
+    @Override
+    public MapValue value(String value, KintoneColumnOption option) {
+      KintoneColumnType type = KintoneColumnType.getType(option, KintoneColumnType.MULTI_LINE_TEXT);
+      Supplier<Value> supplier =
+          () -> type.asValue(type.getFieldValue(Reducer.PARSER.parse(value), option));
+      return value(type, value, supplier);
+    }
+
+    @Override
+    public Comparator<String> comparator(KintoneSortColumn.Order order) {
+      return order(order);
+    }
+  };
+  private static final Value NIL = ValueFactory.newNil();
+  private static final Value ID = ValueFactory.newString("id");
+  private static final Value TYPE = ValueFactory.newString("type");
+  private static final Value VALUE = ValueFactory.newString("value");
+  private static final Value KEY_SET = ValueFactory.newString("$$key_set");
+  private static final Value SORT_VALUE = ValueFactory.newString("$$sort_value");
+
+  public abstract MapValue value(String value, KintoneColumnOption option);
+
+  public abstract Comparator<String> comparator(KintoneSortColumn.Order order);
+
+  public static Comparator<String> comparator(Column column, KintoneSortColumn.Order order) {
+    return valueOf(column).comparator(order);
+  }
+
+  public static String asString(Value value, KintoneSortColumn sortColumn) {
+    return asString(sortValue(value).map().get(value(sortColumn.getName())));
+  }
+
+  public static boolean isEmpty(MapValue value) {
+    return value.values().stream()
+        .map(Value::asMapValue)
+        .map(MapValue::map)
+        .map(map -> map.get(VALUE))
+        .allMatch(Value::isNilValue);
+  }
+
+  public static Value value(String value) {
+    return value == null ? NIL : ValueFactory.newString(value);
+  }
+
+  public static MapValue value(Value value) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    Map<Value, Value> map = value.asMapValue().map();
+    builder.put(ID, map.get(ID));
+    builder.put(VALUE, value(map.get(VALUE).asMapValue().map(), map.get(KEY_SET).asArrayValue()));
+    return builder.build();
+  }
+
+  public static MapValue value(Long id, MapValue value, MapValue sortValue) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    builder.put(ID, id == null ? NIL : ValueFactory.newString(id.toString()));
+    builder.put(VALUE, value == null ? ValueFactory.emptyMap() : value);
+    builder.put(KEY_SET, value == null ? ValueFactory.emptyArray() : keySet(value));
+    builder.put(SORT_VALUE, sortValue == null ? ValueFactory.emptyMap() : sortValue);
+    return builder.build();
+  }
+
+  public static MapValue value(Column column, List<String> values, KintoneColumnOption option) {
+    return valueOf(column).value(values.get(column.getIndex()), option);
+  }
+
+  protected static MapValue value(KintoneColumnType type, String value, Supplier<Value> supplier) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    builder.put(TYPE, value(type.name()));
+    builder.put(VALUE, value == null ? NIL : supplier.get());
+    return builder.build();
+  }
+
+  private static <T extends Comparable<? super T>> Comparator<T> order(
+      KintoneSortColumn.Order order) {
+    return order == KintoneSortColumn.Order.DESC
+        ? Comparator.reverseOrder()
+        : Comparator.naturalOrder();
+  }
+
+  private static String asString(Value value) {
+    return value.isNilValue() ? null : value.asStringValue().asString();
+  }
+
+  private static MapValue sortValue(Value value) {
+    return value.asMapValue().map().get(SORT_VALUE).asMapValue();
+  }
+
+  private static MapValue value(Map<Value, Value> map, ArrayValue keySet) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    keySet.forEach(key -> builder.put(key, map.get(key)));
+    return builder.build();
+  }
+
+  private static ArrayValue keySet(MapValue value) {
+    return ValueFactory.newArray(new ArrayList<>(value.asMapValue().keySet()));
+  }
+
+  private static ReduceType valueOf(Column column) {
+    return valueOf(column.getType().getName().toUpperCase());
+  }
+}

data/src/main/java/org/embulk/output/kintone/reducer/ReducedPageOutput.java

@@ -0,0 +1,100 @@
+package org.embulk.output.kintone.reducer;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.lang.invoke.MethodHandles;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import org.apache.commons.csv.CSVPrinter;
+import org.embulk.config.TaskReport;
+import org.embulk.output.kintone.KintoneOutputPlugin;
+import org.embulk.spi.ColumnVisitor;
+import org.embulk.spi.Exec;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.Schema;
+import org.embulk.spi.TransactionalPageOutput;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ReducedPageOutput implements TransactionalPageOutput {
+  private static final Logger LOGGER =
+      LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+  private final PageReader reader;
+  private final File file;
+  private final CSVPrinter printer;
+  private final ColumnVisitor visitor;
+
+  public ReducedPageOutput(Schema schema, int taskIndex) {
+    reader = new PageReader(schema);
+    file = file(taskIndex);
+    printer = printer(file);
+    visitor = new CSVOutputColumnVisitor(reader, printer);
+  }
+
+  @Override
+  public void add(Page page) {
+    reader.setPage(page);
+    while (reader.nextRecord()) visitColumns();
+  }
+
+  @Override
+  public void finish() {}
+
+  @Override
+  public void close() {
+    reader.close();
+    close(printer);
+  }
+
+  @Override
+  public void abort() {}
+
+  @Override
+  public TaskReport commit() {
+    return Exec.newTaskReport().set("path", file.getPath());
+  }
+
+  private void visitColumns() {
+    reader.getSchema().visitColumns(visitor);
+    println(printer);
+  }
+
+  private static File file(int taskIndex) {
+    try {
+      return File.createTempFile(
+          String.format("%s.", KintoneOutputPlugin.class.getName()),
+          String.format(".%d", taskIndex));
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static CSVPrinter printer(File file) {
+    try {
+      return new CSVPrinter(
+          new OutputStreamWriter(Files.newOutputStream(file.toPath()), StandardCharsets.UTF_8),
+          Reducer.FORMAT);
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static void println(CSVPrinter printer) {
+    try {
+      printer.println();
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static void close(Closeable closeable) {
+    try {
+      closeable.close();
+    } catch (IOException e) {
+      LOGGER.warn("close error", e);
+    }
+  }
+}

data/src/main/java/org/embulk/output/kintone/reducer/Reducer.java

@@ -0,0 +1,355 @@
+package org.embulk.output.kintone.reducer;
+
+import com.google.code.externalsorting.csv.CsvExternalSort;
+import com.google.code.externalsorting.csv.CsvSortOptions;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.invoke.MethodHandles;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+import org.apache.commons.csv.QuoteMode;
+import org.embulk.config.ConfigDiff;
+import org.embulk.config.TaskReport;
+import org.embulk.output.kintone.KintoneColumnOption;
+import org.embulk.output.kintone.KintoneColumnType;
+import org.embulk.output.kintone.KintoneOutputPlugin;
+import org.embulk.output.kintone.KintonePageOutput;
+import org.embulk.output.kintone.KintoneSortColumn;
+import org.embulk.output.kintone.PluginTask;
+import org.embulk.spi.Column;
+import org.embulk.spi.Exec;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.Schema;
+import org.embulk.spi.json.JsonParser;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import org.msgpack.value.ArrayValue;
+import org.msgpack.value.MapValue;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Reducer {
+  protected static final CSVFormat FORMAT =
+      CSVFormat.DEFAULT.builder().setNullString("").setQuoteMode(QuoteMode.ALL_NON_NULL).build();
+  protected static final JsonParser PARSER = new JsonParser();
+  private static final Logger LOGGER =
+      LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+  private final PluginTask task;
+  private final List<Integer> indices;
+  private final int size;
+  private final Schema schema;
+
+  public Reducer(PluginTask task, Schema schema) {
+    this.task = task;
+    indices =
+        schema.getColumns().stream()
+            .filter(column -> !column.getName().matches("^.*\\..*$"))
+            .map(Column::getIndex)
+            .collect(Collectors.toList());
+    size = schema.size();
+    this.schema = schema(task, schema);
+    this.task.setDerivedColumns(
+        range().mapToObj(this.schema::getColumn).collect(Collectors.toSet()));
+  }
+
+  public ConfigDiff reduce(List<TaskReport> taskReports, Column column) {
+    File merged = file(".merged");
+    merge(taskReports, merged);
+    File sorted = file(".sorted");
+    sort(merged, sorted, sortOptions(task, schema, column));
+    AtomicInteger reduced = new AtomicInteger();
+    try (CSVParser parser = parser(sorted);
+        PageBuilder builder = builder(task, schema)) {
+      addRecords(column, reduced, parser, builder);
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+    if (reduced.get() % task.getChunkSize() != 0) {
+      LOGGER.info(String.format("Number of records reduced: %d", reduced.get()));
+    }
+    return Exec.newConfigDiff();
+  }
+
+  private void addRecords(
+      Column column, AtomicInteger reduced, CSVParser parser, PageBuilder builder) {
+    List<String> values = null;
+    for (CSVRecord record : parser) {
+      values = addRecord(column, reduced, builder, values, record);
+    }
+    if (values != null) {
+      addRecord(column, reduced, builder, values, null);
+    }
+    builder.finish();
+  }
+
+  private List<String> addRecord(
+      Column column,
+      AtomicInteger reduced,
+      PageBuilder builder,
+      List<String> values,
+      CSVRecord record) {
+    if (values == null && record == null) {
+      return null;
+    }
+    if (values == null) {
+      return values(record);
+    }
+    int index = column.getIndex();
+    if (record != null
+        && values.get(index) != null
+        && record.get(index) != null
+        && values.get(index).equals(record.get(index))) {
+      return values(column, values, record);
+    }
+    schema.visitColumns(new CSVInputColumnVisitor(builder, values(values)));
+    builder.addRecord();
+    reduced.getAndIncrement();
+    if (reduced.get() % task.getChunkSize() == 0) {
+      LOGGER.info(String.format("Number of records reduced: %d", reduced.get()));
+    }
+    return record == null ? null : values(record);
+  }
+
+  private List<String> values(CSVRecord record) {
+    List<String> values = new ArrayList<>(record.toList());
+    range().forEach(index -> values.add(value(record, index).toJson()));
+    return values;
+  }
+
+  private ArrayValue value(CSVRecord record, int index) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    String name = schema.getColumnName(index);
+    Predicate<Column> isId = column -> column.getName().equals(String.format("%s.$id", name));
+    Long id =
+        schema.getColumns().stream()
+            .filter(isId)
+            .findFirst()
+            .map(column -> record.get(column.getIndex()))
+            .filter(value -> !value.isEmpty())
+            .map(Long::parseLong)
+            .orElse(null);
+    Predicate<Column> predicate =
+        column -> column.getName().matches(String.format("^%s\\..*$", name));
+    Function<Column, String> function =
+        column -> column.getName().replaceFirst(String.format("^%s\\.", name), "");
+    schema.getColumns().stream()
+        .filter(isId.negate().and(predicate))
+        .forEach(column -> builder.put(key(function, column), value(record, column)));
+    MapValue value = builder.build();
+    return id == null && ReduceType.isEmpty(value)
+        ? ValueFactory.emptyArray()
+        : ValueFactory.newArray(ReduceType.value(id, value, sortValue(record, index)));
+  }
+
+  private Value key(Function<Column, String> function, Column column) {
+    KintoneColumnOption option = task.getColumnOptions().get(column.getName());
+    return ReduceType.value(option != null ? option.getFieldCode() : function.apply(column));
+  }
+
+  private MapValue value(CSVRecord record, Column column) {
+    return ReduceType.value(column, record.toList(), task.getColumnOptions().get(column.getName()));
+  }
+
+  private MapValue sortValue(CSVRecord record, int index) {
+    ValueFactory.MapBuilder builder = ValueFactory.newMapBuilder();
+    String name = schema.getColumnName(index);
+    Function<KintoneSortColumn, Column> column = sortColumn -> lookupColumn(name, sortColumn);
+    Function<KintoneSortColumn, Value> key = sortColumn -> ReduceType.value(sortColumn.getName());
+    Function<KintoneSortColumn, Value> value =
+        sortColumn -> ReduceType.value(record.get(column.apply(sortColumn).getIndex()));
+    getSortColumns(index)
+        .forEach(sortColumn -> builder.put(key.apply(sortColumn), value.apply(sortColumn)));
+    return builder.build();
+  }
+
+  private List<String> values(Column column, List<String> values, CSVRecord record) {
+    if (!indices.stream().allMatch(index -> Objects.equals(values.get(index), record.get(index)))) {
+      throw new ReduceException(
+          String.format(
+              "Couldn't reduce because column %s is not unique to %s\n%s expected %s but actual %s",
+              column.getName(),
+              range().mapToObj(schema::getColumnName).collect(Collectors.toList()),
+              indices.stream().map(schema::getColumnName).collect(Collectors.toList()),
+              indices.stream().map(values::get).collect(Collectors.toList()),
+              indices.stream().map(record::get).collect(Collectors.toList())));
+    }
+    range().forEach(index -> values.set(index, value(values, record, index).toJson()));
+    return values;
+  }
+
+  private ArrayValue value(List<String> values, CSVRecord record, int index) {
+    List<Value> list = new ArrayList<>(list(values, index));
+    list.addAll(value(record, index).list());
+    return list.isEmpty() ? ValueFactory.emptyArray() : ValueFactory.newArray(list);
+  }
+
+  private List<String> values(List<String> values) {
+    range().forEach(index -> values.set(index, value(values, index).toJson()));
+    return values;
+  }
+
+  private ArrayValue value(List<String> values, int index) {
+    List<Value> list =
+        list(values, index).stream()
+            .sorted(comparator(index))
+            .map(ReduceType::value)
+            .collect(Collectors.toList());
+    return list.isEmpty() ? ValueFactory.emptyArray() : ValueFactory.newArray(list);
+  }
+
+  private Comparator<Value> comparator(int index) {
+    String name = schema.getColumnName(index);
+    return getSortColumns(index).stream()
+        .map(sortColumn -> comparator(name, sortColumn))
+        .reduce(Comparator::thenComparing)
+        .orElse(Comparator.comparing(value -> 0));
+  }
+
+  private Comparator<Value> comparator(String name, KintoneSortColumn sortColumn) {
+    Column column = lookupColumn(name, sortColumn);
+    return Comparator.comparing(
+        value -> ReduceType.asString(value, sortColumn),
+        Comparator.nullsLast(ReduceType.comparator(column, sortColumn.getOrder())));
+  }
+
+  private List<KintoneSortColumn> getSortColumns(int index) {
+    KintoneColumnOption option = task.getColumnOptions().get(schema.getColumnName(index));
+    return option != null ? option.getSortColumns() : Collections.emptyList();
+  }
+
+  private Column lookupColumn(String name, KintoneSortColumn sortColumn) {
+    return schema.lookupColumn(String.format("%s.%s", name, sortColumn.getName()));
+  }
+
+  private IntStream range() {
+    return IntStream.range(size, schema.size());
+  }
+
+  private static Schema schema(PluginTask task, Schema schema) {
+    Schema.Builder builder = Schema.builder();
+    schema.getColumns().forEach(column -> builder.add(column.getName(), column.getType()));
+    schema.getColumns().stream()
+        .map(Column::getName)
+        .filter(name -> name.matches("^.*\\..*$"))
+        .map(name -> name.replaceFirst("\\..*$", ""))
+        .distinct()
+        .forEach(name -> builder.add(name, type(task, name)));
+    return builder.build();
+  }
+
+  private static Type type(PluginTask task, String name) {
+    return KintoneColumnType.getType(task.getColumnOptions().get(name), KintoneColumnType.SUBTABLE)
+            == KintoneColumnType.SUBTABLE
+        ? Types.JSON
+        : Types.STRING;
+  }
+
+  private static File file(String suffix) {
+    try {
+      return File.createTempFile(String.format("%s.", KintoneOutputPlugin.class.getName()), suffix);
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static void merge(List<TaskReport> taskReports, File merged) {
+    try (OutputStream out = Files.newOutputStream(merged.toPath())) {
+      long bytes =
+          taskReports.stream()
+              .map(taskReport -> new File(taskReport.get(String.class, "path")).toPath())
+              .mapToLong(source -> copy(source, out))
+              .sum();
+      LOGGER.info(String.format("Number of bytes merged: %d", bytes));
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static long copy(Path source, OutputStream out) {
+    try {
+      long bytes = Files.copy(source, out);
+      LOGGER.info(String.format("Number of bytes copied: %d", bytes));
+      return bytes;
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static void sort(File merged, File sorted, CsvSortOptions sortOptions) {
+    try {
+      int lines =
+          CsvExternalSort.mergeSortedFiles(
+              CsvExternalSort.sortInBatch(merged, null, sortOptions, new ArrayList<>()),
+              sorted,
+              sortOptions,
+              false,
+              Collections.emptyList());
+      LOGGER.info(String.format("Number of lines sorted: %d", lines));
+    } catch (IOException | ClassNotFoundException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static CsvSortOptions sortOptions(PluginTask task, Schema schema, Column column) {
+    List<KintoneSortColumn> sortColumns = new ArrayList<>();
+    sortColumns.add(new KintoneSortColumn(column.getName(), KintoneSortColumn.Order.ASC));
+    sortColumns.addAll(task.getSortColumns());
+    return new CsvSortOptions.Builder(
+            comparator(schema, sortColumns),
+            task.getMaxSortTmpFiles().orElse(CsvExternalSort.DEFAULTMAXTEMPFILES),
+            task.getMaxSortMemory().orElse(CsvExternalSort.estimateAvailableMemory()))
+        .charset(StandardCharsets.UTF_8)
+        .format(FORMAT)
+        .build();
+  }
+
+  private static Comparator<CSVRecord> comparator(
+      Schema schema, List<KintoneSortColumn> sortColumns) {
+    Function<KintoneSortColumn, Comparator<CSVRecord>> function =
+        sortColumn -> comparator(schema, sortColumn);
+    return sortColumns.stream()
+        .skip(1)
+        .map(function)
+        .reduce(function.apply(sortColumns.get(0)), Comparator::thenComparing);
+  }
+
+  private static Comparator<CSVRecord> comparator(Schema schema, KintoneSortColumn sortColumn) {
+    Column column = schema.lookupColumn(sortColumn.getName());
+    return Comparator.comparing(
+        record -> record.get(column.getIndex()),
+        Comparator.nullsLast(ReduceType.comparator(column, sortColumn.getOrder())));
+  }
+
+  private static CSVParser parser(File sorted) {
+    try {
+      return CSVParser.parse(sorted, StandardCharsets.UTF_8, FORMAT);
+    } catch (IOException e) {
+      throw new ReduceException(e);
+    }
+  }
+
+  private static PageBuilder builder(PluginTask task, Schema schema) {
+    return new PageBuilder(Exec.getBufferAllocator(), schema, new KintonePageOutput(task, schema));
+  }
+
+  private static List<Value> list(List<String> values, int index) {
+    return PARSER.parse(values.get(index)).asArrayValue().list();
+  }
+}

data/src/test/java/org/embulk/output/kintone/KintoneColumnOptionBuilder.java

@@ -1,5 +1,7 @@
 package org.embulk.output.kintone;
 
+import java.util.Collections;
+import java.util.List;
 import org.embulk.config.TaskSource;
 
 public class KintoneColumnOptionBuilder {
@@ -50,6 +52,11 @@ public class KintoneColumnOptionBuilder {
         return valueSeparator;
       }
 
+      @Override
+      public List<KintoneSortColumn> getSortColumns() {
+        return Collections.emptyList();
+      }
+
       @Override
       public void validate() {}