embulk-input-jdbc 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c8e7bcef7a17ff17d0765398c37a01e30069d1e
-  data.tar.gz: e8da2a078d57ea323a94e4e12228ec38aa9ebff8
+  metadata.gz: 58343b1cbca7d7302990e5ae707abd6093c50a6e
+  data.tar.gz: 1f20480bd02215e50e9e297ab71b8edbf7737f1a
 SHA512:
-  metadata.gz: 31f6a9698536e5bb62c795a43a0a7215e3f6c654c3fdacf3155702903699146187953dee40c60da4cb9358fe6e6b420f53ea94511ef4e099d4bd71defee6a305
-  data.tar.gz: 6e95e49f74ac0d529486b610713d75f8372d619fd4fcc47847a2ea908263c0a1aa593a7fbaf7ddc691d4854d0506405c3d8dc83395d377f99c4e1a071e8debb6
+  metadata.gz: a79c9b92ca7b98df26ad863382a8351266b1acaebfb218429000e47132a081afe692f3ba2f543bbb6a2bf768e2eba756cc4fe510c184eb941858ca04fd9e854f
+  data.tar.gz: cf26a3cbf0ece3949506e6ac9f282eb08c338f39bb9b1cb929b09a2bad9fcaf5d3d08703090dea09a27ebe740cb562382dc55422acf06f9776adfd916abcfb7b

data/src/main/java/org/embulk/input/JdbcInputPlugin.java

@@ -1,6 +1,5 @@
 package org.embulk.input;
 
-import java.nio.file.Paths;
 import java.util.Set;
 import java.util.HashSet;
 import java.util.Properties;
@@ -9,7 +8,6 @@ import java.sql.Driver;
 import java.sql.SQLException;
 import com.google.common.base.Optional;
 import com.google.common.base.Throwables;
-import org.embulk.spi.PluginClassLoader;
 import org.embulk.config.Config;
 import org.embulk.config.ConfigDefault;
 import org.embulk.input.jdbc.AbstractJdbcInputPlugin;
@@ -98,10 +96,4 @@ public class JdbcInputPlugin
         }
     }
 
-    private void loadDriverJar(String glob)
-    {
-        // TODO match glob
-        PluginClassLoader loader = (PluginClassLoader) getClass().getClassLoader();
-        loader.addPath(Paths.get(glob));
-    }
 }

data/src/main/java/org/embulk/input/jdbc/AbstractJdbcInputPlugin.java

@@ -1,13 +1,19 @@
 package org.embulk.input.jdbc;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Properties;
+import java.nio.file.Paths;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+
 import org.slf4j.Logger;
+
 import com.google.common.base.Optional;
+import com.google.common.base.Supplier;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
+
 import org.embulk.config.CommitReport;
 import org.embulk.config.Config;
 import org.embulk.config.ConfigException;
@@ -22,11 +28,13 @@ import org.embulk.spi.Column;
 import org.embulk.spi.PageBuilder;
 import org.embulk.spi.InputPlugin;
 import org.embulk.spi.PageOutput;
+import org.embulk.spi.PluginClassLoader;
 import org.embulk.spi.Schema;
 import org.embulk.spi.Exec;
 import org.embulk.input.jdbc.getter.ColumnGetter;
 import org.embulk.input.jdbc.getter.ColumnGetterFactory;
 import org.embulk.input.jdbc.JdbcInputConnection.BatchSelect;
+import org.joda.time.DateTimeZone;
 
 public abstract class AbstractJdbcInputPlugin
         implements InputPlugin
@@ -97,6 +105,14 @@ public abstract class AbstractJdbcInputPlugin
 
         // TODO parallel execution using "partition_by" config
 
+        @Config("column_options")
+        @ConfigDefault("{}")
+        public Map<String, JdbcColumnOption> getColumnOptions();
+
+        @Config("default_timezone")
+        @ConfigDefault("\"UTC\"")
+        public DateTimeZone getDefaultTimeZone();
+
         public JdbcSchema getQuerySchema();
         public void setQuerySchema(JdbcSchema schema);
 
