embulk-input-jdbc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 266e103762b852c24503fb2a83616a78bd07a235
+  data.tar.gz: 01314fad5353c44cdf63c3cf59c5ae1f029c7c2f
+SHA512:
+  metadata.gz: 3004de01d140d8920f8be786fc2e58f14bf3b9ddff09f1a9e59b5ebe4c8f4a5db582af57431193e9427b664de3c9fe660d78cea1de2fea66c8579ddd0c882c59
+  data.tar.gz: 30b3caa6cc8ac3a25f520d2386bb3134be88678d3a3287197fae630acaee6163e8ab84618e4d56341bd03428537122bec231b58d4c019e46022da1e20e2851be

data/build.gradle

@@ -0,0 +1,2 @@
+dependencies {
+}

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

@@ -0,0 +1,70 @@
+package org.embulk.input;
+
+import java.util.Properties;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.SQLException;
+import com.google.common.base.Throwables;
+import org.embulk.config.Config;
+import org.embulk.input.jdbc.AbstractJdbcInputPlugin;
+import org.embulk.input.jdbc.JdbcInputConnection;
+
+public class JdbcInputPlugin
+        extends AbstractJdbcInputPlugin
+{
+    public interface GenericPluginTask extends PluginTask
+    {
+        @Config("driver_name")
+        public String getDriverName();
+
+        @Config("driver_class")
+        public String getDriverClass();
+    }
+
+    @Override
+    protected Class<? extends PluginTask> getTaskClass()
+    {
+        return GenericPluginTask.class;
+    }
+
+    @Override
+    protected JdbcInputConnection newConnection(PluginTask task) throws SQLException
+    {
+        GenericPluginTask g = (GenericPluginTask) task;
+
+        String url;
+        if (g.getPort().isPresent()) {
+            url = String.format("jdbc:%s://%s:%d/%s",
+                    g.getDriverName(), g.getHost(), g.getPort().get(), g.getDatabase());
+        } else {
+            url = String.format("jdbc:%s://%s:%d/%s",
+                    g.getDriverName(), g.getHost(), g.getDatabase());
+        }
+
+        Properties props = new Properties();
+        props.setProperty("user", g.getUser());
+        props.setProperty("password", g.getPassword());
+
+        props.putAll(g.getOptions());
+
+        Driver driver;
+        try {
+            // TODO check Class.forName(driverClass) is a Driver before newInstance
+            //      for security
+            driver = (Driver) Class.forName(g.getDriverClass()).newInstance();
+        } catch (Exception ex) {
+            throw Throwables.propagate(ex);
+        }
+
+        Connection con = driver.connect(url, props);
+        try {
+            JdbcInputConnection c = new JdbcInputConnection(con, g.getSchema().orNull());
+            con = null;
+            return c;
+        } finally {
+            if (con != null) {
+                con.close();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,315 @@
+package org.embulk.input.jdbc;
+
+import java.util.List;
+import java.util.Properties;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import com.google.common.base.Optional;
+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.ConfigDefault;
+import org.embulk.config.ConfigDiff;
+import org.embulk.config.ConfigInject;
+import org.embulk.config.ConfigSource;
+import org.embulk.config.Task;
+import org.embulk.config.TaskSource;
+import org.embulk.spi.BufferAllocator;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageBuilder;
+import org.embulk.spi.InputPlugin;
+import org.embulk.spi.PageOutput;
+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;
+
+public abstract class AbstractJdbcInputPlugin
+        implements InputPlugin
+{
+    public interface PluginTask extends Task
+    {
+        @Config("host")
+        public String getHost();
+
+        @Config("port")
+        @ConfigDefault("null")
+        public Optional<Integer> getPort();
+
+        @Config("user")
+        public String getUser();
+
+        @Config("password")
+        @ConfigDefault("\"\"")
+        public String getPassword();
+
+        @Config("options")
+        @ConfigDefault("{}")
+        public Properties getOptions();
+
+        @Config("database")
+        public String getDatabase();
+
+        @Config("schema")
+        @ConfigDefault("null")
+        public Optional<String> getSchema();
+
+        @Config("table")
+        public String getTable();
+
+        @Config("select")
+        @ConfigDefault("null")
+        public Optional<String> getSelect();
+
+        @Config("where")
+        @ConfigDefault("null")
+        public Optional<String> getWhere();
+
+        @Config("order_by")
+        @ConfigDefault("null")
+        public Optional<String> getOrderBy();
+
+        //// TODO See bellow.
+        //@Config("last_value")
+        //@ConfigDefault("null")
+        //public Optional<String> getLastValue();
+
+        // TODO limit_value is necessary to make sure repeated bulk load transactions
+        //      don't a same record twice or miss records when the column
+        //      specified at order_by parameter is not unique.
+        //      For example, if the order_by column is "timestamp created_at"
+        //      column whose precision is second, the table can include multiple
+        //      records with the same created_at time. At the first bulk load
+        //      transaction, it loads a record with created_at=2015-01-02 00:00:02.
+        //      Then next transaction will use WHERE created_at > '2015-01-02 00:00:02'.
+        //      However, if another record with created_at=2014-01-01 23:59:59 is
+        //      inserted between the 2 transactions, the new record will be skipped.
+        //      To prevent this scenario, we want to specify
+        //      limit_value=2015-01-02 00:00:00 (exclusive). With this way, as long as
+        //      a transaction runs after 2015-01-02 00:00:00 + some minutes, we don't
+        //      skip records. Ideally, to automate the scheduling, we want to set
+        //      limit_value="today".
+        //
+        //@Config("limit_value")
+        //@ConfigDefault("null")
+        //public Optional<String> getLimitValue();
+
+        //// TODO probably limit_rows is unnecessary as long as this has
+        //        supports parallel execution (partition_by option) and resuming.
+        //@Config("limit_rows")
+        //@ConfigDefault("null")
+        //public Optional<Integer> getLimitRows();
+
+        @Config("fetch_rows")
+        @ConfigDefault("10000")
+        // TODO set minimum number
+        public int getFetchRows();
+
+        // TODO parallel execution using "partition_by" config
+
+        public JdbcSchema getQuerySchema();
+        public void setQuerySchema(JdbcSchema schema);
+
+        @ConfigInject
+        public BufferAllocator getBufferAllocator();
+    }
+
+    // for subclasses to add @Config
+    protected Class<? extends PluginTask> getTaskClass()
+    {
+        return PluginTask.class;
+    }
+
+    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)
+    {
+        PluginTask task = config.loadConfig(getTaskClass());
+
+        //if (task.getLastValue().isPresent() && !task.getOrderBy().isPresent()) {
+        //    throw new ConfigException("order_by parameter must be set if last_value parameter is set");
+        //}
+
+        Schema schema;
+        try (JdbcInputConnection con = newConnection(task)) {
+            schema = setupTask(con, task);
+        } catch (SQLException ex) {
+            throw Throwables.propagate(ex);
+        }
+        System.out.println("schema: "+schema);
+
+        return buildNextConfigDiff(task, control.run(task.dump(), schema, 1));
+    }
+
+    private Schema setupTask(JdbcInputConnection con, PluginTask task) throws SQLException
+    {
+        // build SELECT query and gets schema of its result
+        JdbcSchema querySchema = con.getSchemaOfQuery(task.getTable(), task.getSelect(), task.getWhere(), task.getOrderBy());
+        task.setQuerySchema(querySchema);
+
+        ColumnGetterFactory factory = newColumnGetterFactory(task);
+        ImmutableList.Builder<Column> columns = ImmutableList.builder();
+        for (int i = 0; i < querySchema.getCount(); i++) {
+            columns.add(new Column(i,
+                    querySchema.getColumnName(i),
+                    factory.newColumnGetter(querySchema.getColumn(i)).getToType()));
+        }
+        return new Schema(columns.build());
+    }
+
+    @Override
+    public ConfigDiff resume(TaskSource taskSource,
+            Schema schema, int processorCount,
+            InputPlugin.Control control)
+    {
+        PluginTask task = taskSource.loadTask(getTaskClass());
+
+        // TODO when parallel execution is implemented and enabled, (maybe) order_by
+        //      is necessary to resume. transaction() gets the range of order_by
+        //      colum and set it to WHERE condition to make the operation deterministic
+
+        return buildNextConfigDiff(task, control.run(taskSource, schema, processorCount));
+    }
+
+    protected ConfigDiff buildNextConfigDiff(PluginTask task, List<CommitReport> reports)
+    {
+        ConfigDiff next = Exec.newConfigDiff();
+        // TODO
+        //if (task.getOrderBy().isPresent()) {
+        //    // TODO when parallel execution is implemented, calculate the max last_value
+        //    //      from the all commit reports.
+        //    next.set("last_value", reports.get(0).get(JsonNode.class, "last_value"));
+        //}
+        return next;
+    }
+
+    @Override
+    public void cleanup(TaskSource taskSource,
+            Schema schema, int processorCount,
+            List<CommitReport> successCommitReports)
+    {
+        // do nothing
+    }
+
+    @Override
+    public CommitReport run(TaskSource taskSource,
+            Schema schema, int processorIndex,
+            PageOutput output)
+    {
+        PluginTask task = taskSource.loadTask(getTaskClass());
+
+        JdbcSchema querySchema = task.getQuerySchema();
+        BufferAllocator allocator = task.getBufferAllocator();
+        PageBuilder pageBuilder = new PageBuilder(allocator, schema, output);
+
+        try {
+            List<ColumnGetter> getters = newColumnGetters(task, querySchema);
+
+            try (JdbcInputConnection con = newConnection(task)) {
+                try (BatchSelect cursor = con.newSelectCursor(
+                            task.getTable(), task.getSelect(), task.getWhere(),
+                            task.getOrderBy(), task.getFetchRows())) {
+                    while (true) {
+                        // TODO run fetch() in another thread asynchronously
+                        // TODO retry fetch() if it failed (maybe order_by is required and unique_column(s) option is also required)
+                        System.out.println("fetch....");
+                        boolean cont = fetch(cursor, getters, pageBuilder);
+                        if (!cont) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+        } catch (SQLException ex) {
+            throw Throwables.propagate(ex);
+        }
+        pageBuilder.finish();
+
+        CommitReport report = Exec.newCommitReport();
+        // TODO
+        //if (orderByColumn != null) {
+        //    report.set("last_value", lastValue);
+        //}
+        return report;
+    }
+
+    private List<ColumnGetter> newColumnGetters(PluginTask task, JdbcSchema querySchema) throws SQLException
+    {
+        ColumnGetterFactory factory = newColumnGetterFactory(task);
+        ImmutableList.Builder<ColumnGetter> getters = ImmutableList.builder();
+        for (JdbcColumn c : querySchema.getColumns()) {
+            getters.add(factory.newColumnGetter(c));
+        }
+        return getters.build();
+    }
+
+    private boolean fetch(BatchSelect cursor,
+            List<ColumnGetter> getters, PageBuilder pageBuilder) throws SQLException
+    {
+        ResultSet result = cursor.fetch();
+        if (result == null || !result.next()) {
+            return false;
+        }
+
+        System.out.println("res: "+result);
+
+        List<Column> columns = pageBuilder.getSchema().getColumns();
+        do {
+            System.out.println("record.");
+            for (int i=0; i < getters.size(); i++) {
+                int index = i + 1;  // JDBC column index begins from 1
+                System.out.println("getters "+i+" "+getters.get(i));
+                getters.get(i).getAndSet(result, index, pageBuilder, columns.get(i));
+            }
+            pageBuilder.addRecord();
+        } while (result.next());
+        return true;
+    }
+
+    //// TODO move to embulk.spi.util?
+    //private static class ListPageOutput
+    //{
+    //    public ImmutableList.Builder<Page> pages;
+    //
+    //    public ListPageOutput()
+    //    {
+    //        reset();
+    //    }
+    //
+    //    @Override
+    //    public void add(Page page)
+    //    {
+    //        pages.add(page);
+    //    }
+    //
+    //    @Override
+    //    public void finish()
+    //    {
+    //    }
+    //
+    //    @Override
+    //    public void close()
+    //    {
+    //    }
+    //
+    //    public List<Page> getPages()
+    //    {
+    //        return pages.build();
+    //    }
+    //
+    //    public void reset()
+    //    {
+    //        pages = ImmutableList.builder();
+    //    }
+    //}
+}

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

@@ -0,0 +1,41 @@
+package org.embulk.input.jdbc;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+public class JdbcColumn
+{
+    private String name;
+    private String typeName;
+    private int sqlType;
+
+    @JsonCreator
+    public JdbcColumn(
+            @JsonProperty("name") String name,
+            @JsonProperty("typeName") String typeName,
+            @JsonProperty("sqlType") int sqlType)
+    {
+        this.name = name;
+        this.typeName = typeName;
+        this.sqlType = sqlType;
+    }
+
+    @JsonProperty("name")
+    public String getName()
+    {
+        return name;
+    }
+
+    @JsonProperty("typeName")
+    public String getTypeName()
+    {
+        return typeName;
+    }
+
+    @JsonProperty("sqlType")
+    public int getSqlType()
+    {
+        return sqlType;
+    }
+}

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

@@ -0,0 +1,171 @@
+package org.embulk.input.jdbc;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.SQLException;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import org.slf4j.Logger;
+import org.embulk.spi.Exec;
+
+public class JdbcInputConnection
+        implements AutoCloseable
+{
+    private final Logger logger = Exec.getLogger(JdbcInputConnection.class);
+    protected final Connection connection;
+    protected final String schemaName;
+    protected final DatabaseMetaData databaseMetaData;
+    protected String identifierQuoteString;
+
+    public JdbcInputConnection(Connection connection, String schemaName)
+            throws SQLException
+    {
+        this.connection = connection;
+        this.schemaName = schemaName;
+        this.databaseMetaData = connection.getMetaData();
+        this.identifierQuoteString = databaseMetaData.getIdentifierQuoteString();
+        if (schemaName != null) {
+            setSearchPath(schemaName);
+        }
+        connection.setAutoCommit(false);
+    }
+
+    protected void setSearchPath(String schema) throws SQLException
+    {
+        String sql = "SET search_path TO " + quoteIdentifierString(schema);
+        executeUpdate(sql);
+    }
+
+    protected String buildSelectQuery(String tableName,
+            Optional<String> selectColumnList, Optional<String> whereCondition,
+            Optional<String> orderByColumn)
+    {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("SELECT ");
+        sb.append(selectColumnList.or("*"));
+        sb.append(" FROM ").append(quoteIdentifierString(tableName));
+        if (whereCondition.isPresent()) {
+            sb.append(" WHERE ").append(whereCondition.get());
+        }
+        if (orderByColumn.isPresent()) {
+            sb.append("ORDER BY ").append(quoteIdentifierString(orderByColumn.get())).append(" ASC");
+        }
+
+        return sb.toString();
+    }
+
+    public JdbcSchema getSchemaOfQuery(String tableName,
+            Optional<String> selectColumnList, Optional<String> whereCondition,
+            Optional<String> orderByColumn) throws SQLException
+    {
+        String query = buildSelectQuery(tableName, selectColumnList, whereCondition,
+                orderByColumn);
+        PreparedStatement stmt = connection.prepareStatement(query);
+        try {
+            return getSchemaOfResultMetadata(stmt.getMetaData());
+        } finally {
+            stmt.close();
+        }
+    }
+
+    protected JdbcSchema getSchemaOfResultMetadata(ResultSetMetaData metadata) throws SQLException
+    {
+        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 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));
+        }
+        return new JdbcSchema(columns.build());
+    }
+
+    public BatchSelect newSelectCursor(String tableName,
+            Optional<String> selectColumnList, Optional<String> whereCondition,
+            Optional<String> orderByColumn, int fetchRows) throws SQLException
+    {
+        String select = buildSelectQuery(tableName, selectColumnList, whereCondition, orderByColumn);
+        return newBatchSelect(select, fetchRows);
+    }
+
+    protected BatchSelect newBatchSelect(String select, int fetchRows) throws SQLException
+    {
+        logger.info("SQL: " + select);
+        PreparedStatement stmt = connection.prepareStatement(select);
+        stmt.setFetchSize(fetchRows);
+        return new SingleSelect(stmt);
+    }
+
+    public interface BatchSelect
+            extends AutoCloseable
+    {
+        public ResultSet fetch() throws SQLException;
+
+        @Override
+        public void close() throws SQLException;
+    }
+
+    public class SingleSelect
+            implements BatchSelect
+    {
+        private final PreparedStatement fetchStatement;
+        private boolean fetched = false;
+
+        public SingleSelect(PreparedStatement fetchStatement) throws SQLException
+        {
+            this.fetchStatement = fetchStatement;
+        }
+
+        public ResultSet fetch() throws SQLException
+        {
+            if (fetched == true) {
+                return null;
+            }
+
+            long startTime = System.currentTimeMillis();
+
+            ResultSet rs = fetchStatement.executeQuery();
+
+            double seconds = (System.currentTimeMillis() - startTime) / 1000.0;
+            logger.info(String.format("> %.2f seconds", seconds));
+            fetched = true;
+            return rs;
+        }
+
+        public void close() throws SQLException
+        {
+            // TODO close?
+        }
+    }
+
+    @Override
+    public void close() throws SQLException
+    {
+        connection.close();
+    }
+
+    protected void executeUpdate(String sql) throws SQLException
+    {
+        logger.info("SQL: " + sql);
+        Statement stmt = connection.createStatement();
+        try {
+            stmt.executeUpdate(sql);
+        } finally {
+            stmt.close();
+        }
+    }
+
+    // TODO share code with embulk-output-jdbc
+    protected String quoteIdentifierString(String str)
+    {
+        return identifierQuoteString + str + identifierQuoteString;
+    }
+}

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

@@ -0,0 +1,37 @@
+package org.embulk.input.jdbc;
+
+import java.util.List;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public class JdbcSchema
+{
+    private List<JdbcColumn> columns;
+
+    @JsonCreator
+    public JdbcSchema(List<JdbcColumn> columns)
+    {
+        this.columns = columns;
+    }
+
+    @JsonValue
+    public List<JdbcColumn> getColumns()
+    {
+        return columns;
+    }
+
+    public int getCount()
+    {
+        return columns.size();
+    }
+
+    public JdbcColumn getColumn(int i)
+    {
+        return columns.get(i);
+    }
+
+    public String getColumnName(int i)
+    {
+        return columns.get(i).getName();
+    }
+}

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

@@ -0,0 +1,15 @@
+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;
+
+    public Type getToType();
+}

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

@@ -0,0 +1,99 @@
+package org.embulk.input.jdbc.getter;
+
+import java.sql.Types;
+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;
+
+public class ColumnGetterFactory
+{
+    public ColumnGetter newColumnGetter(JdbcColumn column)
+    {
+        switch(column.getSqlType()) {
+        // getLong
+        case Types.TINYINT:
+        case Types.SMALLINT:
+        case Types.INTEGER:
+        case Types.BIGINT:
+            return new LongColumnGetter();
+
+        // setDouble
+        case Types.DOUBLE:
+        case Types.FLOAT:
+        case Types.REAL:
+            return new DoubleColumnGetter();
+
+        // setBool
+        case Types.BOOLEAN:
+        case Types.BIT:  // JDBC BIT is boolean, unlike SQL-92
+            return new BooleanColumnGetter();
+
+        // setString, Clob
+        case Types.CHAR:
+        case Types.VARCHAR:
+        case Types.LONGVARCHAR:
+        case Types.CLOB:
+        case Types.NCHAR:
+        case Types.NVARCHAR:
+        case Types.LONGNVARCHAR:
+            return new StringColumnGetter();
+
+        // TODO
+        //// setBytes Blob
+        //case Types.BINARY:
+        //case Types.VARBINARY:
+        //case Types.LONGVARBINARY:
+        //case Types.BLOB:
+        //    return new BytesColumnGetter();
+
+        // getDate
+        case Types.DATE:
+            return new DateColumnGetter(); // TODO
+
+        // getTime
+        case Types.TIME:
+            return new TimeColumnGetter(); // TODO
+
+        // getTimestamp
+        case Types.TIMESTAMP:
+            return new TimestampColumnGetter();
+
+        // TODO
+        //// Null
+        //case Types.NULL:
+        //    return new NullColumnGetter();
+
+        // TODO
+        //// BigDecimal
+        //case Types.NUMERIC:
+        //case Types.DECIMAL:
+        //    return new BigDecimalColumnGetter();
+
+        // others
+        case Types.ARRAY:  // array
+        case Types.STRUCT: // map
+        case Types.REF:
+        case Types.DATALINK:
+        case Types.SQLXML: // XML
+        case Types.ROWID:
+        case Types.DISTINCT:
+        case Types.JAVA_OBJECT:
+        case Types.OTHER:
+        default:
+            throw unsupportedOperationException(column);
+        }
+    }
+
+    private static UnsupportedOperationException unsupportedOperationException(JdbcColumn column)
+    {
+        throw new UnsupportedOperationException(
+                String.format("Unsupported type %s (sqlType=%d)",
+                    column.getTypeName(), column.getSqlType()));
+    }
+}
+

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

@@ -0,0 +1,175 @@
+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.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
+        {
+            System.out.println("string column from "+fromIndex+" to "+toColumn);
+            String v = from.getString(fromIndex);
+            if (from.wasNull()) {
+                to.setNull(toColumn);
+                System.out.println("> was null");
+            } else {
+                to.setString(toColumn, v);
+                System.out.println("> "+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");
+        }
+    }
+}

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: embulk-input-jdbc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- FURUHASHI Sadayuki
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-02-16 00:00:00.000000000 Z
+dependencies: []
+description: JDBC input plugin is an Embulk plugin that loads records from JDBC so that any output plugins can receive the records. Search the output plugins by "embulk-output" keyword.
+email:
+- frsyuki@users.sourceforge.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- build.gradle
+- 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/JdbcInputConnection.java
+- src/main/java/org/embulk/input/jdbc/JdbcSchema.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.1.0.jar
+homepage: https://github.com/embulk/embulk-input-jdbc
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: JDBC input plugin for Embulk
+test_files: []