embulk-output-kintone 1.0.0 → 1.2.0

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,29 +14,37 @@ 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) -> {
+        (record, idOrUpdateKey) -> {
           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"));
@@ -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,11 +101,14 @@ 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(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is(""));
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is(""));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           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"));
@@ -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,11 +165,14 @@ 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(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is(""));
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"\""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is(""));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("true"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("1")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("123"));
@@ -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,11 +230,14 @@ 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\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is("abc"));
+          assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(0L, 1L, 2L));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"abc\""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is("abc"));
         });
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getSingleLineTextFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), is("false"));
           assertThat(record.getNumberFieldValue("BOOLEAN"), is(number("0")));
           assertThat(record.getSingleLineTextFieldValue("LONG|SINGLE_LINE_TEXT"), is("456"));
@@ -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,16 +295,19 @@ 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\""));
-          assertThat(updateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
-          assertThat(updateKey.getValue(), is("def"));
+          assertTableRows(record.getSubtableFieldValue("JSON|SUBTABLE"), rows(3L, 4L, 5L));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), is("\"def\""));
+          assertThat(idOrUpdateKey.getField(), is("STRING|SINGLE_LINE_TEXT"));
+          assertThat(idOrUpdateKey.getValue(), is("def"));
         });
   }
 
   @Test
   public void testPreferNulls() {
-    KintoneColumnVisitorVerifier verifier = verifier("LONG", true, false);
+    KintoneColumnVisitorVerifier verifier = verifier(null, "LONG", true, false);
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(
               record.getFieldType("BOOLEAN|SINGLE_LINE_TEXT"), is(FieldType.SINGLE_LINE_TEXT));
           assertThat(record.getFieldType("BOOLEAN"), is(FieldType.NUMBER));
@@ -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,16 +412,19 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getDateTimeFieldValue("TIMESTAMP"), nullValue());
           assertThat(record.getSingleLineTextFieldValue("JSON|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getMultiLineTextFieldValue("JSON"), nullValue());
-          assertThat(updateKey.getField(), is("LONG"));
-          assertThat(updateKey.getValue(), nullValue());
+          assertThat(record.getSubtableFieldValue("JSON|SUBTABLE"), is(list()));
+          assertThat(
+              record.getSingleLineTextFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
+          assertThat(idOrUpdateKey.getField(), is("LONG"));
+          assertThat(idOrUpdateKey.getValue(), nullValue());
         });
   }
 
   @Test
   public void testIgnoreNulls() {
-    KintoneColumnVisitorVerifier verifier = verifier("JSON", false, true);
+    KintoneColumnVisitorVerifier verifier = verifier("JSON", "JSON", false, true);
     verifier.verify(
-        (record, updateKey) -> {
+        (record, idOrUpdateKey) -> {
           assertThat(record.getFieldValue("BOOLEAN|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getFieldValue("BOOLEAN"), nullValue());
           assertThat(record.getFieldValue("LONG|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,55 +473,130 @@ public class KintoneColumnVisitorTest {
           assertThat(record.getFieldValue("TIMESTAMP"), nullValue());
           assertThat(record.getFieldValue("JSON|SINGLE_LINE_TEXT"), nullValue());
           assertThat(record.getFieldValue("JSON"), nullValue());
-          assertThat(updateKey.getField(), nullValue());
-          assertThat(updateKey.getValue(), nullValue());
+          assertThat(record.getFieldValue("JSON|SUBTABLE"), nullValue());
+          assertThat(record.getFieldValue("JSON|SUBTABLE.SINGLE_LINE_TEXT"), nullValue());
+          assertThat(idOrUpdateKey.getField(), nullValue());
+          assertThat(idOrUpdateKey.getValue(), nullValue());
+        },
+        true);
+  }
+
+  @Test
+  public void testReduceKey() {
+    KintoneColumnVisitorVerifier verifier = verifier("JSON|SUBTABLE", null);
+    verifier.verify(
+        (record, idOrUpdateKey) -> {
+          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(idOrUpdateKey.getField(), nullValue());
+          assertThat(idOrUpdateKey.getValue(), nullValue());
         },
         true);
   }
 
   @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"));
-          assertThat(updateKey.getValue(), is(number("0")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("0")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("0")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("0")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("946684799")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("946684799")));
         });
     verifier.verify(
-        (record, updateKey) -> {
-          assertThat(updateKey.getField(), is("TIMESTAMP|NUMBER"));
-          assertThat(updateKey.getValue(), is(number("946684800")));
+        (record, idOrUpdateKey) -> {
+          assertThat(idOrUpdateKey.getField(), is("TIMESTAMP|NUMBER"));
+          assertThat(idOrUpdateKey.getValue(), is(number("946684800")));
         });
   }
 
-  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);
+  }
 }

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

@@ -2,10 +2,11 @@ package org.embulk.output.kintone;
 
 import com.kintone.client.model.record.FieldType;
 import com.kintone.client.model.record.Record;
-import com.kintone.client.model.record.UpdateKey;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import javax.validation.UnexpectedTypeException;
+import org.embulk.output.kintone.record.IdOrUpdateKey;
 import org.embulk.spi.Column;
 import org.embulk.spi.Page;
 import org.embulk.spi.PageReader;
@@ -18,43 +19,52 @@ public class KintoneColumnVisitorVerifier {
   private final KintoneColumnVisitor visitor;
 
   public KintoneColumnVisitorVerifier(
-      Schema schema, Map<String, KintoneColumnOption> options, String updateKeyName, Page page) {
-    this(schema, options, false, false, updateKeyName, page);
+      Schema schema,
+      Set<Column> derived,
+      Map<String, KintoneColumnOption> options,
+      String reduceKeyName,
+      String updateKeyName,
+      Page page) {
+    this(schema, derived, options, false, false, reduceKeyName, updateKeyName, page);
   }
 
   public KintoneColumnVisitorVerifier(
       Schema schema,
+      Set<Column> derived,
       Map<String, KintoneColumnOption> options,
       boolean preferNulls,
       boolean ignoreNulls,
+      String reduceKeyName,
       String updateKeyName,
       Page page) {
     this.schema = schema;
     this.options = options;
     reader = new PageReader(schema);
     reader.setPage(page);
-    visitor = new KintoneColumnVisitor(reader, options, preferNulls, ignoreNulls, updateKeyName);
+    visitor =
+        new KintoneColumnVisitor(
+            reader, derived, options, preferNulls, ignoreNulls, reduceKeyName, updateKeyName);
   }
 
   public void verify() {
     verify((record, updateKey) -> {});
   }
 
-  public void verify(BiConsumer<Record, UpdateKey> consumer) {
+  public void verify(BiConsumer<Record, IdOrUpdateKey> consumer) {
     verify(consumer, false);
   }
 
-  public void verify(BiConsumer<Record, UpdateKey> consumer, boolean nullable) {
+  public void verify(BiConsumer<Record, IdOrUpdateKey> consumer, boolean nullable) {
     if (!reader.nextRecord()) {
       throw new IllegalStateException();
     }
     Record record = new Record();
     visitor.setRecord(record);
-    UpdateKey updateKey = new UpdateKey();
-    visitor.setUpdateKey(updateKey);
+    IdOrUpdateKey idOrUpdateKey = new IdOrUpdateKey();
+    visitor.setIdOrUpdateKey(idOrUpdateKey);
     schema.visitColumns(visitor);
     schema.getColumns().forEach(column -> verify(record, column, nullable));
-    consumer.accept(record, updateKey);
+    consumer.accept(record, idOrUpdateKey);
   }
 
   private void verify(Record record, Column column, boolean nullable) {