embulk-output-td 0.1.0

data/src/main/java/com/treasuredata/api/model/TDTablePermission.java

@@ -0,0 +1,48 @@
+package com.treasuredata.api.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Objects;
+
+public class TDTablePermission
+{
+    private boolean importable;
+    private boolean queryable;
+
+    public TDTablePermission(
+            @JsonProperty("importable") boolean importable,
+            @JsonProperty("queryable") boolean queryable)
+    {
+        this.importable = importable;
+        this.queryable = queryable;
+    }
+
+    @JsonProperty("importable")
+    public boolean isImportable() {
+        return importable;
+    }
+
+    @JsonProperty("queryable")
+    public boolean isQueryable() {
+        return queryable;
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        TDTablePermission other = (TDTablePermission) obj;
+        return Objects.equal(this.importable, other.importable) &&
+                Objects.equal(this.queryable, other.queryable);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hashCode(importable, queryable);
+    }
+}

data/src/main/java/com/treasuredata/api/model/TDTableSchema.java

@@ -0,0 +1,44 @@
+package com.treasuredata.api.model;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Objects;
+
+import java.util.List;
+
+public class TDTableSchema
+{
+    private List<TDColumn> columns;
+
+    @JsonCreator
+    public TDTableSchema(
+            @JsonProperty("columns") List<TDColumn> columns)
+    {
+        this.columns = columns;
+    }
+
+    @JsonProperty
+    public List<TDColumn> getColumns()
+    {
+        return columns;
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        TDTableSchema other = (TDTableSchema) obj;
+        return Objects.equal(this.columns, other.columns);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hashCode(columns);
+    }
+}

data/src/main/java/com/treasuredata/api/model/TDTableType.java

@@ -0,0 +1,36 @@
+package com.treasuredata.api.model;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import com.fasterxml.jackson.databind.RuntimeJsonMappingException;
+
+public enum TDTableType
+{
+    LOG("log"),
+    ITEM("item");
+
+    private String name;
+
+    private TDTableType(String name)
+    {
+        this.name = name;
+    }
+
+    @JsonCreator
+    public static TDTableType fromName(String name)
+    {
+        if ("log".equals(name)) {
+            return LOG;
+        } else if ("item".equals(name)) {
+            return ITEM;
+        }
+        throw new RuntimeJsonMappingException("Unexpected string tuple to deserialize TDTableType");
+    }
+
+    @JsonValue
+    @Override
+    public String toString()
+    {
+        return name;
+    }
+}

data/src/main/java/org/embulk/output/FinalizableExecutorService.java

@@ -0,0 +1,84 @@
+package org.embulk.output;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class FinalizableExecutorService
+{
+    public static class NotCloseable
+            implements Closeable
+    {
+        @Override
+        public void close()
+                throws IOException {
+            // ignore
+        }
+    }
+
+    protected ExecutorService threads;
+    protected Queue<RunningTask> runningTasks;
+
+    public FinalizableExecutorService() {
+        this.threads = Executors.newCachedThreadPool();
+        this.runningTasks = new LinkedList<>();
+    }
+
+    private static class RunningTask {
+        private Future<Void> future;
+        private Closeable finalizer;
+
+        RunningTask(Future<Void> future, Closeable finalizer) {
+            this.future = future;
+            this.finalizer = finalizer;
+        }
+
+        public void join() throws IOException {
+            try {
+                future.get();
+            } catch (InterruptedException ex) {
+                throw new IOException(ex);
+            } catch (ExecutionException ex) {
+                throw new IOException(ex.getCause());
+            }
+            finalizer.close();
+        }
+
+        public void abort() throws IOException {
+            finalizer.close();
+        }
+    }
+
+    public void submit(Callable<Void> task, Closeable finalizer) {
+        Future<Void> future = threads.submit(task);
+        runningTasks.add(new RunningTask(future, finalizer));
+    }
+
+    public void joinPartial(long upto) throws IOException {
+        while(runningTasks.size() > upto) {
+            runningTasks.peek().join();
+            runningTasks.remove();
+        }
+    }
+
+    public void joinAll() throws IOException {
+        joinPartial(0);
+    }
+
+    public void shutdown() throws IOException {
+        try {
+            joinAll();
+        } finally {
+            threads.shutdown();
+            for(RunningTask task : runningTasks) {
+                task.abort();
+            }
+        }
+    }
+}

data/src/main/java/org/embulk/output/MsgpackGZFileBuilder.java

