embulk-output-kintone 1.0.0 → 1.1.0

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);
+  }
+}

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

@@ -1,5 +1,12 @@
 package org.embulk.output.kintone;
 
+import static org.embulk.output.kintone.KintoneColumnTypeTest.date;
+import static org.embulk.output.kintone.KintoneColumnTypeTest.dateTime;
+import static org.embulk.output.kintone.KintoneColumnTypeTest.list;
+import static org.embulk.output.kintone.KintoneColumnTypeTest.number;
+import static org.embulk.output.kintone.KintoneColumnTypeTest.rows;
+import static org.embulk.output.kintone.KintoneColumnTypeTest.time;
+import static org.embulk.output.kintone.deserializer.DeserializerTest.assertTableRows;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
@@ -7,27 +14,35 @@ import static org.junit.Assert.assertThrows;
 
 import com.google.common.collect.ImmutableMap;
 import com.kintone.client.model.record.FieldType;
-import java.math.BigDecimal;
 import java.time.Instant;
-import java.time.LocalDate;
-import java.time.LocalTime;
-import java.time.ZonedDateTime;
 import java.util.AbstractMap;
-import java.util.Arrays;
-import java.util.List;
+import java.util.Collections;
 import java.util.Map;
 import java.util.function.Function;
+import org.embulk.output.kintone.deserializer.DeserializerTest;
 import org.embulk.spi.Page;
 import org.embulk.spi.Schema;
+import org.embulk.spi.json.JsonParser;
 import org.embulk.spi.time.Timestamp;
 import org.embulk.spi.type.Types;
 import org.junit.Test;
+import org.msgpack.value.Value;
 import org.msgpack.value.ValueFactory;
 
 public class KintoneColumnVisitorTest {
+  private static final JsonParser PARSER = new JsonParser();
+  private static final String[] ROWS = {
+    DeserializerTest.TABLE_ROW.apply(0L),
+    DeserializerTest.TABLE_ROW.apply(1L),
+    DeserializerTest.TABLE_ROW.apply(2L),
+    DeserializerTest.TABLE_ROW.apply(3L),
+    DeserializerTest.TABLE_ROW.apply(4L),
+    DeserializerTest.TABLE_ROW.apply(5L),
+  };
+
   @Test
   public void test() {
-    KintoneColumnVisitorVerifier verifier = verifier("STRING|SINGLE_LINE_TEXT");
+    KintoneColumnVisitorVerifier verifier = verifier(null, "STRING|SINGLE_LINE_TEXT");
     verifier.verify(
         (record, updateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
@@ -71,6 +86,7 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("STRING|DATETIME"),
               is(dateTime("1970-01-01T00:00:00Z")));
           assertThat(record.getLinkFieldValue("STRING|LINK"), is(""));
+          assertThat(record.getSubtableFieldValue("STRING|SUBTABLE"), is(list()));
           assertThat(
               record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"),
               is("1970-01-01T00:00:00Z"));
@@ -85,6 +101,9 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1970-01-01T00:00:00Z")));
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("\"\""));
           assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"\""));
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
           assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
           assertThat(updateKey.getValue(), is(""));
         });
@@ -131,6 +150,7 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("STRING|DATETIME"),
               is(dateTime("1970-01-01T00:00:00Z")));
           assertThat(record.getLinkFieldValue("STRING|LINK"), is(""));
+          assertThat(record.getSubtableFieldValue("STRING|SUBTABLE"), is(list()));
           assertThat(
               record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"),
               is("1970-01-01T00:00:00Z"));
@@ -145,6 +165,9 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1970-01-01T00:00:00Z")));
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("\"\""));
           assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"\""));
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
           assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
           assertThat(updateKey.getValue(), is(""));
         });
@@ -192,6 +215,7 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("STRING|DATETIME"),
               is(dateTime("1999-12-31T23:59:59Z")));
           assertThat(record.getLinkFieldValue("STRING|LINK"), is("abc"));
