embulk-input-athena 0.1.0

data/src/main/java/org/embulk/input/jdbc/getter/JsonColumnGetter.java

@@ -0,0 +1,57 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.embulk.input.jdbc.getter.AbstractColumnGetter;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.json.JsonParseException;
+import org.embulk.spi.json.JsonParser;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import org.msgpack.value.Value;
+
+public class JsonColumnGetter
+        extends AbstractColumnGetter
+{
+    protected final JsonParser jsonParser = new JsonParser();
+
+    protected String value;
+
+    public JsonColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getString(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.JSON;
+    }
+
+    @Override
+    public void jsonColumn(Column column)
+    {
+        Value v;
+        try {
+            v = jsonParser.parse(value);
+        } catch (JsonParseException e) {
+            super.jsonColumn(column);
+            return;
+        }
+        to.setJson(column, v);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, value);
+    }
+}

data/src/main/java/org/embulk/input/jdbc/getter/LongColumnGetter.java

@@ -0,0 +1,70 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class LongColumnGetter
+        extends AbstractColumnGetter
+{
+    protected long value;
+
+    public LongColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getLong(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.LONG;
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setBoolean(column, value > 0L);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        to.setLong(column, value);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        to.setDouble(column, value);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, Long.toString(value));
+    }
+
+    @Override
+    public JsonNode encodeToJson()
+    {
+        return jsonNodeFactory.numberNode(value);
+    }
+
+    @Override
+    public void decodeFromJsonTo(PreparedStatement toStatement, int toIndex, JsonNode fromValue)
+        throws SQLException
+    {
+        toStatement.setLong(toIndex, fromValue.asLong());
+    }
+}

data/src/main/java/org/embulk/input/jdbc/getter/StringColumnGetter.java

@@ -0,0 +1,96 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.json.JsonParseException;
+import org.embulk.spi.json.JsonParser;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import org.msgpack.value.Value;
+
+public class StringColumnGetter
+        extends AbstractColumnGetter
+{
+    protected final JsonParser jsonParser = new JsonParser();
+
+    protected String value;
+
+    public StringColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getString(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.STRING;
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        long l;
+        try {
+            l = Long.parseLong(value);
+        } catch (NumberFormatException e) {
+            super.longColumn(column);
+            return;
+        }
+        to.setLong(column, l);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        double d;
+        try {
+            d = Double.parseDouble(value);
+        } catch (NumberFormatException e) {
+            super.doubleColumn(column);
+            return;
+        }
+        to.setDouble(column, d);
+    }
+
+    @Override
+    public void jsonColumn(Column column)
+    {
+        Value v;
+        try {
+            v = jsonParser.parse(value);
+        } catch (JsonParseException e) {
+            super.jsonColumn(column);
+            return;
+        }
+        to.setJson(column, v);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, value);
+    }
+
+    @Override
+    public JsonNode encodeToJson()
+    {
+        return jsonNodeFactory.textNode(value);
+    }
+
+    @Override
+    public void decodeFromJsonTo(PreparedStatement toStatement, int toIndex, JsonNode fromValue)
+        throws SQLException
+    {
+        toStatement.setString(toIndex, fromValue.asText());
+    }
+}

data/src/main/java/org/embulk/input/jdbc/getter/TimeColumnGetter.java

@@ -0,0 +1,37 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Time;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class TimeColumnGetter
+        extends AbstractTimestampColumnGetter
+{
+    static final String DEFAULT_FORMAT = "%H:%M:%S";
+
+    public TimeColumnGetter(PageBuilder to, Type toType, TimestampFormatter timestampFormatter)
+    {
+        super(to, toType, timestampFormatter);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        Time time = from.getTime(fromIndex);
+        if (time != null) {
+            value = Timestamp.ofEpochMilli(time.getTime());
+        }
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.TIMESTAMP.withFormat(DEFAULT_FORMAT);
+    }
+
+}

data/src/main/java/org/embulk/input/jdbc/getter/TimestampColumnGetter.java

@@ -0,0 +1,36 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class TimestampColumnGetter
+        extends AbstractTimestampColumnGetter
+{
+    static final String DEFAULT_FORMAT = "%Y-%m-%d %H:%M:%S";
+
+    public TimestampColumnGetter(PageBuilder to, Type toType, TimestampFormatter timestampFormatter)
+    {
+        super(to, toType, timestampFormatter);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        java.sql.Timestamp timestamp = from.getTimestamp(fromIndex);
+        if (timestamp != null) {
+            value = Timestamp.ofEpochSecond(timestamp.getTime() / 1000, timestamp.getNanos());
+        }
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.TIMESTAMP.withFormat(DEFAULT_FORMAT);
+    }
+
+}

data/src/main/java/org/embulk/input/jdbc/getter/TimestampWithTimeZoneIncrementalHandler.java