@@ -0,0 +1,148 @@
+package org.embulk.output;
+
+import org.msgpack.MessagePack;
+import org.msgpack.packer.Packer;
+
+import java.io.BufferedOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.zip.GZIPOutputStream;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class MsgpackGZFileBuilder
+        implements Closeable
+{
+    static class DataSizeFilter extends FilterOutputStream {
+        private long size = 0;
+
+        public DataSizeFilter(OutputStream out) {
+            super(out);
+        }
+
+        @Override
+        public void write(int b) throws IOException
+        {
+            size += 1;
+            super.write(b);
+        }
+
+        @Override
+        public void write(byte[] b, int off, int len) throws IOException
+        {
+            size += len;
+            super.write(b, off, len);
+        }
+
+        @Override
+        public void close() throws IOException
+        {
+            super.close();
+        }
+
+        public long size()
+        {
+            return size;
+        }
+    }
+
+    private final File file;
+    private final DataSizeFilter out;
+    private final GZIPOutputStream gzout;
+
+    private Packer packer;
+    private long recordCount;
+
+    public MsgpackGZFileBuilder(MessagePack msgpack, File file)
+            throws IOException
+    {
+        this.file = checkNotNull(file);
+        this.out = new DataSizeFilter(new BufferedOutputStream(new FileOutputStream(file)));
+        this.gzout = new GZIPOutputStream(this.out);
+        this.packer = msgpack.createPacker(this.gzout);
+
+        this.recordCount = 0;
+    }
+
+    public long getRecordCount()
+    {
+        return recordCount;
+    }
+
+    public long getWrittenSize()
+    {
+        return out.size();
+    }
+
+    public File getFile()
+    {
+        return file;
+    }
+
+    public void finish()
+            throws IOException
+    {
+        try {
+            packer.flush();
+        } finally {
+            close();
+        }
+    }
+
+    @Override
+    public void close()
+            throws IOException
+    {
+        if (packer != null) {
+            packer.close();
+            packer = null;
+        }
+    }
+
+    public void writeNil()
+            throws IOException
+    {
+        packer.writeNil();
+    }
+
+    public void writeMapBegin(int size)
+            throws IOException
+    {
+        packer.writeMapBegin(size);
+    }
+
+    public void writeMapEnd()
+            throws IOException
+    {
+        packer.writeMapEnd();
+        recordCount++;
+    }
+
+    public void writeString(String v)
+            throws IOException
+    {
+        packer.write(v);
+    }
+
+    public void writeBoolean(boolean v)
+            throws IOException
+    {
+        packer.write(v);
+    }
+
+    public void writeLong(long v)
+            throws IOException
+    {
+        packer.write(v);
+    }
+
+    public void writeDouble(double v)
+            throws IOException
+    {
+        packer.write(v);
+    }
+}

data/src/main/java/org/embulk/output/RecordWriter.java