+          assertTableRows(record.getSubtableFieldValue("STRING|SUBTABLE"), rows(0L, 1L, 2L));
           assertThat(
               record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"),
               is("1999-12-31T23:59:59Z"));
@@ -206,6 +230,9 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1999-12-31T23:59:59Z")));
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("\"abc\""));
           assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"abc\""));
+          assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(0L, 1L, 2L));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"abc\""));
           assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
           assertThat(updateKey.getValue(), is("abc"));
         });
@@ -253,6 +280,7 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("STRING|DATETIME"),
               is(dateTime("2000-01-01T00:00:00Z")));
           assertThat(record.getLinkFieldValue("STRING|LINK"), is("def"));
+          assertTableRows(record.getSubtableFieldValue("STRING|SUBTABLE"), rows(3L, 4L, 5L));
           assertThat(
               record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"),
               is("2000-01-01T00:00:00Z"));
@@ -267,6 +295,9 @@ public class KintoneColumnVisitorTest {
               record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("2000-01-01T00:00:00Z")));
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("\"def\""));
           assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"def\""));
+          assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(3L, 4L, 5L));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"def\""));
           assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
           assertThat(updateKey.getValue(), is("def"));
         });
@@ -274,7 +305,7 @@ public class KintoneColumnVisitorTest {
 
   @Test
   public void testPreferNulls() {
-    KintoneColumnVisitorVerifier verifier = verifier("LONG", true, false);
+    KintoneColumnVisitorVerifier verifier = verifier(null, "LONG", true, false);
     verifier.verify(
         (record, updateKey) -> {
           assertThat(
@@ -316,6 +347,7 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldType("STRING|TIME|PST"), is(FieldType.TIME));
           assertThat(record.getFieldType("STRING|DATETIME"), is(FieldType.DATETIME));
           assertThat(record.getFieldType("STRING|LINK"), is(FieldType.LINK));
+          assertThat(record.getFieldType("STRING|SUBTABLE"), is(FieldType.SUBTABLE));
           assertThat(
               record.getFieldType("TIMESTAMP|SINGLE_LINE_TEXT"), is(FieldType.SINGLE_LINE_TEXT));
           assertThat(record.getFieldType("TIMESTAMP|NUMBER"), is(FieldType.NUMBER));
@@ -328,6 +360,10 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldType("TIMESTAMP"), is(FieldType.DATETIME));
           assertThat(record.getFieldType("JSON|SINGLE_LINE_TEXT"), is(FieldType.SINGLE_LINE_TEXT));
           assertThat(record.getFieldType("JSON"), is(FieldType.MULTI_LINE_TEXT));
+          assertThat(record.getFieldType("JSON|SUBTABLE"), is(FieldType.SUBTABLE));
+          assertThat(
+              record.getFieldType("JSON|SUBTABLE.SINGLE_LINE_TEXT"),
+              is(FieldType.SINGLE_LINE_TEXT));
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getNumberFieldValue("BOOLEAN"), nullValue());
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), nullValue());
@@ -364,6 +400,7 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getTimeFieldValue("STRING|TIME|PST"), nullValue());
           assertThat(record.getDateTimeFieldValue("STRING|DATETIME"), nullValue());
           assertThat(record.getLinkFieldValue("STRING|LINK"), nullValue());
+          assertThat(record.getSubtableFieldValue("STRING|SUBTABLE"), is(list()));
           assertThat(record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getNumberFieldValue("TIMESTAMP|NUMBER"), nullValue());
           assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), nullValue());
@@ -375,6 +412,9 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getDateTimeFieldValue("TIMESTAMP"), nullValue());
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getMultiLineTextFieldValue("JSON"), nullValue());
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
           assertThat(updateKey.getField(), is("LONG"));
           assertThat(updateKey.getValue(), nullValue());
         });
