embulk-input-db2 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22c93dbebbe181e15af9ee5200d4ff7883ebe074
+  data.tar.gz: 4f4636cbd2ba6fa6b05b1fcdacb82a96b5cd5fc6
+SHA512:
+  metadata.gz: 2212f33180ac595f9ece95d990958c2a4644ee2a3e5ac27dfb6e3a379266cc7843733d0fff3c0f6769534041debfa127790bf729e475d96e196d2bd71f9d932d
+  data.tar.gz: f7396aa5648456ef879a18129494c5d9d4ddf77dcabf3692efeef242a4045afc81f223a99e03a745e09bffcd73d0f18ce631253fd3c6cd96ac4d181ad72252aa

data/README.md

@@ -0,0 +1,148 @@
+# DB2 input plugins for Embulk
+
+DB2 input plugins for Embulk loads records from DB2.
+
+## Overview
+
+* **Plugin type**: input
+* **Resume supported**: yes
+
+## Configuration
+
+- **driver_path**: path to the jar file of the DB2 JDBC driver (string)
+- **host**: database host name (string, required)
+- **port**: database port number (integer, default: 50000)
+- **user**: database login user name (string, required)
+- **password**: database login password (string)
+- **database**: destination database name (string, required)
+- **schema**: destination schema name (string, default: use the default schema)
+- If you write SQL directly,
+  - **query**: SQL to run (string)
+- If **query** is not set,
+  - **table**: destination table name (string, required)
+  - **select**: expression of select (e.g. `id, created_at`) (string, default: "*")
+  - **where**: WHERE condition to filter the rows (string, default: no-condition)
+  - **order_by**: expression of ORDER BY to sort rows (e.g. `created_at DESC, id ASC`) (string, default: not sorted)
+- **fetch_rows**: number of rows to fetch one time (used for java.sql.Statement#setFetchSize) (integer, default: 10000)
+- **connect_timeout**: timeout for the driver to connect. 0 means no timeout. (integer (seconds), default: 300)
+- **socket_timeout**: timeout for executing the query. 0 means no timeout. (integer (seconds), default: 1800)
+- **options**: extra JDBC properties (hash, default: {})
+- **incremental**: if true, enables incremental loading. See next section for details (boolean, default: false)
+- **incremental_columns**: column names for incremental loading (array of strings, default: use primary keys)
+- **last_record**: values of the last record for incremental loading (array of objects, default: load all records)
+- **default_timezone**: If the sql type of a column is `date`/`time`/`datetime` and the embulk type is `string`, column values are formatted int this default_timezone. You can overwrite timezone for each columns using column_options option. (string, default: `UTC`)
+- **column_options**: advanced: a key-value pairs where key is a column name and value is options for the column.
+  - **value_type**: embulk get values from database as this value_type. Typically, the value_type determines `getXXX` method of `java.sql.PreparedStatement`.
+  (string, default: depends on the sql type of the column. Available values options are: `long`, `double`, `float`, `decimal`, `boolean`, `string`, `json`, `date`, `time`, `timestamp`)
+  - **type**: Column values are converted to this embulk type.
+  Available values options are: `boolean`, `long`, `double`, `string`, `json`, `timestamp`).
+  By default, the embulk type is determined according to the sql type of the column (or value_type if specified).
+  - **timestamp_format**: If the sql type of the column is `date`/`time`/`datetime` and the embulk type is `string`, column values are formatted by this timestamp_format. And if the embulk type is `timestamp`, this timestamp_format may be used in the output plugin. For example, stdout plugin use the timestamp_format, but *csv formatter plugin doesn't use*. (string, default : `%Y-%m-%d` for `date`, `%H:%M:%S` for `time`, `%Y-%m-%d %H:%M:%S` for `timestamp`)
+  - **timezone**: If the sql type of the column is `date`/`time`/`datetime` and the embulk type is `string`, column values are formatted in this timezone.
+(string, value of default_timezone option is used by default)
+- **after_select**: if set, this SQL will be executed after the SELECT query in the same transaction.
+
+
+### Incremental loading
+
+Incremental loading uses monotonically increasing unique columns (such as incremental (SEQUENCE) column) to load records inserted (or updated) after last execution.
+
+First, if `incremental: true` is set, this plugin loads all records with additional ORDER BY. For example, if `incremental_columns: [updated_at, id]` option is set, query will be as following:
+
+```
+SELECT * FROM (
+  ...original query is here...
+)
+ORDER BY updated_at, id
+```
+
+When bulk data loading finishes successfully, it outputs `last_record: ` paramater as config-diff so that next execution uses it.
+
+At the next execution, when `last_record: ` is also set, this plugin generates additional WHERE conditions to load records larger than the last record. For example, if `last_record: ["2017-01-01 00:32:12", 5291]` is set,
+
+```
+SELECT * FROM (
+  ...original query is here...
+)
+WHERE created_at > '2017-01-01 00:32:12' OR (created_at = '2017-01-01 00:32:12' AND id > 5291)
+ORDER BY updated_at, id
+```
+
+Then, it updates `last_record: ` so that next execution uses the updated last_record.
+
+**IMPORTANT**: If you set `incremental_columns: ` option, make sure that there is an index on the columns to avoid full table scan. For this example, following index should be created:
+
+```
+CREATE INDEX embulk_incremental_loading_index ON table (updated_at, id);
+```
+
+Recommended usage is to leave `incremental_columns` unset and let this plugin automatically finds a primary key. Currently, only strings and integers are supported as incremental_columns.
+
+
+## Example
+
+```yaml
+in:
+  type: db2
+  driver_path: /opt/db2/db2jcc4.jar
+  host: localhost
+  user: myuser
+  password: ""
+  database: my_database
+  table: my_table
+  select: "col1, col2, col3"
+  where: "col4 != 'a'"
+  order_by: "col1 DESC"
+```
+
+This configuration will generate following SQL:
+
+```
+SELECT col1, col2, col3
+FROM "my_table"
+WHERE col4 != 'a'
+ORDER BY col1 DESC
+```
+
+If you need a complex SQL,
+
+```yaml
+in:
+  type: db2
+  driver_path: /opt/db2/db2jcc4.jar
+  host: localhost
+  user: myuser
+  password: ""
+  database: my_database
+  query: |
+    SELECT t1.id, t1.name, t2.id AS t2_id, t2.name AS t2_name
+    FROM table1 AS t1
+    LEFT JOIN table2 AS t2
+      ON t1.id = t2.t1_id
+```
+
+Advanced configuration:
+
+```yaml
+in:
+  type: db2
+  driver_path: /opt/db2/db2jcc4.jar
+  host: localhost
+  user: myuser
+  password: ""
+  database: my_database
+  table: "my_table"
+  select: "col1, col2, col3"
+  where: "col4 != 'a'"
+  column_options:
+    col1: {type: long}
+    col3: {type: string, timestamp_format: "%Y/%m/%d", timezone: "+0900"}
+  after_select: "update my_table set col5 = '1' where col4 != 'a'"
+
+```
+
+## Build
+
+```
+$ ./gradlew gem
+```

