embulk-output-jdbc 0.7.8 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c759a626427a5ec9749cd197ac4a953722b987c
-  data.tar.gz: 223de4b4c1857df71d16dcb2ef18fd8449975936
+  metadata.gz: 48a1142e7d456697b9e0d0c005cde55dec3d7084
+  data.tar.gz: e7616b21132acca2bb8aeddbb4eb59f4a5ee5f8a
 SHA512:
-  metadata.gz: 9a2eda7680e153dbca7bb6f958ac49c0e5d30c6c4116d07586b30b28834a9b1376f3352a291507eae9629649d26a4bce184be2307fb00e90b4c890adbcab25b2
-  data.tar.gz: 67df35b9235c1b441637a6fd878706075076cfb4de394122a50e8d3f0a882a4356d20729c6f5248afe5dc548d10cd1ff8e6846462f359f58e6a8686608f15f1e
+  metadata.gz: d45ff98b8f76f3c0c293a583e8a29a0a1bfb78c5d19f29dd217e129819f968280167dffcb973fd5772d6dae154f52ee1c03766e6a29e471a9fd757d8e337fa45
+  data.tar.gz: 3a45ce034e613ba50a2361d5ccb6de5a9dc8588de7670ca4fa29bbc17ae2a495c6e24bfc41390f2b894d96514104585d2d5a5adc6744e8fdd7819b85954e243a

data/src/main/java/org/embulk/output/jdbc/AbstractJdbcOutputPlugin.java

@@ -15,6 +15,7 @@ import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
 
 import org.embulk.spi.util.RetryExecutor;
+import org.embulk.spi.util.RetryExecutor.RetryGiveupException;
 import org.slf4j.Logger;
 import org.joda.time.DateTimeZone;
 
@@ -116,8 +117,8 @@ public abstract class AbstractJdbcOutputPlugin
         @ConfigDefault("null")
         public Optional<String> getAfterLoad();
 
-        public void setActualTable(String actualTable);
-        public String getActualTable();
+        public void setActualTable(TableIdentifier actualTable);
+        public TableIdentifier getActualTable();
 
         public void setMergeKeys(Optional<List<String>> keys);
 
@@ -130,8 +131,8 @@ public abstract class AbstractJdbcOutputPlugin
         public JdbcSchema getTargetTableSchema();
         public void setTargetTableSchema(JdbcSchema schema);
 
-        public Optional<List<String>> getIntermediateTables();
-        public void setIntermediateTables(Optional<List<String>> names);
+        public Optional<List<TableIdentifier>> getIntermediateTables();
+        public void setIntermediateTables(Optional<List<TableIdentifier>> names);
     }
 
     public static enum LengthSemantics
@@ -461,8 +462,9 @@ public abstract class AbstractJdbcOutputPlugin
             throw new ConfigException(String.format("%s mode does not support 'before_load' option.", mode));
         }
 
+        String actualTable;
         if (con.tableExists(task.getTable())) {
-            task.setActualTable(task.getTable());
+            actualTable = task.getTable();
         } else {
             String upperTable = task.getTable().toUpperCase();
             String lowerTable = task.getTable().toLowerCase();
@@ -471,16 +473,17 @@ public abstract class AbstractJdbcOutputPlugin
                     throw new ConfigException(String.format("Cannot specify table '%s' because both '%s' and '%s' exist.",
                             task.getTable(), upperTable, lowerTable));
                 } else {
-                    task.setActualTable(upperTable);
+                    actualTable = upperTable;
                 }
             } else {
                 if (con.tableExists(lowerTable)) {
-                    task.setActualTable(lowerTable);
+                    actualTable = lowerTable;
                 } else {
-                    task.setActualTable(task.getTable());
+                    actualTable = task.getTable();
                 }
             }
         }
+        task.setActualTable(new TableIdentifier(null, con.getSchemaName(), actualTable));
 
         Optional<JdbcSchema> initialTargetTableSchema =
             mode.ignoreTargetTableSchema() ?