@@ -112,11 +128,6 @@ public abstract class AbstractJdbcInputPlugin
 
     protected abstract JdbcInputConnection newConnection(PluginTask task) throws SQLException;
 
-    protected ColumnGetterFactory newColumnGetterFactory(PluginTask task) throws SQLException
-    {
-        return new ColumnGetterFactory();
-    }
-
     @Override
     public ConfigDiff transaction(ConfigSource config,
             InputPlugin.Control control)
@@ -143,12 +154,17 @@ public abstract class AbstractJdbcInputPlugin
         JdbcSchema querySchema = con.getSchemaOfQuery(getQuery(task, con));
         task.setQuerySchema(querySchema);
 
-        ColumnGetterFactory factory = newColumnGetterFactory(task);
+        // validate column_options
+        newColumnGetters(task, querySchema, null);
+
+        ColumnGetterFactory factory = new ColumnGetterFactory(null, task.getDefaultTimeZone());
         ImmutableList.Builder<Column> columns = ImmutableList.builder();
         for (int i = 0; i < querySchema.getCount(); i++) {
+            JdbcColumn column = querySchema.getColumn(i);
+            JdbcColumnOption columnOption = columnOptionOf(task.getColumnOptions(), column);
             columns.add(new Column(i,
-                    querySchema.getColumnName(i),
-                    factory.newColumnGetter(querySchema.getColumn(i)).getToType()));
+                    column.getName(),
+                    factory.newColumnGetter(column, columnOption).getToType()));
         }
         return new Schema(columns.build());
     }