data/build.gradle

@@ -0,0 +1,7 @@
+dependencies {
+    compile project(':embulk-input-jdbc')
+
+    testCompile project(':embulk-input-jdbc').sourceSets.test.output
+    testCompile 'org.embulk:embulk-standards:0.8.8'
+    testCompile files('driver/db2jcc4.jar')
+}

data/lib/embulk/input/db2.rb

@@ -0,0 +1,3 @@
+Embulk::JavaPlugin.register_input(
+  :db2, "org.embulk.input.DB2InputPlugin",
+  File.expand_path('../../../../classpath', __FILE__))

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

@@ -0,0 +1,94 @@
+package org.embulk.input;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import org.embulk.config.Config;
+import org.embulk.config.ConfigDefault;
+import org.embulk.input.db2.DB2InputConnection;
+import org.embulk.input.jdbc.AbstractJdbcInputPlugin;
+import org.embulk.input.jdbc.JdbcInputConnection;
+
+import com.google.common.base.Optional;
+import static java.util.Locale.ENGLISH;
+
+public class DB2InputPlugin
+    extends AbstractJdbcInputPlugin
+{
+    public interface DB2PluginTask
+        extends PluginTask
+    {
+        @Config("driver_path")
+        @ConfigDefault("null")
+        public Optional<String> getDriverPath();
+
+        @Config("host")
+        public String getHost();
+
+        @Config("port")
+        @ConfigDefault("50000")
+        public int getPort();
+
+        @Config("database")
+        public String getDatabase();
+
+        @Config("schema")
+        @ConfigDefault("null")
+        public Optional<String> getSchema();
+
+        @Config("user")
+        public String getUser();
+
+        @Config("password")
+        @ConfigDefault("null")
+        public Optional<String> getPassword();
+    }
+
+    @Override
+    protected Class<? extends PluginTask> getTaskClass()
+    {
+        return DB2PluginTask.class;
+    }
+
+    @Override
+    protected JdbcInputConnection newConnection(PluginTask task) throws SQLException
+    {
+        DB2PluginTask db2Task = (DB2PluginTask) task;
+
+        String url = String.format(ENGLISH, "jdbc:db2://%s:%d/%s",
+                db2Task.getHost(), db2Task.getPort(), db2Task.getDatabase());
+
+        Properties props = new Properties();
+        props.setProperty("user", db2Task.getUser());
+        if (db2Task.getPassword().isPresent()) {
+            props.setProperty("password", db2Task.getPassword().get());
+        }
+        props.setProperty("connectionTimeout", String.valueOf(db2Task.getConnectTimeout() * 1000)); // milliseconds
+        props.setProperty("commandTimeout", String.valueOf(db2Task.getSocketTimeout() * 1000)); // milliseconds
+        props.putAll(db2Task.getOptions());
+
+        if (db2Task.getDriverPath().isPresent()) {
+            addDriverJarToClasspath(db2Task.getDriverPath().get());
+        }
+
+        try {
+            Class.forName("com.ibm.db2.jcc.DB2Driver");
+        } catch (Exception ex) {
+            throw new RuntimeException(ex);
+        }
+
+        Connection con = DriverManager.getConnection(url, props);
+        try {
+            DB2InputConnection c = new DB2InputConnection(con, db2Task.getSchema().orNull());
+            con = null;
+            return c;
+        } finally {
+            if (con != null) {
+                con.close();
+            }
+        }
+    }
+
+}