@@ -499,29 +502,11 @@ public abstract class AbstractJdbcOutputPlugin
 
         // create intermediate tables
         if (!mode.isDirectModify()) {
-            // direct modify mode doesn't need intermediate tables.
-            ImmutableList.Builder<String> intermTableNames = ImmutableList.builder();
-            if (mode.tempTablePerTask()) {
-                String namePrefix = generateIntermediateTableNamePrefix(task.getActualTable(), con, 3,
-                        task.getFeatures().getMaxTableNameLength(), task.getFeatures().getTableNameLengthSemantics());
-                for (int i = 0; i < taskCount; i++) {
-                    intermTableNames.add(namePrefix + String.format("%03d", i));
-                }
-            } else {
-                String name = generateIntermediateTableNamePrefix(task.getActualTable(), con, 0,
-                        task.getFeatures().getMaxTableNameLength(), task.getFeatures().getTableNameLengthSemantics());
-                intermTableNames.add(name);
-            }
             // create the intermediate tables here
-            task.setIntermediateTables(Optional.<List<String>>of(intermTableNames.build()));
-            for (String name : task.getIntermediateTables().get()) {
-                // DROP TABLE IF EXISTS xyz__0000000054d92dee1e452158_bulk_load_temp
-                con.dropTableIfExists(name);
-                // CREATE TABLE IF NOT EXISTS xyz__0000000054d92dee1e452158_bulk_load_temp
-                con.createTableIfNotExists(name, newTableSchema);
-            }
+            task.setIntermediateTables(Optional.<List<TableIdentifier>>of(createIntermediateTables(con, task, taskCount, newTableSchema)));
         } else {
-            task.setIntermediateTables(Optional.<List<String>>absent());
+            // direct modify mode doesn't need intermediate tables.
+            task.setIntermediateTables(Optional.<List<TableIdentifier>>absent());
             if (task.getBeforeLoad().isPresent()) {
                 con.executeSql(task.getBeforeLoad().get());
             }
@@ -533,7 +518,7 @@ public abstract class AbstractJdbcOutputPlugin
             targetTableSchema = initialTargetTableSchema.get();
             task.setNewTableSchema(Optional.<JdbcSchema>absent());
         } else if (task.getIntermediateTables().isPresent() && !task.getIntermediateTables().get().isEmpty()) {
-            String firstItermTable = task.getIntermediateTables().get().get(0);
+            TableIdentifier firstItermTable = task.getIntermediateTables().get().get(0);
             targetTableSchema = newJdbcSchemaFromTableIfExists(con, firstItermTable).get();
             task.setNewTableSchema(Optional.of(newTableSchema));
         } else {
@@ -591,6 +576,91 @@ public abstract class AbstractJdbcOutputPlugin
         return new ColumnSetterFactory(batch, defaultTimeZone);
     }
 