@@ -220,7 +236,7 @@ public abstract class AbstractJdbcInputPlugin
         PageBuilder pageBuilder = new PageBuilder(allocator, schema, output);
 
         try {
-            List<ColumnGetter> getters = newColumnGetters(task, querySchema);
+            List<ColumnGetter> getters = newColumnGetters(task, querySchema, pageBuilder);
 
             try (JdbcInputConnection con = newConnection(task)) {
                 try (BatchSelect cursor = con.newSelectCursor(getQuery(task, con), task.getFetchRows())) {
@@ -248,16 +264,31 @@ public abstract class AbstractJdbcInputPlugin
         return report;
     }
 
-    private List<ColumnGetter> newColumnGetters(PluginTask task, JdbcSchema querySchema) throws SQLException
+    private List<ColumnGetter> newColumnGetters(PluginTask task, JdbcSchema querySchema, PageBuilder pageBuilder)
+            throws SQLException
     {
-        ColumnGetterFactory factory = newColumnGetterFactory(task);
+        ColumnGetterFactory factory = new ColumnGetterFactory(pageBuilder, task.getDefaultTimeZone());
         ImmutableList.Builder<ColumnGetter> getters = ImmutableList.builder();
         for (JdbcColumn c : querySchema.getColumns()) {
-            getters.add(factory.newColumnGetter(c));
+            JdbcColumnOption columnOption = columnOptionOf(task.getColumnOptions(), c);
+            getters.add(factory.newColumnGetter(c, columnOption));
         }
         return getters.build();
     }
 
+    private static JdbcColumnOption columnOptionOf(Map<String, JdbcColumnOption> columnOptions, JdbcColumn targetColumn)
+    {
+        return Optional.fromNullable(columnOptions.get(targetColumn.getName())).or(
+                    // default column option
+                    new Supplier<JdbcColumnOption>()
+                    {
+                        public JdbcColumnOption get()
+                        {
+                            return Exec.newConfigSource().loadConfig(JdbcColumnOption.class);
+                        }
+                    });
+    }
+
     private boolean fetch(BatchSelect cursor,
             List<ColumnGetter> getters, PageBuilder pageBuilder) throws SQLException
     {
@@ -272,7 +303,7 @@ public abstract class AbstractJdbcInputPlugin
         do {
             for (int i=0; i < getters.size(); i++) {
                 int index = i + 1;  // JDBC column index begins from 1
-                getters.get(i).getAndSet(result, index, pageBuilder, columns.get(i));
+                getters.get(i).getAndSet(result, index, columns.get(i));
             }
             pageBuilder.addRecord();
             rows++;
@@ -320,4 +351,11 @@ public abstract class AbstractJdbcInputPlugin
     //        pages = ImmutableList.builder();
     //    }
     //}
+
+    protected void loadDriverJar(String glob)
+    {
+        // TODO match glob
+        PluginClassLoader loader = (PluginClassLoader) getClass().getClassLoader();
+        loader.addPath(Paths.get(glob));
+    }
 }

data/src/main/java/org/embulk/input/jdbc/JdbcColumn.java

@@ -9,16 +9,22 @@ public class JdbcColumn
     private String name;
     private String typeName;
     private int sqlType;
+    private int precision;
+    private int scale;
 
     @JsonCreator
     public JdbcColumn(
             @JsonProperty("name") String name,
             @JsonProperty("typeName") String typeName,
-            @JsonProperty("sqlType") int sqlType)
+            @JsonProperty("sqlType") int sqlType,
+            @JsonProperty("precision") int precision,
+            @JsonProperty("scale") int scale)
     {
         this.name = name;
         this.typeName = typeName;
         this.sqlType = sqlType;
+        this.precision = precision;
+        this.scale = scale;
     }
 
     @JsonProperty("name")
@@ -38,4 +44,17 @@ public class JdbcColumn
     {
         return sqlType;
     }
+
+
+    @JsonProperty("precision")
+    public int getPrecision()
+    {
+        return precision;
+    }
+
+    @JsonProperty("scale")
+    public int getScale()
+    {
+        return scale;
+    }
 }

data/src/main/java/org/embulk/input/jdbc/JdbcColumnOption.java

@@ -0,0 +1,36 @@
+package org.embulk.input.jdbc;
+
+import org.embulk.config.Config;
+import org.embulk.config.ConfigDefault;
+import org.embulk.config.ConfigInject;
+import org.embulk.config.Task;
+import org.embulk.spi.time.TimestampFormat;
+import org.embulk.spi.type.Type;
+import org.joda.time.DateTimeZone;
+import org.jruby.embed.ScriptingContainer;
+
+import com.google.common.base.Optional;
+
+public interface JdbcColumnOption
+        extends Task
+{
+    @Config("value_type")
+    @ConfigDefault("\"coalesce\"")
+    public String getValueType();
+
+    @Config("type")
+    @ConfigDefault("null")
+    public Optional<Type> getType();
+
+    @Config("timestamp_format")
+    @ConfigDefault("null")
+    public Optional<TimestampFormat> getTimestampFormat();
+
+    @Config("timezone")
+    @ConfigDefault("null")
+    public Optional<DateTimeZone> getTimeZone();
+
+    // required by TimestampFormatter
+    @ConfigInject
+    public ScriptingContainer getJRuby();
+}

data/src/main/java/org/embulk/input/jdbc/JdbcInputConnection.java

@@ -56,12 +56,12 @@ public class JdbcInputConnection
         ImmutableList.Builder<JdbcColumn> columns = ImmutableList.builder();
         for (int i=0; i < metadata.getColumnCount(); i++) {
             int index = i + 1;  // JDBC column index begins from 1
-            String name = metadata.getColumnName(index);
+            String name = metadata.getColumnLabel(index);
             String typeName = metadata.getColumnTypeName(index);
             int sqlType = metadata.getColumnType(index);
-            //String scale = metadata.getScale(index)
-            //String precision = metadata.getPrecision(index)
-            columns.add(new JdbcColumn(name, typeName, sqlType));
+            int scale = metadata.getScale(index);
+            int precision = metadata.getPrecision(index);
+            columns.add(new JdbcColumn(name, typeName, sqlType, precision, scale));
         }
         return new JdbcSchema(columns.build());
     }

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