@@ -382,7 +422,7 @@ public class KintoneColumnVisitorTest {
 
   @Test
   public void testIgnoreNulls() {
-    KintoneColumnVisitorVerifier verifier = verifier("JSON", false, true);
+    KintoneColumnVisitorVerifier verifier = verifier("JSON", "JSON", false, true);
     verifier.verify(
         (record, updateKey) -> {
           assertThat(record.getFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), nullValue());
@@ -421,6 +461,7 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldValue("STRING|TIME|PST"), nullValue());
           assertThat(record.getFieldValue("STRING|DATETIME"), nullValue());
           assertThat(record.getFieldValue("STRING|LINK"), nullValue());
+          assertThat(record.getFieldValue("STRING|SUBTABLE"), nullValue());
           assertThat(record.getFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getFieldValue("TIMESTAMP|NUMBER"), nullValue());
           assertThat(record.getFieldValue("TIMESTAMP|DATE"), nullValue());
@@ -432,6 +473,77 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldValue("TIMESTAMP"), nullValue());
           assertThat(record.getFieldValue("JSON|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getFieldValue("JSON"), nullValue());
+          assertThat(record.getFieldValue("JSON|SUBTABLE"), nullValue());
+          assertThat(record.getFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
+          assertThat(updateKey.getField(), nullValue());
+          assertThat(updateKey.getValue(), nullValue());
+        },
+        true);
+  }
+
+  @Test
+  public void testReduceKey() {
+    KintoneColumnVisitorVerifier verifier = verifier("JSON|SUBTABLE", null);
+    verifier.verify(
+        (record, updateKey) -> {
+          assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
+          assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
+          assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("0"));
+          assertThat(record.getNumberFieldValue("LONG"), is(number("0")));
+          assertThat(record.getDateFieldValue("LONG|DATE"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("LONG|DATE|JST"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("LONG|DATE|PST"), is(date("1969-12-31")));
+          assertThat(record.getTimeFieldValue("LONG|TIME"), is(time("00:00:00")));
+          assertThat(record.getTimeFieldValue("LONG|TIME|JST"), is(time("09:00:00")));
+          assertThat(record.getTimeFieldValue("LONG|TIME|PST"), is(time("16:00:00")));
+          assertThat(
+              record.getDateTimeFieldValue("LONG|DATETIME"), is(dateTime("1970-01-01T00:00:00Z")));
+          assertThat(record.getSingleLineTextFieldValue("DOUBLE|SINGLE_LINE_TEXT"), is("0.0"));
+          assertThat(record.getNumberFieldValue("DOUBLE"), is(number("0.0")));
+          assertThat(record.getDateFieldValue("DOUBLE|DATE"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("DOUBLE|DATE|JST"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("DOUBLE|DATE|PST"), is(date("1969-12-31")));
+          assertThat(record.getTimeFieldValue("DOUBLE|TIME"), is(time("00:00:00")));
+          assertThat(record.getTimeFieldValue("DOUBLE|TIME|JST"), is(time("09:00:00")));
+          assertThat(record.getTimeFieldValue("DOUBLE|TIME|PST"), is(time("16:00:00")));
+          assertThat(
+              record.getDateTimeFieldValue("DOUBLE|DATETIME"),
+              is(dateTime("1970-01-01T00:00:00Z")));
+          assertThat(record.getSingleLineTextFieldValue("STRING|SINGLE_LINE_TEXT"), is(""));
+          assertThat(record.getMultiLineTextFieldValue("STRING"), is(""));
+          assertThat(record.getRichTextFieldValue("STRING|RICH_TEXT"), is(""));
+          assertThat(record.getNumberFieldValue("STRING|NUMBER"), is(number("0")));
+          assertThat(record.getCheckBoxFieldValue("STRING|CHECK_BOX"), is(list()));
+          assertThat(record.getRadioButtonFieldValue("STRING|RADIO_BUTTON"), is(""));
+          assertThat(record.getMultiSelectFieldValue("STRING|MULTI_SELECT"), is(list()));
+          assertThat(record.getDropDownFieldValue("STRING|DROP_DOWN"), is(""));
+          assertThat(record.getDateFieldValue("STRING|DATE"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("STRING|DATE|JST"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("STRING|DATE|PST"), is(date("1969-12-31")));
+          assertThat(record.getTimeFieldValue("STRING|TIME"), is(time("00:00:00")));
+          assertThat(record.getTimeFieldValue("STRING|TIME|JST"), is(time("09:00:00")));
+          assertThat(record.getTimeFieldValue("STRING|TIME|PST"), is(time("16:00:00")));
+          assertThat(
+              record.getDateTimeFieldValue("STRING|DATETIME"),
+              is(dateTime("1970-01-01T00:00:00Z")));
+          assertThat(record.getLinkFieldValue("STRING|LINK"), is(""));
+          assertThat(record.getSubtableFieldValue("STRING|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("TIMESTAMP|SINGLE_LINE_TEXT"),
+              is("1970-01-01T00:00:00Z"));
+          assertThat(record.getNumberFieldValue("TIMESTAMP|NUMBER"), is(number("0")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|JST"), is(date("1970-01-01")));
+          assertThat(record.getDateFieldValue("TIMESTAMP|DATE|PST"), is(date("1969-12-31")));
+          assertThat(record.getTimeFieldValue("TIMESTAMP|TIME"), is(time("00:00:00")));
+          assertThat(record.getTimeFieldValue("TIMESTAMP|TIME|JST"), is(time("09:00:00")));
+          assertThat(record.getTimeFieldValue("TIMESTAMP|TIME|PST"), is(time("16:00:00")));
+          assertThat(
+              record.getDateTimeFieldValue("TIMESTAMP"), is(dateTime("1970-01-01T00:00:00Z")));
+          assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), is("\"\""));
+          assertThat(record.getMultiLineTextFieldValue("JSON"), is("\"\""));
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(record.getFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
           assertThat(updateKey.getField(), nullValue());
           assertThat(updateKey.getValue(), nullValue());
         },
@@ -440,8 +552,8 @@ public class KintoneColumnVisitorTest {
 
   @Test
   public void testUpdateKey() {
-    assertThrows(UnsupportedOperationException.class, () -> verifier("TIMESTAMP").verify());
-    KintoneColumnVisitorVerifier verifier = verifier("TIMESTAMP|NUMBER");
+    assertThrows(UnsupportedOperationException.class, () -> verifier(null, "TIMESTAMP").verify());
+    KintoneColumnVisitorVerifier verifier = verifier(null, "TIMESTAMP|NUMBER");
     verifier.verify(
         (record, updateKey) -> {
           assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
@@ -464,23 +576,27 @@ public class KintoneColumnVisitorTest {
         });
   }
 
-  private static KintoneColumnVisitorVerifier verifier(String updateKeyName) {
+  private static KintoneColumnVisitorVerifier verifier(String reduceKeyName, String updateKeyName) {
     Schema schema = build(Schema.builder());
     return new KintoneColumnVisitorVerifier(
         schema,
+        Collections.emptySet(),
         build(ImmutableMap.builder()),
+        reduceKeyName,
         updateKeyName,
         OutputPageBuilder.build(schema, KintoneColumnVisitorTest::build));
   }
 
   private static KintoneColumnVisitorVerifier verifier(
-      String updateKeyName, boolean preferNulls, boolean ignoreNulls) {
+      String reduceKeyName, String updateKeyName, boolean preferNulls, boolean ignoreNulls) {
     Schema schema = build(Schema.builder());
     return new KintoneColumnVisitorVerifier(
         schema,
+        Collections.emptySet(),
         build(ImmutableMap.builder()),
         preferNulls,
         ignoreNulls,
+        reduceKeyName,
         updateKeyName,
         OutputPageBuilder.build(schema, KintoneColumnVisitorTest::build));
   }
@@ -523,6 +639,7 @@ public class KintoneColumnVisitorTest {
         .add("STRING|TIME|PST", Types.STRING)
         .add("STRING|DATETIME", Types.STRING)
         .add("STRING|LINK", Types.STRING)
+        .add("STRING|SUBTABLE", Types.STRING)
         .add("TIMESTAMP|SINGLE_LINE_TEXT", Types.TIMESTAMP)
         .add("TIMESTAMP|NUMBER", Types.TIMESTAMP)
         .add("TIMESTAMP|DATE", Types.TIMESTAMP)
@@ -534,6 +651,8 @@ public class KintoneColumnVisitorTest {
         .add("TIMESTAMP", Types.TIMESTAMP)
         .add("JSON|SINGLE_LINE_TEXT", Types.JSON)
         .add("JSON", Types.JSON)
+        .add("JSON|SUBTABLE", Types.JSON)
+        .add("JSON|SUBTABLE.SINGLE_LINE_TEXT", Types.JSON)
         .build();
   }
 
@@ -576,6 +695,7 @@ public class KintoneColumnVisitorTest {
         .put(build("STRING|TIME|PST", it -> it.setType("TIME").setTimezone("US/Pacific")))
         .put(build("STRING|DATETIME", it -> it.setType("DATETIME")))
         .put(build("STRING|LINK", it -> it.setType("LINK")))
+        .put(build("STRING|SUBTABLE", it -> it.setType("SUBTABLE")))
         .put(build("TIMESTAMP|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
         .put(build("TIMESTAMP|NUMBER", it -> it.setType("NUMBER")))
         .put(build("TIMESTAMP|DATE", it -> it.setType("DATE").setTimezone("UTC")))
@@ -587,6 +707,8 @@ public class KintoneColumnVisitorTest {
         .put(build("TIMESTAMP", it -> it.setType("DATETIME")))
         .put(build("JSON|SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
         .put(build("JSON", it -> it.setType("MULTI_LINE_TEXT")))
+        .put(build("JSON|SUBTABLE", it -> it.setType("SUBTABLE")))
+        .put(build("JSON|SUBTABLE.SINGLE_LINE_TEXT", it -> it.setType("SINGLE_LINE_TEXT")))
         .build();
   }
 
@@ -634,6 +756,7 @@ public class KintoneColumnVisitorTest {
         .setNull("STRING|TIME|PST")
         .setNull("STRING|DATETIME")
         .setNull("STRING|LINK")
+        .setNull("STRING|SUBTABLE")
         .setNull("TIMESTAMP|SINGLE_LINE_TEXT")
         .setNull("TIMESTAMP|NUMBER")
         .setNull("TIMESTAMP|DATE")
@@ -645,6 +768,8 @@ public class KintoneColumnVisitorTest {
         .setNull("TIMESTAMP")
         .setNull("JSON|SINGLE_LINE_TEXT")
         .setNull("JSON")
+        .setNull("JSON|SUBTABLE")
+        .setNull("JSON|SUBTABLE.SINGLE_LINE_TEXT")
         .addRecord()
         .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", false)
         .setBoolean("BOOLEAN", false)
@@ -682,6 +807,7 @@ public class KintoneColumnVisitorTest {
         .setString("STRING|TIME|PST", "")
         .setString("STRING|DATETIME", "")
         .setString("STRING|LINK", "")
+        .setString("STRING|SUBTABLE", "")
         .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", Timestamp.ofInstant(Instant.EPOCH))
         .setTimestamp("TIMESTAMP|NUMBER", Timestamp.ofInstant(Instant.EPOCH))
         .setTimestamp("TIMESTAMP|DATE", Timestamp.ofInstant(Instant.EPOCH))
@@ -693,6 +819,8 @@ public class KintoneColumnVisitorTest {
         .setTimestamp("TIMESTAMP", Timestamp.ofInstant(Instant.EPOCH))
         .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString(""))
         .setJson("JSON", ValueFactory.newString(""))
+        .setJson("JSON|SUBTABLE", ValueFactory.newString(""))
+        .setJson("JSON|SUBTABLE.SINGLE_LINE_TEXT", ValueFactory.newString(""))
         .addRecord()
         .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", true)
         .setBoolean("BOOLEAN", true)
@@ -730,6 +858,7 @@ public class KintoneColumnVisitorTest {
         .setString("STRING|TIME|PST", "23:59:59")
         .setString("STRING|DATETIME", "1999-12-31T23:59:59Z")
         .setString("STRING|LINK", "abc")
+        .setString("STRING|SUBTABLE", String.format("[%s,%s,%s]", ROWS[0], ROWS[1], ROWS[2]))
         .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", timestamp("1999-12-31T23:59:59Z"))
         .setTimestamp("TIMESTAMP|NUMBER", timestamp("1999-12-31T23:59:59Z"))
         .setTimestamp("TIMESTAMP|DATE", timestamp("1999-12-31T23:59:59Z"))
@@ -741,6 +870,9 @@ public class KintoneColumnVisitorTest {
         .setTimestamp("TIMESTAMP", timestamp("1999-12-31T23:59:59Z"))
         .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString("abc"))
         .setJson("JSON", ValueFactory.newString("abc"))
+        .setJson(
+            "JSON|SUBTABLE", ValueFactory.newArray(value(ROWS[0]), value(ROWS[1]), value(ROWS[2])))
+        .setJson("JSON|SUBTABLE.SINGLE_LINE_TEXT", ValueFactory.newString("abc"))
         .addRecord()
         .setBoolean("BOOLEAN|SINGLE_LINE_TEXT", false)
         .setBoolean("BOOLEAN", false)
@@ -778,6 +910,7 @@ public class KintoneColumnVisitorTest {
         .setString("STRING|TIME|PST", "00:00:00")
         .setString("STRING|DATETIME", "2000-01-01T00:00:00Z")
         .setString("STRING|LINK", "def")
+        .setString("STRING|SUBTABLE", String.format("[%s,%s,%s]", ROWS[3], ROWS[4], ROWS[5]))
         .setTimestamp("TIMESTAMP|SINGLE_LINE_TEXT", timestamp("2000-01-01T00:00:00Z"))
         .setTimestamp("TIMESTAMP|NUMBER", timestamp("2000-01-01T00:00:00Z"))
         .setTimestamp("TIMESTAMP|DATE", timestamp("2000-01-01T00:00:00Z"))
@@ -789,32 +922,18 @@ public class KintoneColumnVisitorTest {
         .setTimestamp("TIMESTAMP", timestamp("2000-01-01T00:00:00Z"))
         .setJson("JSON|SINGLE_LINE_TEXT", ValueFactory.newString("def"))
         .setJson("JSON", ValueFactory.newString("def"))
+        .setJson(
+            "JSON|SUBTABLE", ValueFactory.newArray(value(ROWS[3]), value(ROWS[4]), value(ROWS[5])))
+        .setJson("JSON|SUBTABLE.SINGLE_LINE_TEXT", ValueFactory.newString("def"))
         .addRecord()
         .build();
   }
 
-  private static BigDecimal number(String value) {
-    return new BigDecimal(value);
-  }
-
-  @SafeVarargs
-  private static <T> List<T> list(T... a) {
-    return Arrays.asList(a);
-  }
-
-  private static LocalDate date(CharSequence text) {
-    return LocalDate.parse(text);
-  }
-
-  private static LocalTime time(CharSequence text) {
-    return LocalTime.parse(text);
-  }
-
-  private static ZonedDateTime dateTime(CharSequence text) {
-    return ZonedDateTime.parse(text);
-  }
-
   private static Timestamp timestamp(CharSequence text) {
     return Timestamp.ofInstant(Instant.parse(text));
   }
+
+  private static Value value(String json) {
+    return PARSER.parse(json);
+  }
 }