data/src/main/java/org/embulk/input/db2/DB2InputConnection.java

@@ -0,0 +1,30 @@
+package org.embulk.input.db2;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import org.embulk.input.jdbc.JdbcInputConnection;
+
+public class DB2InputConnection extends JdbcInputConnection {
+
+    public DB2InputConnection(Connection connection, String schemaName) throws SQLException
+    {
+        super(connection, schemaName);
+    }
+
+    @Override
+    protected void setSearchPath(String schema) throws SQLException
+    {
+        connection.setSchema(schema);
+    }
+
+    @Override
+    public void close() throws SQLException
+    {
+        // DB2 JDBC Driver requires explicit commit/rollback before closing connection.
+        connection.rollback();
+
+        super.close();
+    }
+
+}

data/src/test/java/org/embulk/input/db2/DB2InputPluginTest.java

@@ -0,0 +1,290 @@
+package org.embulk.input.db2;
+
+import static java.util.Locale.ENGLISH;
+import static org.junit.Assert.assertEquals;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Arrays;
+
+import org.embulk.input.AbstractJdbcInputPluginTest;
+import org.embulk.input.DB2InputPlugin;
+import org.embulk.spi.InputPlugin;
+import org.junit.Test;
+
+public class DB2InputPluginTest extends AbstractJdbcInputPluginTest
+{
+    @Override
+    protected void prepare() throws SQLException
+    {
+        tester.addPlugin(InputPlugin.class, "db2", DB2InputPlugin.class);
+
+        try {
+            Class.forName("com.ibm.db2.jcc.DB2Driver");
+        } catch (ClassNotFoundException e) {
+            System.err.println("Warning: you should put 'db2jcc4.jar' in 'embulk-input-db2/driver' directory in order to test.");
+            return;
+        }
+
+        try {
+            connect();
+        } catch (SQLException e) {
+            System.err.println(e);
+            System.err.println(String.format(ENGLISH, "Warning: prepare a schema on DB2 (server = %s, port = %d, database = %s, user = %s, password = %s).",
+                    getHost(), getPort(), getDatabase(), getUser(), getPassword()));
+            return;
+        }
+
+        enabled = true;
+
+        String dropString = "DROP TABLE TEST_STRING";
+        executeSQL(dropString, true);
+
+        String createString =
+                "CREATE TABLE TEST_STRING ("
+                + "ID               CHAR(2) NOT NULL,"
+                + "CHAR_ITEM        CHAR(4),"
+                + "VARCHAR_ITEM     VARCHAR(8),"
+                + "CLOB_ITEM        CLOB,"
+                + "GRAPHIC_ITEM     GRAPHIC(4),"
+                + "VARGRAPHIC_ITEM  VARGRAPHIC(8),"
+                + "NCHAR_ITEM       NCHAR(4),"
+                + "NVARCHAR_ITEM    NVARCHAR(8),"
+                + "NCLOB_ITEM       NCLOB,"
+                + "PRIMARY KEY (ID))";
+        executeSQL(createString);
+
+        String insertString1 =
+                "INSERT INTO TEST_STRING VALUES("
+                + "'10',"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL)";
+        executeSQL(insertString1);
+
+        String insertString2 =
+                "INSERT INTO TEST_STRING VALUES("
+                + "'11',"
+                + "'aa',"
+                + "'AA',"
+                + "'aaaaaaaaaaaa',"
+                + "'ああ',"
+                + "'いいいい',"
+                + "'ａａ',"
+                + "'ＡＡ',"
+                + "'ａａａａａａａａ')";
+        executeSQL(insertString2);
+
+        String dropNumber = "DROP TABLE TEST_NUMBER";
+        executeSQL(dropNumber, true);
+
+        String createNumber =
+                "CREATE TABLE TEST_NUMBER ("
+                + "ID               CHAR(2) NOT NULL,"
+                + "SMALLINT_ITEM    SMALLINT,"
+                + "INTEGER_ITEM     INTEGER,"
+                + "BIGINT_ITEM      BIGINT,"
+                + "DECIMAL_ITEM      DECIMAL(8,2),"
+                + "NUMERIC_ITEM     NUMERIC(8,2),"
+                + "REAL_ITEM        REAL,"
+                + "DOUBLE_ITEM      DOUBLE,"
+                + "FLOAT_ITEM       FLOAT,"
+                + "PRIMARY KEY (ID))";
+        executeSQL(createNumber);
+
+        String insertNumber1 =
+                "INSERT INTO TEST_NUMBER VALUES("
+                + "'10',"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL)";
+        executeSQL(insertNumber1);
+
+        String insertNumber2 =
+                "INSERT INTO TEST_NUMBER VALUES("
+                + "'11',"
+                + "12345,"
+                + "123456789,"
+                + "123456789012,"
+                + "123456.78,"
+                + "876543.21,"
+                + "1.23456,"
+                + "1.23456789012,"
+                + "3.45678901234)";
+        executeSQL(insertNumber2);
+
+        String insertNumber3 =
+                "INSERT INTO TEST_NUMBER VALUES("
+                + "'12',"
+                + "-12345,"
+                + "-123456789,"
+                + "-123456789012,"
+                + "-123456.78,"
+                + "-876543.21,"
+                + "-1.23456,"
+                + "-1.23456789012,"
+                + "-3.45678901234)";
+        executeSQL(insertNumber3);
+
+        String dropDateTime = "DROP TABLE TEST_DATETIME";
+        executeSQL(dropDateTime, true);
+
+        String createDateTime =
+                "CREATE TABLE TEST_DATETIME ("
+                + "ID               CHAR(2) NOT NULL,"
+                + "DATE_ITEM        DATE,"
+                + "TIME_ITEM        TIME,"
+                + "TIMESTAMP_ITEM   TIMESTAMP,"
+                + "TIMESTAMP0_ITEM  TIMESTAMP(0),"
+                + "TIMESTAMP12_ITEM TIMESTAMP(12),"
+                + "PRIMARY KEY (ID))";
+        executeSQL(createDateTime);
+
+        String insertDateTime1 =
+                "INSERT INTO TEST_DATETIME VALUES("
+                + "'10',"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL,"
+                + "NULL)";
+        executeSQL(insertDateTime1);
+
+        String insertDateTime2 =
+                "INSERT INTO TEST_DATETIME VALUES("
+                + "'11',"
+                + "'2016-09-08',"
+                + "'12:34:45',"
+                + "'2016-09-09 12:34:45.123456',"
+                + "'2016-09-10 12:34:45',"
+                + "'2016-09-11 12:34:45.123456789012')";
+        executeSQL(insertDateTime2);
+
+        /*
+        String create1 =
+                "create table test1 ("
+                + "c1  tinyint,"
+                + "c2  smallint,"
+                + "c3  int,"
+                + "c4  bigint,"
+                + "c5  float,"
+                + "c6  double,"
+                + "c7  decimal(4,0),"
+                + "c8  decimal(20,2),"
+                + "c9  char(4),"
+                + "c10 varchar(4),"
+                + "c11 date,"
+                + "c12 datetime,"
+                + "c13 timestamp,"
+                + "c14 time,"
+                + "c15 datetime(6));";
+        executeSQL(create1);
+
+        String insert1 =
+                "insert into test1 values("
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "null,"
+                + "'2015-06-04 23:45:06',"
+                + "null,"
+                + "null);";
+        executeSQL(insert1);
+
+        String insert2 =
+                "insert into test1 values("
+                + "99,"
+                + "9999,"
+                + "-99999999,"
+                + "-9999999999999999,"
+                + "1.2345,"
+                + "1.234567890123,"
+                + "-1234,"
+                + "123456789012345678.12,"
+                + "'5678',"
+                + "'xy',"
+                + "'2015-06-04',"
+                + "'2015-06-04 12:34:56',"
+                + "'2015-06-04 23:45:06',"
+                + "'08:04:02',"
+                + "'2015-06-04 01:02:03.123456');";
+        executeSQL(insert2);
+
+        String drop2 = "drop table if exists test2";
+        executeSQL(drop2);
+
+        String create2 = "create table test2 (c1 bigint unsigned);";
+        executeSQL(create2);
+
+        String insert3 = "insert into test2 values(18446744073709551615)";
+        executeSQL(insert3);*/
+    }
+
+    @Test
+    public void testString() throws Exception
+    {
+        if (enabled) {
+            test("/db2/yml/input-string.yml");
+            assertEquals(Arrays.asList(
+                    "ID,CHAR_ITEM,VARCHAR_ITEM,CLOB_ITEM,GRAPHIC_ITEM,VARGRAPHIC_ITEM,NCHAR_ITEM,NVARCHAR_ITEM,NCLOB_ITEM",
+                    "10,,,,,,,,",
+                    "11,aa  ,AA,aaaaaaaaaaaa,ああ  ,いいいい,ａａ  ,ＡＡ,ａａａａａａａａ"),
+                    read("db2-input000.00.csv"));
+        }
+    }
+
+    @Test
+    public void testNumber() throws Exception
+    {
+        if (enabled) {
+            test("/db2/yml/input-number.yml");
+            assertEquals(Arrays.asList(
+                    "ID,SMALLINT_ITEM,INTEGER_ITEM,BIGINT_ITEM,DECIMAL_ITEM,NUMERIC_ITEM,REAL_ITEM,DOUBLE_ITEM,FLOAT_ITEM",
+                    "10,,,,,,,,",
+                    // (double)1.23456f becomes "1.2345600128173828", not "1.23456", because of difference of precision.
+                    "11,12345,123456789,123456789012,123456.78,876543.21," + (double)1.23456f + ",1.23456789012,3.45678901234",
+                    "12,-12345,-123456789,-123456789012,-123456.78,-876543.21," + (double)-1.23456f + ",-1.23456789012,-3.45678901234"),
+                    read("db2-input000.00.csv"));
+        }
+    }
+
+    @Test
+    public void testDateTime() throws Exception
+    {
+        if (enabled) {
+            test("/db2/yml/input-datetime.yml");
+            assertEquals(Arrays.asList(
+                    "ID,DATE_ITEM,TIME_ITEM,TIMESTAMP_ITEM,TIMESTAMP0_ITEM,TIMESTAMP12_ITEM",
+                    "10,,,,,",
+                    // precision of embulk timestamp is nano seconds
+                    "11,2016/09/07,03-34-45,2016/09/09 03:34:45,2016/09/10 12:34:45,2016/09/11 03:34:45.123456789000"),
+                    read("db2-input000.00.csv"));
+        }
+    }
+
+    @Override
+    protected Connection connect() throws SQLException
+    {
+        return DriverManager.getConnection(String.format(ENGLISH, "jdbc:db2://%s:%d/%s", getHost(), getPort(), getDatabase()),
+                getUser(), getPassword());
+    }
+}