@@ -0,0 +1,76 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.ColumnVisitor;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+
+public abstract class AbstractColumnGetter implements ColumnGetter, ColumnVisitor
+{
+    protected final PageBuilder to;
+    private final Type toType;
+
+    public AbstractColumnGetter(PageBuilder to, Type toType)
+    {
+        this.to = to;
+        this.toType = toType;
+    }
+
+    @Override
+    public void getAndSet(ResultSet from, int fromIndex,
+            Column toColumn) throws SQLException {
+
+        fetch(from, fromIndex);
+        if (from.wasNull()) {
+            to.setNull(toColumn);
+        } else {
+            toColumn.visit(this);
+        }
+    }
+
+    protected abstract void fetch(ResultSet from, int fromIndex) throws SQLException;
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setNull(column);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        to.setNull(column);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        to.setNull(column);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setNull(column);
+    }
+
+    @Override
+    public void timestampColumn(Column column)
+    {
+        to.setNull(column);
+    }
+
+    @Override
+    public Type getToType()
+    {
+        if (toType == null) {
+            return getDefaultToType();
+        }
+        return toType;
+    }
+
+    protected abstract Type getDefaultToType();
+
+}

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

@@ -0,0 +1,33 @@
+package org.embulk.input.jdbc.getter;
+
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.type.Type;
+
+public abstract class AbstractTimestampColumnGetter
+        extends AbstractColumnGetter
+{
+    private final TimestampFormatter timestampFormatter;
+    protected Timestamp value;
+
+    public AbstractTimestampColumnGetter(PageBuilder to, Type toType, TimestampFormatter timestampFormatter)
+    {
+        super(to, toType);
+
+        this.timestampFormatter = timestampFormatter;
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, timestampFormatter.format(value));
+    }
+
+    @Override
+    public void timestampColumn(Column column)
+    {
+        to.setTimestamp(column, value);
+    }
+}

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

@@ -0,0 +1,59 @@
+package org.embulk.input.jdbc.getter;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class BigDecimalColumnGetter
+        extends AbstractColumnGetter
+{
+    private BigDecimal value;
+
+    public BigDecimalColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getBigDecimal(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.DOUBLE;
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setBoolean(column, value.signum() > 0);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        to.setLong(column, value.longValue());
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        // rounded value could be Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY.
+        double rounded = value.doubleValue();
+        to.setDouble(column, rounded);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, value.toPlainString());
+    }
+
+}

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

@@ -0,0 +1,56 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class BooleanColumnGetter
+        extends AbstractColumnGetter
+{
+    private boolean value;
+
+    public BooleanColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getBoolean(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.BOOLEAN;
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setBoolean(column, value);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        to.setLong(column, value ? 1L : 0L);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        to.setDouble(column, value ? 1.0 : 0.0);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, Boolean.toString(value));
+    }
+
+}

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

@@ -3,13 +3,12 @@ package org.embulk.input.jdbc.getter;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import org.embulk.spi.Column;
-import org.embulk.spi.PageBuilder;
 import org.embulk.spi.type.Type;
 
 public interface ColumnGetter
 {
     public void getAndSet(ResultSet from, int fromIndex,
-            PageBuilder to, Column toColumn) throws SQLException;
+            Column toColumn) throws SQLException;
 
     public Type getToType();
 }

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

@@ -1,38 +1,84 @@
 package org.embulk.input.jdbc.getter;
 
 import java.sql.Types;
+
+import org.embulk.config.ConfigException;
 import org.embulk.input.jdbc.JdbcColumn;