@@ -0,0 +1,567 @@
+package org.embulk.output;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Throwables;
+import com.treasuredata.api.TdApiClient;
+import org.embulk.config.CommitReport;
+import org.embulk.config.ConfigException;
+import org.embulk.output.TdOutputPlugin.PluginTask;
+import org.embulk.spi.Column;
+import org.embulk.spi.ColumnVisitor;
+import org.embulk.spi.Exec;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.Schema;
+import org.embulk.spi.TransactionalPageOutput;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.StringType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.Type;
+import org.joda.time.DateTimeZone;
+import org.jruby.embed.ScriptingContainer;
+import org.msgpack.MessagePack;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.NumberFormat;
+import java.util.concurrent.Callable;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class RecordWriter
+        implements TransactionalPageOutput
+{
+    private final Logger log;
+    private final TdApiClient client;
+    private final String sessionName;
+
+    private final MessagePack msgpack;
+    private final FieldWriterSet fieldWriters;
+    private final File tempDir;
+
+    private int seqid = 0;
+    private PageReader pageReader;
+    private MsgpackGZFileBuilder builder;
+
+    private final FinalizableExecutorService executor;
+    private final int uploadConcurrency;
+    private final long fileSplitSize; // unit: kb
+
+    public RecordWriter(PluginTask task, TdApiClient client, FieldWriterSet fieldWriters)
+    {
+        this.log = Exec.getLogger(getClass());
+        this.client = checkNotNull(client);
+        this.sessionName = task.getSessionName();
+
+        this.msgpack = new MessagePack();
+        this.fieldWriters = fieldWriters;
+        this.tempDir = new File(task.getTempDir());
+        this.executor = new FinalizableExecutorService();
+        this.uploadConcurrency = task.getUploadConcurrency();
+        this.fileSplitSize = task.getFileSplitSize() * 1024;
+    }
+
+    public static void validateSchema(Logger log, PluginTask task, Schema schema)
+    {
+        new FieldWriterSet(log, task, schema);
+    }
+
+    void open(final Schema schema)
+            throws IOException
+    {
+        this.pageReader = new PageReader(checkNotNull(schema));
+        prepareNextBuilder();
+    }
+
+    private void prepareNextBuilder()
+            throws IOException
+    {
+        String prefix = String.format("%s-%d-", sessionName, seqid);
+        File tempFile = File.createTempFile(prefix, ".msgpack.gz", tempDir);
+        this.builder = new MsgpackGZFileBuilder(msgpack, tempFile);
+    }
+
+    @Override
+    public void add(final Page page)
+    {
+        pageReader.setPage(checkNotNull(page));
+
+        try {
+            while (pageReader.nextRecord()) {
+                builder.writeMapBegin(fieldWriters.getFieldCount());
+
+                pageReader.getSchema().visitColumns(new ColumnVisitor() {
+                    @Override
+                    public void booleanColumn(Column column)
+                    {
+                        write(column);
+                    }
+
+                    @Override
+                    public void longColumn(Column column)
+                    {
+                        write(column);
+                    }
+
+                    @Override
+                    public void doubleColumn(Column column)
+                    {
+                        write(column);
+                    }
+
+                    @Override
+                    public void stringColumn(Column column)
+                    {
+                        write(column);
+                    }
+
+                    @Override
+                    public void timestampColumn(Column column)
+                    {
+                        write(column);
+                    }
+
+                    private void write(Column column)
+                    {
+                        FieldWriter fieldWriter = fieldWriters.getFieldWriter(column.getIndex());
+                        try {
+                            fieldWriter.writeKeyValue(builder, pageReader, column);
+                        } catch (IOException e) {
+                            throw Throwables.propagate(e);
+                        }
+                    }
+                });
+
+                builder.writeMapEnd();
+
+                if (builder.getWrittenSize() > fileSplitSize) {
+                    flush();
+                }
+            }
+
+        } catch (IOException e) {
+            throw Throwables.propagate(e);
+        }
+    }
+
+    public void flush() throws IOException
+    {
+        builder.finish();
+
+        if (builder.getRecordCount() > 0) {
+            log.info("{uploading: {rows: {}, size: {} bytes (compressed)}}",
+                    builder.getRecordCount(),
+                    NumberFormat.getNumberInstance().format(builder.getWrittenSize()));
+            upload(builder);
+            builder = null;
+        }
+
+        prepareNextBuilder();
+    }
+
+    private void upload(final MsgpackGZFileBuilder builder)
+            throws IOException
+    {
+        executor.joinPartial(uploadConcurrency - 1);
+        executor.submit(new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                client.uploadBulkImport(sessionName, builder.getFile());
+                return null;
+            }
+        }, builder);
+        seqid++;
+    }
+
+    @Override
+    public void finish()
+    {
+        try {
+            flush();
+        } catch (IOException e) {
+            throw Throwables.propagate(e);
+        } finally {
+            close();
+        }
+    }
+
+    @Override
+    public void close()
+    {
+        try {
+            try {
+                executor.joinAll();
+                executor.shutdown(); // shutdown calls joinAll
+            } finally {
+                if (builder != null) {
+                    builder.close();
+                    builder = null;
+                }
+
+                if (client != null) {
+                    client.close();
+                }
+            }
+        } catch (IOException e) {
+            throw Throwables.propagate(e);
+        }
+    }
+
+    @Override
+    public void abort()
+    {
+        //  do nothing
+    }
+
+    @Override
+    public CommitReport commit()
+    {
+        CommitReport report = Exec.newCommitReport();
+        //  TODO
+        return report;
+    }
+
+    static class FieldWriterSet
+    {
+        private enum ColumnWriterMode
+        {
+            PRIMARY_KEY,
+            SIMPLE_VALUE,
+            DUPLICATE_PRIMARY_KEY;
+        }
+
+        private final int fieldCount;
+        private final FieldWriter[] fieldWriters;
+
+        public FieldWriterSet(Logger log, PluginTask task, Schema schema)
+        {
+            Optional<String> userDefinedPrimaryKeySourceColumnName = task.getTimeColumn();
+            boolean hasPkWriter = false;
+            int duplicatePrimaryKeySourceIndex = -1;
+            int firstTimestampColumnIndex = -1;
+
+            int fc = 0;
+            fieldWriters = new FieldWriter[schema.size()];
+
+            for (int i = 0; i < schema.size(); i++) {
+                String columnName = schema.getColumnName(i);
+                Type columnType = schema.getColumnType(i);
+
+                // choose the mode
+                final ColumnWriterMode mode;
+
+                if (userDefinedPrimaryKeySourceColumnName.isPresent() &&
+                        columnName.equals(userDefinedPrimaryKeySourceColumnName.get())) {
+                    // found time_column
+                    if ("time".equals(userDefinedPrimaryKeySourceColumnName.get())) {
+                        mode = ColumnWriterMode.PRIMARY_KEY;
+                    } else {
+                        mode = ColumnWriterMode.DUPLICATE_PRIMARY_KEY;
+                    }
+
+                } else if ("time".equals(columnName)) {
+                    // the column name is same with the primary key name.
+                    if (userDefinedPrimaryKeySourceColumnName.isPresent()) {
+                        columnName = newColumnUniqueName(columnName, schema);
+                        mode = ColumnWriterMode.SIMPLE_VALUE;
+                        log.warn("time_column '{}' is set but 'time' column also exists. The existent 'time' column is renamed to {}",
+                                userDefinedPrimaryKeySourceColumnName.get(), "time", "time", columnName);
+                    } else {
+                        mode = ColumnWriterMode.PRIMARY_KEY;
+                    }
+
+                } else {
+                    mode = ColumnWriterMode.SIMPLE_VALUE;
+                }
+
+                // create the fieldWriters writer depending on the mode
+                final FieldWriter writer;
+
+                switch (mode) {
+                    case PRIMARY_KEY:
+                        log.info("Using {}:{} column as the data partitioning key", columnName, columnType);
+                        if (columnType instanceof LongType) {
+                            writer = new LongFieldWriter(columnName);
+                            hasPkWriter = true;
+                        } else if (columnType instanceof TimestampType) {
+                            writer = new TimestampStringFieldWriter(task.getJRuby(), columnName);
+                            hasPkWriter = true;
+                        } else {
+                            throw new ConfigException(String.format("Type of '%s' column must be long or timestamp but got %s",
+                                    columnName, columnType));
+                        }
+                        break;
+
+                    case SIMPLE_VALUE:
+                        if (columnType instanceof BooleanType) {
+                            writer = new BooleanFieldWriter(columnName);
+                        } else if (columnType instanceof LongType) {
+                            writer = new LongFieldWriter(columnName);
+                        } else if (columnType instanceof DoubleType) {
+                            writer = new DoubleFieldWriter(columnName);
+                        } else if (columnType instanceof StringType) {
+                            writer = new StringFieldWriter(columnName);
+                        } else if (columnType instanceof TimestampType) {
+                            writer = new TimestampStringFieldWriter(task.getJRuby(), columnName);
+                            if (firstTimestampColumnIndex < 0) {
+                                firstTimestampColumnIndex = i;
+                            }
+                        } else {
+                            throw new ConfigException("Unsupported type: " + columnType);
+                        }
+                        break;
+
+                    case DUPLICATE_PRIMARY_KEY:
+                        duplicatePrimaryKeySourceIndex = i;
+                        writer = null;  // handle later
+                        break;
+
+                    default:
+                        throw new AssertionError();
+                }
+
+                fieldWriters[i] = writer;
+                fc += 1;
+            }
+
+            if (!hasPkWriter) {
+                // PRIMARY_KEY was not found.
+                if (duplicatePrimaryKeySourceIndex < 0) {
+                    if (userDefinedPrimaryKeySourceColumnName.isPresent()) {
+                        throw new ConfigException(String.format("time_column '%s' does not exist", userDefinedPrimaryKeySourceColumnName.get()));
+                    } else if (firstTimestampColumnIndex >= 0) {
+                        // if time is not found, use the first timestamp column
+                        duplicatePrimaryKeySourceIndex = firstTimestampColumnIndex;
+                    } else {
+                        throw new ConfigException(String.format("TD output plugin requires at least one timestamp column, or a long column named 'time'"));
+                    }
+                }
+
+                String columnName = schema.getColumnName(duplicatePrimaryKeySourceIndex);
+                Type columnType = schema.getColumnType(duplicatePrimaryKeySourceIndex);
+
+                log.info("Duplicating {}:{} column to 'time' column for the data partitioning",
+                        columnName, columnType);
+
+                FieldWriter writer;
+                if (columnType instanceof LongType) {
+                    writer = new LongFieldDuplicator(columnName, "time");
+                } else if (columnType instanceof TimestampType) {
+                    writer = new TimestampFieldLongDuplicator(task.getJRuby(), columnName, "time");
+                } else {
+                    throw new ConfigException(String.format("Type of '%s' column must be long or timestamp but got %s",
+                            columnName, columnType));
+                }
+
+                // replace existint writer
+                fieldWriters[duplicatePrimaryKeySourceIndex] = writer;
+                fc += 1;
+            }
+
+            fieldCount = fc;
+        }
+
+        private static String newColumnUniqueName(String originalName, Schema schema)
+        {
+            String name = originalName;
+            do {
+                name += "_";
+            } while (containsColumnName(schema, name));
+            return name;
+        }
+
+        private static boolean containsColumnName(Schema schema, String name)
+        {
+            for (Column c : schema.getColumns()) {
+                if (c.getName().equals(name)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public FieldWriter getFieldWriter(int index)
+        {
+            return fieldWriters[index];
+        }
+
+        public int getFieldCount()
+        {
+            return fieldCount;
+        }
+    }
+
+    static abstract class FieldWriter
+    {
+        private final String keyName;
+
+        protected FieldWriter(String keyName)
+        {
+            this.keyName = keyName;
+        }
+
+        public void writeKeyValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            writeKey(builder);
+            if (reader.isNull(column)) {
+                builder.writeNil();
+            } else {
+                writeValue(builder, reader, column);
+            }
+        }
+
+        private void writeKey(MsgpackGZFileBuilder builder)
+                throws IOException
+        {
+            builder.writeString(keyName);
+        }
+
+        protected abstract void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException;
+    }
+
+    static class DoubleFieldWriter
+            extends FieldWriter
+    {
+        public DoubleFieldWriter(String keyName)
+        {
+            super(keyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeDouble(reader.getDouble(column));
+        }
+    }
+
+    static class BooleanFieldWriter
+            extends FieldWriter
+    {
+        public BooleanFieldWriter(String keyName)
+        {
+            super(keyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeBoolean(reader.getBoolean(column));
+        }
+    }
+
+    static class LongFieldWriter
+            extends FieldWriter
+    {
+        LongFieldWriter(String keyName)
+        {
+            super(keyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeLong(reader.getLong(column));
+        }
+    }
+
+    static class StringFieldWriter
+            extends FieldWriter
+    {
+        public StringFieldWriter(String keyName)
+        {
+            super(keyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeString(reader.getString(column));
+        }
+    }
+
+    static class TimestampStringFieldWriter
+            extends FieldWriter
+    {
+        // to format timestamp values to string by "%Y-%m-%d %H:%M:%S.%3N"
+        private final TimestampFormatter defaultFormatter;
+
+        public TimestampStringFieldWriter(ScriptingContainer jruby, String keyName)
+        {
+            super(keyName);
+            this.defaultFormatter = new TimestampFormatter(jruby, "%Y-%m-%d %H:%M:%S.%3N", DateTimeZone.UTC);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeString(defaultFormatter.format(reader.getTimestamp(column)));
+        }
+    }
+
+    static class TimestampLongFieldWriter
+            extends FieldWriter
+    {
+        public TimestampLongFieldWriter(String keyName)
+        {
+            super(keyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            builder.writeLong(reader.getTimestamp(column).getEpochSecond());
+        }
+    }
+
+    static class LongFieldDuplicator
+            extends LongFieldWriter
+    {
+        private final LongFieldWriter timeFieldWriter;
+
+        public LongFieldDuplicator(String keyName, String duplicateKeyName)
+        {
+            super(keyName);
+            timeFieldWriter = new LongFieldWriter(duplicateKeyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            super.writeValue(builder, reader, column);
+            timeFieldWriter.writeKeyValue(builder, reader, column);
+        }
+    }
+
+    static class TimestampFieldLongDuplicator
+            extends TimestampStringFieldWriter
+    {
+        private final TimestampLongFieldWriter timeFieldWriter;
+
+        public TimestampFieldLongDuplicator(ScriptingContainer jruby, String keyName, String longDuplicateKeyName)
+        {
+            super(jruby, keyName);
+            timeFieldWriter = new TimestampLongFieldWriter(longDuplicateKeyName);
+        }
+
+        @Override
+        public void writeValue(MsgpackGZFileBuilder builder, PageReader reader, Column column)
+                throws IOException
+        {
+            super.writeValue(builder, reader, column);
+            timeFieldWriter.writeKeyValue(builder, reader, column);
+        }
+    }
+}