data/src/test/resources/db2/yml/input-datetime.yml

@@ -0,0 +1,23 @@
+in:
+  type: db2
+  host: #host#
+  database: #database#
+  user: #user#
+  password: #password#
+  table: TEST_DATETIME
+  select: "*"
+  order_by: "id"
+  default_timezone: '+0900'
+
+out:
+  type: file
+  path_prefix: db2-input
+  file_ext: csv
+  formatter:
+    type: csv
+    column_options:
+      DATE_ITEM: {format: '%Y/%m/%d'}
+      TIME_ITEM: {format: '%H-%M-%S'}
+      TIMESTAMP_ITEM: {format: '%Y/%m/%d %H:%M:%S'}
+      TIMESTAMP0_ITEM: {format: '%Y/%m/%d %H:%M:%S', timezone: '+0900'}
+      TIMESTAMP12_ITEM: {format: '%Y/%m/%d %H:%M:%S.%12N'}

data/src/test/resources/db2/yml/input-number.yml

@@ -0,0 +1,16 @@
+in:
+  type: db2
+  host: #host#
+  database: #database#
+  user: #user#
+  password: #password#
+  table: TEST_NUMBER
+  select: "*"
+  order_by: "id"
+
+out:
+  type: file
+  path_prefix: db2-input
+  file_ext: csv
+  formatter:
+    type: csv