-import org.embulk.input.jdbc.getter.ColumnGetters.BooleanColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.LongColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.DoubleColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.StringColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.DateColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.TimeColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.TimestampColumnGetter;
-import org.embulk.input.jdbc.getter.ColumnGetters.BigDecimalToDoubleColumnGetter;
+import org.embulk.input.jdbc.JdbcColumnOption;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.time.TimestampFormatter;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.Type;
+import org.joda.time.DateTimeZone;
 
 public class ColumnGetterFactory
 {
-    public ColumnGetter newColumnGetter(JdbcColumn column)
+    private final PageBuilder to;
+    private final DateTimeZone defaultTimeZone;
+
+    public ColumnGetterFactory(PageBuilder to, DateTimeZone defaultTimeZone)
+    {
+        this.to = to;
+        this.defaultTimeZone = defaultTimeZone;
+    }
+
+    public ColumnGetter newColumnGetter(JdbcColumn column, JdbcColumnOption option)
+    {
+        return newColumnGetter(column, option, option.getValueType());
+    }
+
+    private ColumnGetter newColumnGetter(JdbcColumn column, JdbcColumnOption option, String valueType)
+    {
+        Type toType = getToType(option);
+        switch(valueType) {
+        case "coalesce":
+            return newColumnGetter(column, option, sqlTypeToValueType(column, column.getSqlType()));
+        case "long":
+            return new LongColumnGetter(to, toType);
+        case "float":
+            return new FloatColumnGetter(to, toType);
+        case "double":
+            return new DoubleColumnGetter(to, toType);
+        case "boolean":
+            return new BooleanColumnGetter(to, toType);
+        case "string":
+            return new StringColumnGetter(to, toType);
+        case "date":
+            return new DateColumnGetter(to, toType, newTimestampFormatter(option, DateColumnGetter.DEFAULT_FORMAT));
+        case "time":
+            return new TimeColumnGetter(to, toType, newTimestampFormatter(option, DateColumnGetter.DEFAULT_FORMAT));
+        case "timestamp":
+            return new TimestampColumnGetter(to, toType, newTimestampFormatter(option, DateColumnGetter.DEFAULT_FORMAT));
+        case "decimal":
+            return new BigDecimalColumnGetter(to, toType);
+        default:
+            throw new ConfigException(String.format("Unknown value_type '%s' for column '%s'", option.getValueType(), column.getName()));
+        }
+    }
+
+    private String sqlTypeToValueType(JdbcColumn column, int sqlType)
     {
-        switch(column.getSqlType()) {
+        switch(sqlType) {
         // getLong
         case Types.TINYINT:
         case Types.SMALLINT:
         case Types.INTEGER:
         case Types.BIGINT:
-            return new LongColumnGetter();
+            return "long";
 
-        // getDouble
-        case Types.DOUBLE:
+        // getFloat
         case Types.FLOAT:
         case Types.REAL:
-            return new DoubleColumnGetter();
+            return "float";
+
+        // getDouble
+        case Types.DOUBLE:
+            return "double";
 
         // getBool
         case Types.BOOLEAN:
         case Types.BIT:  // JDBC BIT is boolean, unlike SQL-92
-            return new BooleanColumnGetter();
+            return "boolean";
 
         // getString, Clob
         case Types.CHAR:
@@ -42,7 +88,7 @@ public class ColumnGetterFactory
         case Types.NCHAR:
         case Types.NVARCHAR:
         case Types.LONGNVARCHAR:
-            return new StringColumnGetter();
+            return "string";
 
         // TODO
         //// getBytes Blob
@@ -54,15 +100,15 @@ public class ColumnGetterFactory
 
         // getDate
         case Types.DATE:
-            return new DateColumnGetter(); // TODO
+            return "date";
 
         // getTime
         case Types.TIME:
-            return new TimeColumnGetter(); // TODO
+            return "time";
 
         // getTimestamp
         case Types.TIMESTAMP:
-            return new TimestampColumnGetter();
+            return "timestamp";
 
         // TODO
         //// Null
@@ -72,7 +118,7 @@ public class ColumnGetterFactory
         // getBigDecimal
         case Types.NUMERIC:
         case Types.DECIMAL:
-            return new BigDecimalToDoubleColumnGetter();
+            return "decimal";
 
         // others
         case Types.ARRAY:  // array
@@ -89,6 +135,26 @@ public class ColumnGetterFactory
         }
     }
 
+    private Type getToType(JdbcColumnOption option)
+    {
+        if (!option.getType().isPresent()) {
+            return null;
+        }
+        Type toType = option.getType().get();
+        if (toType instanceof TimestampType && option.getTimestampFormat().isPresent()) {
+            toType = ((TimestampType)toType).withFormat(option.getTimestampFormat().get().getFormat());
+        }
+        return toType;
+    }
+
+    private TimestampFormatter newTimestampFormatter(JdbcColumnOption option, String defaultTimestampFormat)
+    {
+        return new TimestampFormatter(
+                option.getJRuby(),
+                option.getTimestampFormat().isPresent() ? option.getTimestampFormat().get().getFormat() : defaultTimestampFormat,
+                option.getTimeZone().or(defaultTimeZone));
+    }
+
     private static UnsupportedOperationException unsupportedOperationException(JdbcColumn column)
     {
         throw new UnsupportedOperationException(

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

@@ -0,0 +1,37 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.Date;
+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 DateColumnGetter
+        extends AbstractTimestampColumnGetter
+{
+    static final String DEFAULT_FORMAT = "%Y-%m-%d";
+
+    public DateColumnGetter(PageBuilder to, Type toType, TimestampFormatter timestampFormatter)
+    {
+        super(to, toType, timestampFormatter);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        Date date = from.getDate(fromIndex);
+        if (date != null) {
+            value = Timestamp.ofEpochMilli(date.getTime());
+        }
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.TIMESTAMP.withFormat(DEFAULT_FORMAT);
+    }
+
+}

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

@@ -0,0 +1,66 @@
+package org.embulk.input.jdbc.getter;
+
+import java.math.RoundingMode;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import com.google.common.math.DoubleMath;
+
+public class DoubleColumnGetter
+        extends AbstractColumnGetter
+{
+    private double value;
+
+    public DoubleColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getDouble(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.DOUBLE;
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setBoolean(column, value > 0.0);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        long l;
+        try {
+            // TODO configurable rounding mode
+            l = DoubleMath.roundToLong(value, RoundingMode.HALF_UP);
+        } catch (ArithmeticException e) {
+            // NaN / Infinite / -Infinite
+            super.longColumn(column);
+            return;
+        }
+        to.setLong(column, l);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        to.setDouble(column, value);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, Double.toString(value));
+    }
+}

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

@@ -0,0 +1,66 @@
+package org.embulk.input.jdbc.getter;
+
+import java.math.RoundingMode;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+import com.google.common.math.DoubleMath;
+
+public class FloatColumnGetter
+        extends AbstractColumnGetter
+{
+    private float value;
+
+    public FloatColumnGetter(PageBuilder to, Type toType)
+    {
+        super(to, toType);
+    }
+
+    @Override
+    protected void fetch(ResultSet from, int fromIndex) throws SQLException
+    {
+        value = from.getFloat(fromIndex);
+    }
+
+    @Override
+    protected Type getDefaultToType()
+    {
+        return Types.DOUBLE;
+    }
+
+    @Override
+    public void booleanColumn(Column column)
+    {
+        to.setBoolean(column, value > 0.0);
+    }
+
+    @Override
+    public void longColumn(Column column)
+    {
+        long l;
+        try {
+            // TODO configurable rounding mode
+            l = DoubleMath.roundToLong(value, RoundingMode.HALF_UP);
+        } catch (ArithmeticException e) {
+            // NaN / Infinite / -Infinite
+            super.longColumn(column);
+            return;
+        }
+        to.setLong(column, l);
+    }
+
+    @Override
+    public void doubleColumn(Column column)
+    {
+        to.setDouble(column, value);
+    }
+
+    @Override
+    public void stringColumn(Column column)
+    {
+        to.setString(column, Float.toString(value));
+    }
+}

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

@@ -0,0 +1,56 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+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
+{
+    private 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));
+    }
+
+}

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