@@ -0,0 +1,83 @@
+package org.embulk.input.jdbc.getter;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.base.Optional;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.Task;
+import org.embulk.spi.Column;
+import org.embulk.spi.Exec;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.time.TimestampParser;
+
+public class TimestampWithTimeZoneIncrementalHandler
+        extends AbstractIncrementalHandler
+{
+    private static final String ISO_USEC_FORMAT = "%Y-%m-%dT%H:%M:%S.%6NZ";
+    private static final String ISO_USEC_PATTERN = "%Y-%m-%dT%H:%M:%S.%N%z";
+
+    private long epochSecond;
+    private int nano;
+
+    public TimestampWithTimeZoneIncrementalHandler(ColumnGetter next)
+    {
+        super(next);
+    }
+
+    @Override
+    public void getAndSet(ResultSet from, int fromIndex,
+            Column toColumn) throws SQLException
+    {
+        // sniff the value
+        Timestamp timestamp = from.getTimestamp(fromIndex);
+        if (timestamp != null) {
+            epochSecond = timestamp.getTime() / 1000;
+            nano = timestamp.getNanos();
+        }
+
+        super.getAndSet(from, fromIndex, toColumn);
+    }
+
+    private static interface FormatterIntlTask extends Task, TimestampFormatter.Task {}
+    private static interface FormatterIntlColumnOption extends Task, TimestampFormatter.TimestampColumnOption {}
+
+    @Override
+    public JsonNode encodeToJson()
+    {
+        // TODO: Switch to a newer TimestampFormatter constructor after a reasonable interval.
+        // Traditional constructor is used here for compatibility.
+        final ConfigSource configSource = Exec.newConfigSource();
+        configSource.set("format", ISO_USEC_FORMAT);
+        configSource.set("timezone", "UTC");
+        TimestampFormatter formatter = new TimestampFormatter(
+            Exec.newConfigSource().loadConfig(FormatterIntlTask.class),
+            Optional.fromNullable(configSource.loadConfig(FormatterIntlColumnOption.class)));
+        String text = formatter.format(org.embulk.spi.time.Timestamp.ofEpochSecond(epochSecond, nano));
+        return jsonNodeFactory.textNode(text);
+    }
+
+    private static interface ParserIntlTask extends Task, TimestampParser.Task {}
+    private static interface ParserIntlColumnOption extends Task, TimestampParser.TimestampColumnOption {}
+
+    @Override
+    public void decodeFromJsonTo(PreparedStatement toStatement, int toIndex, JsonNode fromValue)
+        throws SQLException
+    {
+        // TODO: Switch to a newer TimestampParser constructor after a reasonable interval.
+        // Traditional constructor is used here for compatibility.
+        final ConfigSource configSource = Exec.newConfigSource();
+        configSource.set("format", ISO_USEC_PATTERN);
+        configSource.set("timezone", "UTC");
+        TimestampParser parser = new TimestampParser(
+            Exec.newConfigSource().loadConfig(ParserIntlTask.class),
+            configSource.loadConfig(ParserIntlColumnOption.class));
+        org.embulk.spi.time.Timestamp epoch = parser.parse(fromValue.asText());
+
+        Timestamp sqlTimestamp = new Timestamp(epoch.getEpochSecond() * 1000);
+        sqlTimestamp.setNanos(epoch.getNano());
+        toStatement.setTimestamp(toIndex, sqlTimestamp);
+    }
+}

data/src/main/java/org/embulk/input/jdbc/getter/TimestampWithoutTimeZoneIncrementalHandler.java

@@ -0,0 +1,75 @@
+package org.embulk.input.jdbc.getter;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.TimeZone;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.embulk.config.ConfigException;
+import org.embulk.spi.Column;
+import static java.util.Locale.ENGLISH;
+
+public class TimestampWithoutTimeZoneIncrementalHandler
+        extends AbstractIncrementalHandler
+{
+    private static final String ISO_USEC_FORMAT = "%d-%02d-%02dT%02d:%02d:%02d.%06d";
+    private static final Pattern ISO_USEC_PATTERN = Pattern.compile("(\\d+)-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}).(\\d{6})");
+
+    private Timestamp dateTime;
+
+    public TimestampWithoutTimeZoneIncrementalHandler(ColumnGetter next)
+    {
+        super(next);
+    }
+
+    @Override
+    public void getAndSet(ResultSet from, int fromIndex,
+            Column toColumn) throws SQLException
+    {
+        // sniff the value
+        Timestamp timestamp = from.getTimestamp(fromIndex);
+        if (timestamp != null) {
+            this.dateTime = timestamp;
+        }
+
+        super.getAndSet(from, fromIndex, toColumn);
+    }
+
+    @Override
+    public JsonNode encodeToJson()
+    {
+        String text = String.format(ENGLISH,
+                ISO_USEC_FORMAT,
+                dateTime.getYear() + 1900,
+                dateTime.getMonth() + 1,
+                dateTime.getDate(),
+                dateTime.getHours(),
+                dateTime.getMinutes(),
+                dateTime.getSeconds(),
+                dateTime.getNanos() / 1000);
+        return jsonNodeFactory.textNode(text);
+    }
+
+    @Override
+    public void decodeFromJsonTo(PreparedStatement toStatement, int toIndex, JsonNode fromValue)
+        throws SQLException
+    {
+        Matcher matcher = ISO_USEC_PATTERN.matcher(fromValue.asText());
+        if (!matcher.matches()) {
+            throw new ConfigException("Invalid timestamp without time zone pattern: " + fromValue);
+        }
+        Timestamp sqlDateTime = new Timestamp(
+                Integer.parseInt(matcher.group(1)) - 1900,  // year
+                Integer.parseInt(matcher.group(2)) - 1,  // month
+                Integer.parseInt(matcher.group(3)),  // day
+                Integer.parseInt(matcher.group(4)),  // hour
+                Integer.parseInt(matcher.group(5)),  // minute
+                Integer.parseInt(matcher.group(6)),  // second
+                Integer.parseInt(matcher.group(7)) * 1000);  // usec -> nsec
+        toStatement.setTimestamp(toIndex, sqlDateTime);
+    }
+}