embulk-filter-add_time 0.1.0

data/src/main/java/org/embulk/filter/add_time/reader/StringColumnReader.java

@@ -0,0 +1,35 @@
+package org.embulk.filter.add_time.reader;
+
+import org.embulk.filter.add_time.converter.ValueConverter;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageReader;
+
+public class StringColumnReader
+        extends AbstractColumnReader<StringColumnReader>
+{
+    protected String value;
+
+    public StringColumnReader(ValueConverter valueConverter)
+    {
+        super(valueConverter);
+    }
+
+    @Override
+    public void readNonNullValue(Column column, PageReader pageReader)
+    {
+        value = pageReader.getString(column);
+    }
+
+    @Override
+    public void convertNonNullValue(Column column, PageBuilder pageBuilder)
+    {
+        valueConverter.convertValue(column, value, pageBuilder);
+    }
+
+    @Override
+    public void copyValueTo(StringColumnReader columnReader)
+    {
+        columnReader.value = this.value;
+    }
+}

data/src/main/java/org/embulk/filter/add_time/reader/TimeValueGenerator.java

@@ -0,0 +1,177 @@
+package org.embulk.filter.add_time.reader;
+
+import com.google.common.base.Optional;
+import org.embulk.config.ConfigException;
+import org.embulk.filter.add_time.AddTimeFilterPlugin.FromValueConfig;
+import org.embulk.filter.add_time.AddTimeFilterPlugin.UnixTimestampUnit;
+import org.embulk.filter.add_time.converter.ValueConverter;
+import org.embulk.spi.Column;
+import org.embulk.spi.Exec;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampParser;
+
+public abstract class TimeValueGenerator
+        implements ColumnReader
+{
+    private final ValueConverter valueConverter;
+
+    public TimeValueGenerator(ValueConverter valueConverter)
+    {
+        this.valueConverter = valueConverter;
+    }
+
+    protected abstract Timestamp nextTimestamp();
+
+    @Override
+    public void readValue(Column column, PageReader pageReader)
+    {
+        throw new AssertionError("Never call");
+    }
+
+    @Override
+    public void convertValue(Column column, PageBuilder pageBuilder)
+    {
+        valueConverter.convertValue(column, nextTimestamp(), pageBuilder);
+    }
+
+    @Override
+    public void copyTo(ColumnReader columnReader)
+    {
+        throw new AssertionError("Never call");
+    }
+
+    public static TimeValueGenerator newGenerator(final FromValueConfig config, ValueConverter valueConverter)
+    {
+        switch (config.getMode()) {
+            case "fixed_time":
+                require(config.getValue(), "'value'");
+                reject(config.getFrom(), "'from'");
+                reject(config.getTo(), "'to'");
+                return new FixedTimeValueGenerator(config, valueConverter);
+
+            case "incremental_time": // default mode
+                require(config.getFrom(), "'from', 'to'");
+                require(config.getTo(), "'to'");
+                reject(config.getValue(), "'value'");
+                return new IncrementalTimeValueGenerator(config, valueConverter);
+
+            case "upload_time":
+                reject(config.getFrom(), "'value'");
+                reject(config.getFrom(), "'from'");
+                reject(config.getTo(), "'to'");
+                return new UploadTimeValueGenerator(valueConverter);
+
+            default:
+                throw new ConfigException(String.format("Unknwon mode '%s'. Supported methods are incremental_time, fixed_time.", config.getMode()));
+        }
+    }
+
+    public static class IncrementalTimeValueGenerator
+            extends TimeValueGenerator
+    {
+        private final Timestamp from;
+        private final Timestamp to;
+
+        private Timestamp current;
+
+        public IncrementalTimeValueGenerator(final FromValueConfig config, ValueConverter valueConverter)
+        {
+            super(valueConverter);
+            current = from = toTimestamp(config, config.getFrom().get());
+            to = toTimestamp(config, config.getTo().get());
+        }
+
+        @Override
+        public Timestamp nextTimestamp()
+        {
+            try {
+                Timestamp ret = current;
+                current = Timestamp.ofEpochSecond(current.getEpochSecond() + 1, current.getNano());
+                return ret;
+            }
+            finally {
+                if (current.compareTo(to) > 0) {
+                    current = from;
+                }
+            }
+        }
+    }
+
+    public static class FixedTimeValueGenerator
+            extends TimeValueGenerator
+    {
+        private final Timestamp value;
+
+        public FixedTimeValueGenerator(FromValueConfig config, ValueConverter valueConverter)
+        {
+            this(toTimestamp(config, config.getValue().get()), valueConverter);
+        }
+
+        public FixedTimeValueGenerator(Timestamp value, ValueConverter valueConverter)
+        {
+            super(valueConverter);
+            this.value = value;
+        }
+
+        @Override
+        public Timestamp nextTimestamp()
+        {
+            return value;
+        }
+
+    }
+
+    public static class UploadTimeValueGenerator
+            extends FixedTimeValueGenerator
+    {
+        public UploadTimeValueGenerator(ValueConverter valueConverter)
+        {
+            super(Exec.getTransactionTime(), valueConverter);
+        }
+    }
+
+    // ported from embulk-input-s3
+    private static <T> T require(Optional<T> value, String message)
+    {
+        if (value.isPresent()) {
+            return typeCheck(value.get(), message);
+        }
+        else {
+            throw new ConfigException("Required option is not set: " + message);
+        }
+    }
+
+    // ported from embulk-input-s3
+    private static <T> void reject(Optional<T> value, String message)
+    {
+        if (value.isPresent()) {
+            throw new ConfigException("Invalid option is set: " + message);
+        }
+    }
+
+    private static <T> T typeCheck(T value, String message)
+    {
+        if (value instanceof String || value instanceof Number) {
+            return value;
+        }
+        else {
+            throw new ConfigException("Required option must be string or long: " + message);
+        }
+    }
+
+    private static Timestamp toTimestamp(FromValueConfig config, Object time)
+    {
+        if (time instanceof String) {
+            return new TimestampParser(config, config).parse((String) time); // TODO optimize?
+        }
+        else if (time instanceof Number) {
+            long t = ((Number) time).longValue();
+            return UnixTimestampUnit.of(config.getUnixTimestampUnit()).toTimestamp(t);
+        }
+        else {
+            throw new RuntimeException();
+        }
+    }
+}

