embulk-output-kintone 0.4.1 → 1.1.0

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,6 +1,7 @@
 package org.embulk.output.kintone;
 
-import java.util.Optional;
+import java.util.Collections;
+import java.util.List;
 import org.embulk.config.TaskSource;
 
 public class KintoneColumnOptionBuilder {
@@ -42,8 +43,8 @@ public class KintoneColumnOptionBuilder {
       }
 
       @Override
-      public Optional<String> getTimezone() {
-        return Optional.ofNullable(timezone);
+      public String getTimezone() {
+        return timezone;
       }
 
       @Override
@@ -51,6 +52,11 @@ public class KintoneColumnOptionBuilder {
         return valueSeparator;
       }
 
+      @Override
+      public List<KintoneSortColumn> getSortColumns() {
+        return Collections.emptyList();
+      }
+
       @Override
       public void validate() {}
 

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

@@ -0,0 +1,194 @@
+package org.embulk.output.kintone;
+
+import static org.embulk.output.kintone.KintoneColumnType.CHECK_BOX;
+import static org.embulk.output.kintone.KintoneColumnType.DATE;
+import static org.embulk.output.kintone.KintoneColumnType.DATETIME;
+import static org.embulk.output.kintone.KintoneColumnType.DROP_DOWN;
+import static org.embulk.output.kintone.KintoneColumnType.FILE;
+import static org.embulk.output.kintone.KintoneColumnType.GROUP_SELECT;
+import static org.embulk.output.kintone.KintoneColumnType.LINK;
+import static org.embulk.output.kintone.KintoneColumnType.MULTI_LINE_TEXT;
+import static org.embulk.output.kintone.KintoneColumnType.MULTI_SELECT;
+import static org.embulk.output.kintone.KintoneColumnType.NUMBER;
+import static org.embulk.output.kintone.KintoneColumnType.ORGANIZATION_SELECT;
+import static org.embulk.output.kintone.KintoneColumnType.RADIO_BUTTON;
+import static org.embulk.output.kintone.KintoneColumnType.RICH_TEXT;
+import static org.embulk.output.kintone.KintoneColumnType.SINGLE_LINE_TEXT;
+import static org.embulk.output.kintone.KintoneColumnType.SUBTABLE;
+import static org.embulk.output.kintone.KintoneColumnType.TIME;
+import static org.embulk.output.kintone.KintoneColumnType.USER_SELECT;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThrows;
+
+import com.kintone.client.model.record.CheckBoxFieldValue;
+import com.kintone.client.model.record.DateFieldValue;
+import com.kintone.client.model.record.DateTimeFieldValue;
+import com.kintone.client.model.record.DropDownFieldValue;
+import com.kintone.client.model.record.LinkFieldValue;
+import com.kintone.client.model.record.MultiLineTextFieldValue;
+import com.kintone.client.model.record.MultiSelectFieldValue;
+import com.kintone.client.model.record.NumberFieldValue;
+import com.kintone.client.model.record.RadioButtonFieldValue;
+import com.kintone.client.model.record.RichTextFieldValue;
+import com.kintone.client.model.record.SingleLineTextFieldValue;
+import com.kintone.client.model.record.SubtableFieldValue;
+import com.kintone.client.model.record.TableRow;
+import com.kintone.client.model.record.TimeFieldValue;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.embulk.output.kintone.deserializer.DeserializerTest;
+import org.embulk.spi.time.Timestamp;
+import org.junit.Test;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+
+public class KintoneColumnTypeTest {
+  private static final Timestamp EPOCH = Timestamp.ofInstant(Instant.EPOCH);
+  private static final Value EMPTY = ValueFactory.newString("");
+
+  @Test
+  public void testSupportedTypes() {
+    // spotless:off
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue(false, null)).getValue(), is("false"));
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue(0L, null)).getValue(), is("0"));
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue(0.0d, null)).getValue(), is("0.0"));
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue(EPOCH, null)).getValue(), is("1970-01-01T00:00:00Z"));
+    assertThat(((SingleLineTextFieldValue) SINGLE_LINE_TEXT.getFieldValue(EMPTY, null)).getValue(), is("\"\""));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue(false, null)).getValue(), is("false"));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue(0L, null)).getValue(), is("0"));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue(0.0d, null)).getValue(), is("0.0"));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue(EPOCH, null)).getValue(), is("1970-01-01T00:00:00Z"));
+    assertThat(((MultiLineTextFieldValue) MULTI_LINE_TEXT.getFieldValue(EMPTY, null)).getValue(), is("\"\""));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue(false, null)).getValue(), is("false"));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue(0L, null)).getValue(), is("0"));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue(0.0d, null)).getValue(), is("0.0"));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue(EPOCH, null)).getValue(), is("1970-01-01T00:00:00Z"));
+    assertThat(((RichTextFieldValue) RICH_TEXT.getFieldValue(EMPTY, null)).getValue(), is("\"\""));
+    assertThat(((NumberFieldValue) NUMBER.getFieldValue(false, null)).getValue(), is(number("0")));
+    assertThat(((NumberFieldValue) NUMBER.getFieldValue(0L, null)).getValue(), is(number("0")));
+    assertThat(((NumberFieldValue) NUMBER.getFieldValue(0.0d, null)).getValue(), is(number("0.0")));
+    assertThat(((NumberFieldValue) NUMBER.getFieldValue("", null)).getValue(), is(number("0")));
+    assertThat(((NumberFieldValue) NUMBER.getFieldValue(EPOCH, null)).getValue(), is(number("0")));
+    assertThat(((CheckBoxFieldValue) CHECK_BOX.getFieldValue("", null)).getValues(), is(list()));
+    assertThat(((RadioButtonFieldValue) RADIO_BUTTON.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((MultiSelectFieldValue) MULTI_SELECT.getFieldValue("", null)).getValues(), is(list()));
+    assertThat(((DropDownFieldValue) DROP_DOWN.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((DateFieldValue) DATE.getFieldValue(0L, null)).getValue(), is(date("1970-01-01")));
+    assertThat(((DateFieldValue) DATE.getFieldValue(0.0d, null)).getValue(), is(date("1970-01-01")));
+    assertThat(((DateFieldValue) DATE.getFieldValue("", null)).getValue(), is(date("1970-01-01")));
+    assertThat(((DateFieldValue) DATE.getFieldValue(EPOCH, null)).getValue(), is(date("1970-01-01")));
+    assertThat(((TimeFieldValue) TIME.getFieldValue(0L, null)).getValue(), is(time("00:00:00")));
+    assertThat(((TimeFieldValue) TIME.getFieldValue(0.0d, null)).getValue(), is(time("00:00:00")));
+    assertThat(((TimeFieldValue) TIME.getFieldValue("", null)).getValue(), is(time("00:00:00")));
+    assertThat(((TimeFieldValue) TIME.getFieldValue(EPOCH, null)).getValue(), is(time("00:00:00")));
+    assertThat(((DateTimeFieldValue) DATETIME.getFieldValue(0L, null)).getValue(), is(dateTime("1970-01-01T00:00:00Z")));
+    assertThat(((DateTimeFieldValue) DATETIME.getFieldValue(0.0d, null)).getValue(), is(dateTime("1970-01-01T00:00:00Z")));
+    assertThat(((DateTimeFieldValue) DATETIME.getFieldValue("", null)).getValue(), is(dateTime("1970-01-01T00:00:00Z")));
+    assertThat(((DateTimeFieldValue) DATETIME.getFieldValue(EPOCH, null)).getValue(), is(dateTime("1970-01-01T00:00:00Z")));
+    assertThat(((LinkFieldValue) LINK.getFieldValue("", null)).getValue(), is(""));
+    assertThat(((SubtableFieldValue) SUBTABLE.getFieldValue("", null)).getRows(), is(rows()));
+    assertThat(((SubtableFieldValue) SUBTABLE.getFieldValue(EMPTY, null)).getRows(), is(rows()));
+    // spotless:on
+  }
+
+  @Test
+  public void testUnsupportedTypes() {
+    // spotless:off
+    assertThrows(UnsupportedOperationException.class, () -> NUMBER.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> CHECK_BOX.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> CHECK_BOX.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> CHECK_BOX.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> CHECK_BOX.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> CHECK_BOX.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> RADIO_BUTTON.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> RADIO_BUTTON.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> RADIO_BUTTON.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> RADIO_BUTTON.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> RADIO_BUTTON.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> MULTI_SELECT.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> MULTI_SELECT.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> MULTI_SELECT.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> MULTI_SELECT.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> MULTI_SELECT.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> DROP_DOWN.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> DROP_DOWN.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> DROP_DOWN.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> DROP_DOWN.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> DROP_DOWN.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue("", null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> USER_SELECT.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue("", null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> ORGANIZATION_SELECT.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue("", null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> GROUP_SELECT.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> DATE.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> DATE.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> TIME.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> TIME.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> DATETIME.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> DATETIME.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> LINK.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> LINK.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> LINK.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> LINK.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> LINK.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue("", null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue(EPOCH, null));
+    assertThrows(UnsupportedOperationException.class, () -> FILE.getFieldValue(EMPTY, null));
+    assertThrows(UnsupportedOperationException.class, () -> SUBTABLE.getFieldValue(false, null));
+    assertThrows(UnsupportedOperationException.class, () -> SUBTABLE.getFieldValue(0L, null));
+    assertThrows(UnsupportedOperationException.class, () -> SUBTABLE.getFieldValue(0.0d, null));
+    assertThrows(UnsupportedOperationException.class, () -> SUBTABLE.getFieldValue(EPOCH, null));
+    // spotless:on
+  }
+
+  public static BigDecimal number(String value) {
+    return new BigDecimal(value);
+  }
+
+  @SafeVarargs
+  public static <T> List<T> list(T... a) {
+    return Arrays.asList(a);
+  }
+
+  public static List<TableRow> rows(Long... ids) {
+    return Arrays.stream(ids).map(DeserializerTest::tableRow).collect(Collectors.toList());
+  }
+
+  public static LocalDate date(CharSequence text) {
+    return LocalDate.parse(text);
+  }
+
+  public static LocalTime time(CharSequence text) {
+    return LocalTime.parse(text);
+  }
+
+  public static ZonedDateTime dateTime(CharSequence text) {
+    return ZonedDateTime.parse(text);
+  }
+}