@@ -0,0 +1,64 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.type.Type;
+import org.embulk.spi.type.Types;
+
+public class StringColumnGetter
+        extends AbstractColumnGetter
+{
+    private 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 stringColumn(Column column)
+    {
+        to.setString(column, value);
+    }
+
+}

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embulk-input-jdbc
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-06-17 00:00:00.000000000 Z
 dependencies: []
 description: Selects records from a table.
 email:
@@ -22,12 +22,23 @@ files:
 - src/main/java/org/embulk/input/JdbcInputPlugin.java
 - src/main/java/org/embulk/input/jdbc/AbstractJdbcInputPlugin.java
 - src/main/java/org/embulk/input/jdbc/JdbcColumn.java
+- src/main/java/org/embulk/input/jdbc/JdbcColumnOption.java
 - src/main/java/org/embulk/input/jdbc/JdbcInputConnection.java
 - src/main/java/org/embulk/input/jdbc/JdbcSchema.java
+- src/main/java/org/embulk/input/jdbc/getter/AbstractColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/AbstractTimestampColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/BigDecimalColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/BooleanColumnGetter.java
 - src/main/java/org/embulk/input/jdbc/getter/ColumnGetter.java
 - src/main/java/org/embulk/input/jdbc/getter/ColumnGetterFactory.java