data/src/main/java/org/embulk/filter/add_time/reader/TimestampColumnReader.java

@@ -0,0 +1,36 @@
+package org.embulk.filter.add_time.reader;
+
+import org.embulk.filter.add_time.converter.ValueConverter;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.time.Timestamp;
+
+public class TimestampColumnReader
+        extends AbstractColumnReader<TimestampColumnReader>
+{
+    protected Timestamp value;
+
+    public TimestampColumnReader(ValueConverter valueConverter)
+    {
+        super(valueConverter);
+    }
+
+    @Override
+    public void readNonNullValue(Column column, PageReader pageReader)
+    {
+        value = pageReader.getTimestamp(column);
+    }
+
+    @Override
+    public void convertNonNullValue(Column column, PageBuilder pageBuilder)
+    {
+        valueConverter.convertValue(column, value, pageBuilder);
+    }
+
+    @Override
+    public void copyValueTo(TimestampColumnReader columnReader)
+    {
+        columnReader.value = this.value;
+    }
+}

data/src/test/java/org/embulk/filter/add_time/TestAddTimeFilterPlugin.java

@@ -0,0 +1,416 @@
+package org.embulk.filter.add_time;
+
+import com.google.common.collect.ImmutableMap;
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.TaskSource;
+import org.embulk.filter.add_time.AddTimeFilterPlugin.PluginTask;
+import org.embulk.spi.FilterPlugin;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageOutput;
+import org.embulk.spi.PageTestUtils;
+import org.embulk.spi.Schema;
+import org.embulk.spi.TestPageBuilderReader.MockPageOutput;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import org.embulk.spi.util.Pages;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+
+public class TestAddTimeFilterPlugin
+{
+    @Rule
+    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
+
+    private AddTimeFilterPlugin plugin;
+    private ConfigSource config;
+    private Schema inputSchema;
+    private List<Object[]> records;
+
+    @Before
+    public void createResources()
+    {
+        plugin = plugin();
+        config = runtime.getExec().newConfigSource();
+        inputSchema = schema("c0", Types.BOOLEAN, "c1", Types.LONG, "c2", Types.DOUBLE, "c3", Types.STRING, "c4", Types.TIMESTAMP);
+    }
+
+    @Test
+    public void testFromColumn()
+    {
+        { // long type
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_column", ImmutableMap.of("name", "c1", "unix_timestamp_unit", "sec"));
+            List<Page> pages = newPages(true, 1451646671L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(1451646671L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+
+        { // timestamp type
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_column", ImmutableMap.of("name", "c4"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+
+        { // string type
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_column", ImmutableMap.of("name", "c3"));
+            List<Page> pages = newPages(true, 0L, 0.1, "2016-01-01 11:11:11 UTC", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("2016-01-01 11:11:11 UTC", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+    }
+
+    @Test
+    public void testFromValue()
+    {
+        // mode: fixed_time
+        {
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+        { // specifies timestamp_format
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11.000 UTC", "timestamp_format", "%Y-%m-%d %H:%M:%S.%N %Z"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+        { // specifies unix_timestamp_unit
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", 1451646671, "unix_timestamp_unit", "sec"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+
+        // mode: incremental_time
+        {
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "incremental_time",
+                            "from", "2016-01-01 11:11:11 UTC", "to", "2016-01-01 11:11:12 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+        { // specifies timestamp_format
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "incremental_time",
+                            "from", "2016-01-01 11:11:11.000 UTC", "to", "2016-01-01 11:11:12.000 UTC", "timestamp_format", "%Y-%m-%d %H:%M:%S.%N %Z"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+        { // specifies unix_timestamp_unit
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "incremental_time",
+                            "from", 1451646671, "to", 1451646672, "unix_timestamp_unit", "sec"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+
+        // mode: upload_time
+        {
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "upload_time"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(runtime.getExec().getTransactionTime(), record[5]);
+            }
+        }
+    }
+
+    @Test
+    public void testToColumn()
+    {
+        // timestamp type
+        {
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, ((Timestamp) record[5]).getEpochSecond());
+            }
+        }
+
+        // long type
+        { // unix_timestamp: sec
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time", "type", "long", "unix_timestamp_unit", "sec"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671L, record[5]);
+            }
+        }
+        { // unix_timestamp: milli
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time", "type", "long", "unix_timestamp_unit", "milli"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671000L, record[5]);
+            }
+        }
+        { // unix_timestamp: micro
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time", "type", "long", "unix_timestamp_unit", "micro"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671000000L, record[5]);
+            }
+        }
+        { // unix_timestamp: nano
+            ConfigSource conf = this.config.deepCopy()
+                    .set("to_column", ImmutableMap.of("name", "time", "type", "long", "unix_timestamp_unit", "nano"))
+                    .set("from_value", ImmutableMap.of("mode", "fixed_time", "value", "2016-01-01 11:11:11 UTC"));
+            List<Page> pages = newPages(true, 0L, 0.1, "foo", Timestamp.ofEpochSecond(1451646671));
+
+            callTansaction(conf, inputSchema, pages);
+
+            assertEquals(1, records.size());
+            for (Object[] record : records) {
+                assertEquals(inputSchema.size() + 1, record.length);
+
+                assertEquals(true, record[0]);
+                assertEquals(0L, record[1]);
+                assertEquals(0.1, record[2]);
+                assertEquals("foo", record[3]);
+                assertEquals(1451646671L, ((Timestamp) record[4]).getEpochSecond());
+                assertEquals(1451646671000000000L, record[5]);
+            }
+        }
+    }
+
+    private List<Page> newPages(Object... values)
+    {
+        return PageTestUtils.buildPage(runtime.getBufferAllocator(), inputSchema, values);
+    }
+
+    private void callTansaction(ConfigSource conf, final Schema inputSchema, final List<Page> pages)
+    {
+        final MockPageOutput output = new MockPageOutput();
+        plugin.transaction(conf, inputSchema, new FilterPlugin.Control() {
+            @Override
+            public void run(TaskSource taskSource, Schema outputSchema)
+            {
+                try (PageOutput out = plugin.open(taskSource, inputSchema, outputSchema, output)) {
+                    for (Page page : pages) {
+                        out.add(page);
+                    }
+                    out.finish();
+                }
+                records = Pages.toObjects(outputSchema, output.pages);
+            }
+        });
+    }
+
+    public static Schema schema(Object... nameAndTypes)
+    {
+        Schema.Builder builder = Schema.builder();
+        for (int i = 0; i < nameAndTypes.length; i += 2) {
+            String name = (String) nameAndTypes[i];
+            Type type = (Type) nameAndTypes[i + 1];
+            builder.add(name, type);
+        }
+        return builder.build();
+    }
+
+    public static PluginTask pluginTask(ConfigSource config)
+    {
+        return config.loadConfig(PluginTask.class);
+    }
+
+    public static AddTimeFilterPlugin plugin()
+    {
+        return spy(new AddTimeFilterPlugin());
+    }
+}