data/src/test/resources/db2/yml/input-string.yml

@@ -0,0 +1,16 @@
+in:
+  type: db2
+  host: #host#
+  database: #database#
+  user: #user#
+  password: #password#
+  table: TEST_STRING
+  select: "*"
+  order_by: "id"
+
+out:
+  type: file
+  path_prefix: db2-input
+  file_ext: csv
+  formatter:
+    type: csv

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: embulk-input-db2
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Sadayuki Furuhashi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-10-13 00:00:00.000000000 Z
+dependencies: []
+description: Selects records from a table.
+email:
+- frsyuki@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- build.gradle
+- classpath/embulk-input-db2-0.8.0.jar
+- classpath/embulk-input-jdbc-0.8.0.jar
+- lib/embulk/input/db2.rb
+- src/main/java/org/embulk/input/DB2InputPlugin.java
+- src/main/java/org/embulk/input/db2/DB2InputConnection.java
+- src/test/java/org/embulk/input/db2/DB2InputPluginTest.java
+- src/test/resources/db2/yml/input-datetime.yml
+- src/test/resources/db2/yml/input-number.yml
+- src/test/resources/db2/yml/input-string.yml
+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.4.8
+signing_key:
+specification_version: 4
+summary: JDBC input plugin for Embulk
+test_files: []