+    protected TableIdentifier buildIntermediateTableId(final JdbcOutputConnection con, PluginTask task, String tableName)
+    {
+        return new TableIdentifier(null, con.getSchemaName(), tableName);
+    }
+
+    private List<TableIdentifier> createIntermediateTables(final JdbcOutputConnection con,
+            final PluginTask task, final int taskCount, final JdbcSchema newTableSchema) throws SQLException
+    {
+        try {
+            return buildRetryExecutor(task).run(new Retryable<List<TableIdentifier>>() {
+                private TableIdentifier table;
+                private ImmutableList.Builder<TableIdentifier> intermTables;
+
+                @Override
+                public List<TableIdentifier> call() throws Exception
+                {
+                    intermTables = ImmutableList.builder();
+                    if (task.getMode().tempTablePerTask()) {
+                        String namePrefix = generateIntermediateTableNamePrefix(task.getActualTable().getTableName(), con, 3,
+                                task.getFeatures().getMaxTableNameLength(), task.getFeatures().getTableNameLengthSemantics());
+                        for (int taskIndex = 0; taskIndex < taskCount; taskIndex++) {
+                            String tableName = namePrefix + String.format("%03d", taskIndex);
+                            table = buildIntermediateTableId(con, task, tableName);
+                            // if table already exists, SQLException will be thrown
+                            con.createTable(table, newTableSchema);
+                            intermTables.add(table);
+                        }
+                    } else {
+                        String tableName = generateIntermediateTableNamePrefix(task.getActualTable().getTableName(), con, 0,
+                                task.getFeatures().getMaxTableNameLength(), task.getFeatures().getTableNameLengthSemantics());
+                        table = buildIntermediateTableId(con, task, tableName);
+                        con.createTable(table, newTableSchema);
+                        intermTables.add(table);
+                    }
+                    return intermTables.build();
+                }
+
+                @Override
+                public boolean isRetryableException(Exception exception)
+                {
+                    if (exception instanceof SQLException) {
+                        try {
+                            // true means that creating table failed because the table already exists.
+                            return con.tableExists(table);
+                        } catch (SQLException e) {
+                        }
+                    }
+                    return false;
+                }
+
+                @Override
+                public void onRetry(Exception exception, int retryCount, int retryLimit, int retryWait)
+                        throws RetryGiveupException
+                {
+                    logger.info("Try to create intermediate tables again because already exist");
+                    try {
+                        dropTables();
+                    } catch (SQLException e) {
+                        throw new RetryGiveupException(e);
+                    }
+                }
+
+                @Override
+                public void onGiveup(Exception firstException, Exception lastException)
+                        throws RetryGiveupException
+                {
+                    try {
+                        dropTables();
+                    } catch (SQLException e) {
+                        logger.warn("Cannot delete intermediate table", e);
+                    }
+                }
+
+                private void dropTables() throws SQLException
+                {
+                    for (TableIdentifier table : intermTables.build()) {
+                        con.dropTableIfExists(table);
+                    }
+                }
+            });
+        } catch (RetryGiveupException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     protected String generateIntermediateTableNamePrefix(String baseTableName, JdbcOutputConnection con,
             int suffixLength, int maxLength, LengthSemantics lengthSemantics) throws SQLException
     {
@@ -729,7 +799,7 @@ public abstract class AbstractJdbcOutputPlugin
         throws SQLException
     {
         if (task.getIntermediateTables().isPresent()) {
-            for (String intermTable : task.getIntermediateTables().get()) {
+            for (TableIdentifier intermTable : task.getIntermediateTables().get()) {
                 con.dropTableIfExists(intermTable);
             }
         }
@@ -788,9 +858,9 @@ public abstract class AbstractJdbcOutputPlugin
     }
 
     public Optional<JdbcSchema> newJdbcSchemaFromTableIfExists(JdbcOutputConnection connection,
-            String tableName) throws SQLException
+            TableIdentifier table) throws SQLException
     {
-        if (!connection.tableExists(tableName)) {
+        if (!connection.tableExists(table)) {
             // DatabaseMetaData.getPrimaryKeys fails if table does not exist
             return Optional.absent();
         }
@@ -798,7 +868,7 @@ public abstract class AbstractJdbcOutputPlugin
         DatabaseMetaData dbm = connection.getMetaData();
         String escape = dbm.getSearchStringEscape();
 
-        ResultSet rs = dbm.getPrimaryKeys(null, connection.getSchemaName(), tableName);
+        ResultSet rs = dbm.getPrimaryKeys(table.getDatabase(), table.getSchemaName(), table.getTableName());
         ImmutableSet.Builder<String> primaryKeysBuilder = ImmutableSet.builder();
         try {
             while(rs.next()) {
@@ -810,9 +880,10 @@ public abstract class AbstractJdbcOutputPlugin
         ImmutableSet<String> primaryKeys = primaryKeysBuilder.build();
 
         ImmutableList.Builder<JdbcColumn> builder = ImmutableList.builder();
-        rs = dbm.getColumns(null,
-                JdbcUtils.escapeSearchString(connection.getSchemaName(), escape),
-                JdbcUtils.escapeSearchString(tableName, escape),
+        rs = dbm.getColumns(
+                JdbcUtils.escapeSearchString(table.getDatabase(), escape),
+                JdbcUtils.escapeSearchString(table.getSchemaName(), escape),
+                JdbcUtils.escapeSearchString(table.getTableName(), escape),
                 null);
         try {
             while (rs.next()) {
@@ -887,7 +958,7 @@ public abstract class AbstractJdbcOutputPlugin
             }
 
             // configure BatchInsert -> an intermediate table (!isDirectModify) or the target table (isDirectModify)
-            String destTable;
+            TableIdentifier destTable;
             if (mode.tempTablePerTask()) {
                 destTable = task.getIntermediateTables().get().get(taskIndex);
             } else if (mode.isDirectModify()) {

data/src/main/java/org/embulk/output/jdbc/BatchInsert.java

@@ -8,7 +8,7 @@ import org.embulk.spi.time.Timestamp;
 
 public interface BatchInsert
 {
-    public void prepare(String loadTable, JdbcSchema insertSchema) throws SQLException;
+    public void prepare(TableIdentifier loadTable, JdbcSchema insertSchema) throws SQLException;
 
     public int getBatchWeight();
 

data/src/main/java/org/embulk/output/jdbc/JdbcOutputConnection.java

@@ -11,7 +11,9 @@ import java.sql.SQLException;
 import java.sql.Statement;
 
 import org.slf4j.Logger;
+
 import com.google.common.base.Optional;
+
 import org.embulk.spi.Exec;
 
 public class JdbcOutputConnection
@@ -70,18 +72,23 @@ public class JdbcOutputConnection
         }
     }
 
-    public boolean tableExists(String tableName) throws SQLException
+    public boolean tableExists(TableIdentifier table) throws SQLException
     {
-        try (ResultSet rs = connection.getMetaData().getTables(null, schemaName, tableName, null)) {
+        try (ResultSet rs = connection.getMetaData().getTables(table.getDatabase(), table.getSchemaName(), table.getTableName(), null)) {
             return rs.next();
         }
     }
 
-    public void dropTableIfExists(String tableName) throws SQLException
+    public boolean tableExists(String tableName) throws SQLException
+    {
+        return tableExists(new TableIdentifier(null, schemaName, tableName));
+    }
+
+    public void dropTableIfExists(TableIdentifier table) throws SQLException
     {
         Statement stmt = connection.createStatement();
         try {
-            dropTableIfExists(stmt, tableName);
+            dropTableIfExists(stmt, table);
             commitIfNecessary(connection);
         } catch (SQLException ex) {
             throw safeRollback(connection, ex);
@@ -90,17 +97,17 @@ public class JdbcOutputConnection
         }
     }
 
-    protected void dropTableIfExists(Statement stmt, String tableName) throws SQLException
+    protected void dropTableIfExists(Statement stmt, TableIdentifier table) throws SQLException
     {
-        String sql = String.format("DROP TABLE IF EXISTS %s", quoteIdentifierString(tableName));
+        String sql = String.format("DROP TABLE IF EXISTS %s", quoteTableIdentifier(table));
         executeUpdate(stmt, sql);
     }
 
-    public void dropTable(String tableName) throws SQLException
+    public void dropTable(TableIdentifier table) throws SQLException
     {
         Statement stmt = connection.createStatement();
         try {
-            dropTable(stmt, tableName);
+            dropTable(stmt, table);
             commitIfNecessary(connection);
         } catch (SQLException ex) {
             throw safeRollback(connection, ex);
@@ -109,17 +116,17 @@ public class JdbcOutputConnection
         }
     }
 
-    protected void dropTable(Statement stmt, String tableName) throws SQLException
+    protected void dropTable(Statement stmt, TableIdentifier table) throws SQLException
     {
-        String sql = String.format("DROP TABLE %s", quoteIdentifierString(tableName));
+        String sql = String.format("DROP TABLE %s", quoteTableIdentifier(table));
         executeUpdate(stmt, sql);
     }
 
-    public void createTableIfNotExists(String tableName, JdbcSchema schema) throws SQLException
+    public void createTableIfNotExists(TableIdentifier targetTable, JdbcSchema schema) throws SQLException
     {
         Statement stmt = connection.createStatement();
         try {
-            String sql = buildCreateTableIfNotExistsSql(tableName, schema);
+            String sql = buildCreateTableIfNotExistsSql(targetTable, schema);
             executeUpdate(stmt, sql);
             commitIfNecessary(connection);
         } catch (SQLException ex) {
@@ -129,12 +136,36 @@ public class JdbcOutputConnection
         }
     }
 
-    protected String buildCreateTableIfNotExistsSql(String name, JdbcSchema schema)
+    protected String buildCreateTableIfNotExistsSql(TableIdentifier table, JdbcSchema schema)
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append("CREATE TABLE IF NOT EXISTS ");
-        quoteIdentifierString(sb, name);
+        quoteTableIdentifier(sb, table);
+        sb.append(buildCreateTableSchemaSql(schema));
+        return sb.toString();
+    }
+
+    public void createTable(TableIdentifier table, JdbcSchema schema) throws SQLException
+    {
+        Statement stmt = connection.createStatement();
+        try {
+            String sql = buildCreateTableSql(table, schema);
+            executeUpdate(stmt, sql);
+            commitIfNecessary(connection);
+        } catch (SQLException ex) {
+            throw safeRollback(connection, ex);
+        } finally {
+            stmt.close();
+        }
+    }
+
+    protected String buildCreateTableSql(TableIdentifier table, JdbcSchema schema)
+    {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("CREATE TABLE ");
+        quoteTableIdentifier(sb, table);
         sb.append(buildCreateTableSchemaSql(schema));
         return sb.toString();
     }
@@ -156,13 +187,13 @@ public class JdbcOutputConnection
         return sb.toString();
     }
 
-    protected String buildRenameTableSql(String fromTable, String toTable)
+    protected String buildRenameTableSql(TableIdentifier fromTable, TableIdentifier toTable)
     {
         StringBuilder sb = new StringBuilder();
         sb.append("ALTER TABLE ");
-        quoteIdentifierString(sb, fromTable);
+        quoteTableIdentifier(sb, fromTable);
         sb.append(" RENAME TO ");
-        quoteIdentifierString(sb, toTable);
+        quoteTableIdentifier(sb, toTable);
         return sb.toString();
     }
 
@@ -241,7 +272,7 @@ public class JdbcOutputConnection
         return ColumnDeclareType.SIMPLE;
     }
 
-    public PreparedStatement prepareBatchInsertStatement(String toTable, JdbcSchema toTableSchema, Optional<MergeConfig> mergeConfig) throws SQLException
+    public PreparedStatement prepareBatchInsertStatement(TableIdentifier toTable, JdbcSchema toTableSchema, Optional<MergeConfig> mergeConfig) throws SQLException
     {
         String sql;
         if (mergeConfig.isPresent()) {
@@ -253,12 +284,12 @@ public class JdbcOutputConnection
         return connection.prepareStatement(sql);
     }
 
-    protected String buildPreparedInsertSql(String toTable, JdbcSchema toTableSchema) throws SQLException
+    protected String buildPreparedInsertSql(TableIdentifier toTable, JdbcSchema toTableSchema) throws SQLException
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append("INSERT INTO ");
-        quoteIdentifierString(sb, toTable);
+        quoteTableIdentifier(sb, toTable);
 
         sb.append(" (");
         for (int i=0; i < toTableSchema.getCount(); i++) {
@@ -275,7 +306,7 @@ public class JdbcOutputConnection
         return sb.toString();
     }
 
-    protected String buildPreparedMergeSql(String toTable, JdbcSchema toTableSchema, MergeConfig mergeConfig) throws SQLException
+    protected String buildPreparedMergeSql(TableIdentifier toTable, JdbcSchema toTableSchema, MergeConfig mergeConfig) throws SQLException
     {
         throw new UnsupportedOperationException("not implemented");
     }
@@ -293,7 +324,7 @@ public class JdbcOutputConnection
         }
     }
 
-    protected void collectInsert(List<String> fromTables, JdbcSchema schema, String toTable,
+    protected void collectInsert(List<TableIdentifier> fromTables, JdbcSchema schema, TableIdentifier toTable,
             boolean truncateDestinationFirst, Optional<String> preSql, Optional<String> postSql) throws SQLException
     {
         if (fromTables.isEmpty()) {
@@ -326,22 +357,22 @@ public class JdbcOutputConnection
         }
     }
 
-    protected String buildTruncateSql(String table)
+    protected String buildTruncateSql(TableIdentifier table)
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append("DELETE FROM ");
-        quoteIdentifierString(sb, table);
+        quoteTableIdentifier(sb, table);
 
         return sb.toString();
     }
 
-    protected String buildCollectInsertSql(List<String> fromTables, JdbcSchema schema, String toTable)
+    protected String buildCollectInsertSql(List<TableIdentifier> fromTables, JdbcSchema schema, TableIdentifier toTable)
     {
         StringBuilder sb = new StringBuilder();
 
         sb.append("INSERT INTO ");
-        quoteIdentifierString(sb, toTable);
+        quoteTableIdentifier(sb, toTable);
         sb.append(" (");
         for (int i=0; i < schema.getCount(); i++) {
             if (i != 0) { sb.append(", "); }
@@ -356,13 +387,13 @@ public class JdbcOutputConnection
                 quoteIdentifierString(sb, schema.getColumnName(j));
             }
             sb.append(" FROM ");
-            quoteIdentifierString(sb, fromTables.get(i));
+            quoteTableIdentifier(sb, fromTables.get(i));
         }
 
         return sb.toString();
     }
 
-    protected void collectMerge(List<String> fromTables, JdbcSchema schema, String toTable, MergeConfig mergeConfig,
+    protected void collectMerge(List<TableIdentifier> fromTables, JdbcSchema schema, TableIdentifier toTable, MergeConfig mergeConfig,
             Optional<String> preSql, Optional<String> postSql) throws SQLException
     {
         if (fromTables.isEmpty()) {
@@ -390,12 +421,12 @@ public class JdbcOutputConnection
         }
     }
 
-    protected String buildCollectMergeSql(List<String> fromTables, JdbcSchema schema, String toTable, MergeConfig mergeConfig) throws SQLException
+    protected String buildCollectMergeSql(List<TableIdentifier> fromTables, JdbcSchema schema, TableIdentifier toTable, MergeConfig mergeConfig) throws SQLException
     {
         throw new UnsupportedOperationException("not implemented");
     }
 
-    public void replaceTable(String fromTable, JdbcSchema schema, String toTable, Optional<String> postSql) throws SQLException
+    public void replaceTable(TableIdentifier fromTable, JdbcSchema schema, TableIdentifier toTable, Optional<String> postSql) throws SQLException
     {
         Statement stmt = connection.createStatement();
         try {
@@ -415,9 +446,29 @@ public class JdbcOutputConnection
         }
     }
 
+    protected String quoteTableIdentifier(TableIdentifier table)
+    {
+        StringBuilder sb = new StringBuilder();
+        if (table.getDatabase() != null) {
+            sb.append(quoteIdentifierString(table.getDatabase(), identifierQuoteString));
+            sb.append(".");
+        }
+        if (table.getSchemaName() != null) {
+            sb.append(quoteIdentifierString(table.getSchemaName(), identifierQuoteString));
+            sb.append(".");
+        }
+        sb.append(quoteIdentifierString(table.getTableName(), identifierQuoteString));
+        return sb.toString();
+    }
+
+    protected void quoteTableIdentifier(StringBuilder sb, TableIdentifier table)
+    {
+        sb.append(quoteTableIdentifier(table));
+    }
+
     protected void quoteIdentifierString(StringBuilder sb, String str)
     {
-        sb.append(quoteIdentifierString(str, identifierQuoteString));
+        sb.append(quoteIdentifierString(str));
     }
 
     protected String quoteIdentifierString(String str)

data/src/main/java/org/embulk/output/jdbc/StandardBatchInsert.java

@@ -33,7 +33,7 @@ public class StandardBatchInsert
         this.mergeConfig = mergeConfig;
     }
 
-    public void prepare(String loadTable, JdbcSchema insertSchema) throws SQLException
+    public void prepare(TableIdentifier loadTable, JdbcSchema insertSchema) throws SQLException
     {
         this.connection = connector.connect(true);
         this.index = 1;  // PreparedStatement index begings from 1
@@ -43,7 +43,7 @@ public class StandardBatchInsert
         batch.clearBatch();
     }
 
-    protected PreparedStatement prepareStatement(String loadTable, JdbcSchema insertSchema) throws SQLException
+    protected PreparedStatement prepareStatement(TableIdentifier loadTable, JdbcSchema insertSchema) throws SQLException
     {
         return connection.prepareBatchInsertStatement(loadTable, insertSchema, mergeConfig);
     }

data/src/main/java/org/embulk/output/jdbc/TableIdentifier.java

@@ -0,0 +1,54 @@
+package org.embulk.output.jdbc;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+
+public class TableIdentifier
+{
+    private String database;
+    private String schemaName;
+    private String tableName;
+
+    public TableIdentifier(String database, String shcemaName, String tableName)
+    {
+        this.database = database;
+        this.schemaName = shcemaName;
+        this.tableName = tableName;
+    }
+
+    public TableIdentifier()
+    {
+    }
+
+    @JsonProperty
+    public String getDatabase() {
+        return database;
+    }
+
+    @JsonProperty
+    public void setDatabase(String database) {
+        this.database = database;
+    }
+
+    @JsonProperty
+    public String getSchemaName()
+    {
+        return schemaName;
+    }
+
+    @JsonProperty
+    public void setSchemaName(String schemaName)
+    {
+        this.schemaName = schemaName;
+    }
+
+    @JsonProperty
+    public String getTableName() {
+        return tableName;
+    }
+
+    @JsonProperty
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
+    }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embulk-output-jdbc
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-05-10 00:00:00.000000000 Z
+date: 2017-06-23 00:00:00.000000000 Z
 dependencies: []
 description: Inserts or updates records to a table.
 email:
@@ -19,7 +19,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - build.gradle
-- classpath/embulk-output-jdbc-0.7.8.jar
+- classpath/embulk-output-jdbc-0.7.9.jar
 - lib/embulk/output/jdbc.rb
 - src/main/java/org/embulk/output/JdbcOutputPlugin.java
 - src/main/java/org/embulk/output/jdbc/AbstractJdbcOutputPlugin.java
@@ -32,6 +32,7 @@ files:
 - src/main/java/org/embulk/output/jdbc/JdbcUtils.java
 - src/main/java/org/embulk/output/jdbc/MergeConfig.java
 - src/main/java/org/embulk/output/jdbc/StandardBatchInsert.java
+- src/main/java/org/embulk/output/jdbc/TableIdentifier.java
 - src/main/java/org/embulk/output/jdbc/TimestampFormat.java
 - src/main/java/org/embulk/output/jdbc/ToString.java
 - src/main/java/org/embulk/output/jdbc/ToStringMap.java