-- src/main/java/org/embulk/input/jdbc/getter/ColumnGetters.java
-- classpath/embulk-input-jdbc-0.4.0.jar
+- src/main/java/org/embulk/input/jdbc/getter/DateColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/DoubleColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/FloatColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/LongColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/StringColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/TimeColumnGetter.java
+- src/main/java/org/embulk/input/jdbc/getter/TimestampColumnGetter.java
+- classpath/embulk-input-jdbc-0.5.0.jar
 homepage: https://github.com/embulk/embulk-input-jdbc
 licenses:
 - Apache 2.0

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

@@ -1,197 +0,0 @@
-package org.embulk.input.jdbc.getter;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.math.BigDecimal;
-import org.embulk.spi.Column;
-import org.embulk.spi.PageBuilder;
-import org.embulk.spi.Column;
-import org.embulk.spi.time.Timestamp;
-import org.embulk.spi.type.Type;
-import org.embulk.spi.type.Types;
-
-public class ColumnGetters
-{
-    private ColumnGetters() { }
-
-    public static class BooleanColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            boolean v = from.getBoolean(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                to.setBoolean(toColumn, v);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.BOOLEAN;
-        }
-    }
-
-    public static class LongColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            long v = from.getLong(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                to.setLong(toColumn, v);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.LONG;
-        }
-    }
-
-    public static class DoubleColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            double v = from.getDouble(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                to.setDouble(toColumn, v);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.DOUBLE;
-        }
-    }
-
-    public static class StringColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            String v = from.getString(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                to.setString(toColumn, v);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.STRING;
-        }
-    }
-
-    public static class DateColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            java.sql.Date v = from.getDate(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                Timestamp t = Timestamp.ofEpochMilli(v.getTime());
-                to.setTimestamp(toColumn, t);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.TIMESTAMP.withFormat("%Y-%m-%d");
-        }
-    }
-
-    public static class TimeColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            java.sql.Time v = from.getTime(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                Timestamp t = Timestamp.ofEpochMilli(v.getTime());
-                to.setTimestamp(toColumn, t);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.TIMESTAMP.withFormat("%H:%M:%S");
-        }
-    }
-
-    public static class TimestampColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            java.sql.Timestamp v = from.getTimestamp(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                Timestamp t = Timestamp.ofEpochSecond(v.getTime() / 1000, v.getNanos());
-                to.setTimestamp(toColumn, t);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.TIMESTAMP.withFormat("%Y-%m-%d %H:%M:%S");
-        }
-    }
-
-    public static class BigDecimalToDoubleColumnGetter
-            implements ColumnGetter
-    {
-        @Override
-        public void getAndSet(ResultSet from, int fromIndex,
-                PageBuilder to, Column toColumn) throws SQLException
-        {
-            BigDecimal v = from.getBigDecimal(fromIndex);
-            if (from.wasNull()) {
-                to.setNull(toColumn);
-            } else {
-                // rounded value could be Double.NEGATIVE_INFINITY or Double.POSITIVE_INFINITY.
-                double rounded = v.doubleValue();
-                to.setDouble(toColumn, rounded);
-            }
-        }
-
-        @Override
-        public Type getToType()
-        {
-            return Types.DOUBLE;
-        }
-    }
-}