diff --git a/config/cubrid_tpcc_config.xml b/config/cubrid_tpcc_config.xml new file mode 100644 index 000000000..75284d7e5 --- /dev/null +++ b/config/cubrid_tpcc_config.xml @@ -0,0 +1,43 @@ + + + + + cubrid + cubrid.jdbc.driver.CUBRIDDriver + jdbc:cubrid:localhost:33000:tpcc:PUBLIC:: + + + TRANSACTION_READ_COMMITTED + + + 16 + + + 64 + + + + unlimited + 45,43,4,4,4 + + + + + + + NewOrder + + + Payment + + + OrderStatus + + + Delivery + + + StockLevel + + + diff --git a/config/cubrid_tpch_config.xml b/config/cubrid_tpch_config.xml new file mode 100644 index 000000000..3bb8461c5 --- /dev/null +++ b/config/cubrid_tpch_config.xml @@ -0,0 +1,147 @@ + + + + + cubrid + + cubrid.jdbc.driver.CUBRIDDriver + + jdbc:cubrid:127.0.0.1:33000:tpch:public:: + + + + + + TRANSACTION_READ_COMMITTED + + + data/tpch1 + + + + tbl + + + 20 + + + 1 + + + true + unlimited + all + + + true + unlimited + even + + + true + unlimited + odd + + + + + + + odd + 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0 + + + even + 0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1 + + + + Q1 + 1 + + + Q2 + 2 + + + Q3 + 3 + + + Q4 + 4 + + + Q5 + 5 + + + Q6 + 6 + + + Q7 + 7 + + + Q8 + 8 + + + Q9 + 9 + + + Q10 + 10 + + + Q11 + 11 + + + Q12 + 12 + + + Q13 + 13 + + + Q14 + 14 + + + Q15 + 15 + + + Q16 + 16 + + + Q17 + 17 + + + Q18 + 18 + + + Q19 + 19 + + + Q20 + 20 + + + Q21 + 21 + + + Q22 + 22 + + + diff --git a/config/cubrid_wikipedia_config.xml b/config/cubrid_wikipedia_config.xml new file mode 100644 index 000000000..e8f1157ac --- /dev/null +++ b/config/cubrid_wikipedia_config.xml @@ -0,0 +1,95 @@ + + + + + + + + + cubrid + + cubrid.jdbc.driver.CUBRIDDriver + + jdbc:cubrid:127.0.0.1:33000:wikipedia:public:: + + + + + + TRANSACTION_READ_COMMITTED + + + + + + 1 + + + + + + config/traces/wikipedia-100k.trace + + 10 + + 10.1. + + + + + + 64 + + + + + + + + unlimited + + 0.07,0.07,7.6725,91.2656,0.9219 + + + + + + + + + + + + + + AddWatchList + + + + + + RemoveWatchList + + + + + + UpdatePage + + + + + + GetPageAnonymous + + + + + + GetPageAuthenticated + + + + + + diff --git a/lib/JDBC-10.1.0.7663-cubrid.jar b/lib/JDBC-10.1.0.7663-cubrid.jar new file mode 100644 index 000000000..ebcdbe024 Binary files /dev/null and b/lib/JDBC-10.1.0.7663-cubrid.jar differ diff --git a/src/com/oltpbenchmark/api/Procedure.java b/src/com/oltpbenchmark/api/Procedure.java index 615846ba5..878c2fa17 100644 --- a/src/com/oltpbenchmark/api/Procedure.java +++ b/src/com/oltpbenchmark/api/Procedure.java @@ -133,7 +133,12 @@ public final PreparedStatement getPreparedStatementReturnKeys(Connection conn, S } // Everyone else can use the regular getGeneratedKeys() method else if (is != null) { - pStmt = conn.prepareStatement(stmt.getSQL(), is); + if (getDatabaseType() == DatabaseType.CUBRID) { + // Required by cubrid jdbc to add an integer parameter in prepareStatement method. + pStmt = conn.prepareStatement(stmt.getSQL(), pStmt.RETURN_GENERATED_KEYS); + } else { + pStmt = conn.prepareStatement(stmt.getSQL(), is); + } } // They don't care about keys else { diff --git a/src/com/oltpbenchmark/benchmarks/wikipedia/WikipediaLoader.java b/src/com/oltpbenchmark/benchmarks/wikipedia/WikipediaLoader.java index 38f48f527..e1e0790cc 100644 --- a/src/com/oltpbenchmark/benchmarks/wikipedia/WikipediaLoader.java +++ b/src/com/oltpbenchmark/benchmarks/wikipedia/WikipediaLoader.java @@ -181,7 +181,16 @@ private void loadUsers() throws SQLException { if(this.getDatabaseType() == DatabaseType.ORACLE) { // Oracle handles quoted object identifiers differently, do not escape names sql = SQLUtil.getInsertSQL(catalog_tbl, false); + } else if(this.getDatabaseType() == DatabaseType.CUBRID) { + // In table , the primary key set 'auto_increment'. When manually inserting records, + // we skip this field so the Cubrid can take care of the auto_increment property. This is because + // Cubrid does not update the starting value of the auto_increment field when we manually insert + // a value. This will cause unique constraint violation on the primary key when we loading + // data again in the UpdatePage procedure. + // The params means for the insert sql, skip the first column and include the column name. + sql = SQLUtil.getInsertSQL(catalog_tbl, true, false, 1, 0); } + PreparedStatement userInsert = this.conn.prepareStatement(sql); FlatHistogram h_nameLength = new FlatHistogram(this.rng(), UserHistograms.NAME_LENGTH); @@ -210,7 +219,10 @@ private void loadUsers() throws SQLException { String touched = TimeUtil.getCurrentTimeString14(); int param = 1; - userInsert.setInt(param++, i); // user_id + if (this.getDatabaseType() != DatabaseType.CUBRID) { + // Skip the auto_increment field. + userInsert.setInt(param++, i); // user_id + } userInsert.setString(param++, name); // user_name userInsert.setString(param++, realName); // user_real_name userInsert.setString(param++, password); // user_password @@ -265,7 +277,11 @@ private void loadPages() throws SQLException { if (this.getDatabaseType() == DatabaseType.ORACLE) { // Oracle handles quoted object identifiers differently, do not escape names sql = SQLUtil.getInsertSQL(catalog_tbl, false); + } else if(this.getDatabaseType() == DatabaseType.CUBRID) { + // Include the column names and skip the page_id field in the insert query. + sql = SQLUtil.getInsertSQL(catalog_tbl, true, false, 1, 0); } + PreparedStatement pageInsert = this.conn.prepareStatement(sql); FlatHistogram h_titleLength = new FlatHistogram(this.rng(), PageHistograms.TITLE_LENGTH); @@ -286,7 +302,10 @@ private void loadPages() throws SQLException { String pageTouched = TimeUtil.getCurrentTimeString14(); int param = 1; - pageInsert.setInt(param++, i); // page_id + if (this.getDatabaseType() != DatabaseType.CUBRID) { + // Skip the page_id field. Cubrid will auto increment it. + pageInsert.setInt(param++, i); // page_id + } pageInsert.setInt(param++, namespace); // page_namespace pageInsert.setString(param++, title); // page_title pageInsert.setString(param++, restrictions);// page_restrictions @@ -420,6 +439,9 @@ private void loadRevision() throws SQLException { if (this.getDatabaseType() == DatabaseType.ORACLE) { // Oracle handles quoted object identifiers differently, do not escape names textSQL = SQLUtil.getInsertSQL(textTable, false); + } else if (this.getDatabaseType() == DatabaseType.CUBRID) { + // Include the column names and skip the old_id field in the insert query. + textSQL = SQLUtil.getInsertSQL(textTable, true, false, 1, 0); } PreparedStatement textInsert = this.conn.prepareStatement(textSQL); @@ -429,6 +451,9 @@ private void loadRevision() throws SQLException { if (this.getDatabaseType() == DatabaseType.ORACLE) { // Oracle handles quoted object identifiers differently, do not escape names revSQL = SQLUtil.getInsertSQL(revTable, false); + } else if (this.getDatabaseType() == DatabaseType.CUBRID) { + // Include the column names and skip the rev-id field in the insert query. + revSQL = SQLUtil.getInsertSQL(revTable, true, false, 1, 0); } PreparedStatement revisionInsert = this.conn.prepareStatement(revSQL); @@ -477,7 +502,13 @@ private void loadRevision() throws SQLException { // Insert the text int col = 1; - textInsert.setInt(col++, rev_id); // old_id + if (this.getDatabaseType() != DatabaseType.CUBRID) { + // Old_id is a primary key and is auto_incremented. Skip this field here so Cubrid will + // automatically set it. Cubrid does not update the intial value of the auto_increment field. + // Thus, if we manually set the value here, when we load data again in the UpdatePage, it may + // cause unique key constraint violation. + textInsert.setInt(col++, rev_id); // old_id + } textInsert.setString(col++, new String(old_text)); // old_text textInsert.setString(col++, "utf-8"); // old_flags textInsert.setInt(col++, page_id); // old_page @@ -485,7 +516,10 @@ private void loadRevision() throws SQLException { // Insert the revision col = 1; - revisionInsert.setInt(col++, rev_id); // rev_id + if (this.getDatabaseType() != DatabaseType.CUBRID) { + // skip the rev_id field. Cubrid will auto increment it. + revisionInsert.setInt(col++, rev_id); // rev_id + } revisionInsert.setInt(col++, page_id); // rev_page revisionInsert.setInt(col++, rev_id); // rev_text_id revisionInsert.setString(col++, rev_comment); // rev_comment @@ -533,7 +567,6 @@ private void loadRevision() throws SQLException { this.updateAutoIncrement(textTable.getColumn(0), rev_id); this.updateAutoIncrement(revTable.getColumn(0), rev_id); } - // UPDATE USER revTable = this.benchmark.getTableCatalog(WikipediaConstants.TABLENAME_USER); @@ -609,3 +642,4 @@ private void loadRevision() throws SQLException { } } } + diff --git a/src/com/oltpbenchmark/benchmarks/wikipedia/ddls/wikipedia-cubrid-ddl.sql b/src/com/oltpbenchmark/benchmarks/wikipedia/ddls/wikipedia-cubrid-ddl.sql new file mode 100644 index 000000000..e8e40648d --- /dev/null +++ b/src/com/oltpbenchmark/benchmarks/wikipedia/ddls/wikipedia-cubrid-ddl.sql @@ -0,0 +1,229 @@ +-- TODO: ipb_id auto_increment +--DROP TABLE "ipblocks"; +CREATE TABLE "ipblocks" ( + ipb_id int NOT NULL AUTO_INCREMENT, + ipb_address varchar(1024) NOT NULL, + ipb_user int NOT NULL, + ipb_by int NOT NULL, + ipb_by_text varchar(255) NOT NULL, + ipb_reason varchar(1024) NOT NULL, + ipb_timestamp varchar(14) NOT NULL, + ipb_auto SMALLINT NOT NULL, + ipb_anon_only SMALLINT NOT NULL, + ipb_create_account SMALLINT NOT NULL , + ipb_enable_autoblock SMALLINT NOT NULL , + ipb_expiry varchar(14) NOT NULL, + ipb_range_start varchar(255) NOT NULL, + ipb_range_end varchar(255) NOT NULL, + ipb_deleted SMALLINT NOT NULL , + ipb_block_email SMALLINT NOT NULL , + ipb_allow_usertalk SMALLINT NOT NULL , + PRIMARY KEY (ipb_id), + UNIQUE (ipb_address,ipb_user,ipb_auto,ipb_anon_only) +); + +CREATE INDEX IDX_IPB_USER ON "ipblocks" (ipb_user); +CREATE INDEX IDX_IPB_RANGE ON "ipblocks" (ipb_range_start,ipb_range_end); +CREATE INDEX IDX_IPB_TIMESTAMP ON "ipblocks" (ipb_timestamp); +CREATE INDEX IDX_IPB_EXPIRY ON "ipblocks" (ipb_expiry); + +-- TOOD: user_id auto_increment +--DROP TABLE "useracct"; +CREATE TABLE "useracct" ( + user_id int NOT NULL AUTO_INCREMENT, + user_name varchar(255) NOT NULL, + user_real_name varchar(255) NOT NULL, + user_password varchar(1024) NOT NULL, + user_newpassword varchar(1024) NOT NULL, + user_newpass_time varchar(14) DEFAULT NULL, + user_email varchar(1024) NOT NULL, + user_options varchar(1024) NOT NULL, + user_touched varchar(14) NOT NULL, + user_token char(32) NOT NULL, + user_email_authenticated char(14) DEFAULT NULL, + user_email_token char(32) DEFAULT NULL, + user_email_token_expires char(14) DEFAULT NULL, + user_registration varchar(14) DEFAULT NULL, + user_editcount int DEFAULT NULL, + PRIMARY KEY (user_id), + UNIQUE (user_name) +); +CREATE INDEX IDX_USER_EMAIL_TOKEN ON "useracct" (user_email_token); + +-- TODO: log_id auto_increment +--DROP TABLE "logging"; +CREATE TABLE "logging" ( + log_id int NOT NULL AUTO_INCREMENT, + log_type varchar(32) NOT NULL, + log_action varchar(32) NOT NULL, + log_timestamp varchar(14) NOT NULL, + log_user int NOT NULL, + log_namespace int NOT NULL, + log_title varchar(255) NOT NULL, + log_comment varchar(255) NOT NULL, + log_params varchar(1024) NOT NULL, + log_deleted SMALLINT NOT NULL DEFAULT '0', + log_user_text varchar(255) NOT NULL, + log_page int DEFAULT NULL, + PRIMARY KEY (log_id) +); +CREATE INDEX IDX_LOG_TYPE_TIME ON "logging" (log_type,log_timestamp); +CREATE INDEX IDX_LOG_USER_TIME ON "logging" (log_user,log_timestamp); +CREATE INDEX IDX_LOG_PAGE_TIME ON "logging" (log_namespace,log_title,log_timestamp); +CREATE INDEX IDX_LOG_TIMES ON "logging" (log_timestamp); +CREATE INDEX IDX_LOG_USER_TYPE_TIME ON "logging" (log_user,log_type,log_timestamp); +CREATE INDEX IDX_LOG_PAGE_ID_TIME ON "logging" (log_page,log_timestamp); + +-- TODO: page_id auto_increment +--DROP TABLE "page"; +CREATE TABLE "page" ( + page_id int NOT NULL AUTO_INCREMENT, + page_namespace int NOT NULL, + page_title varchar(1024) NOT NULL, + page_restrictions varchar(1024) NULL, + page_counter bigint NOT NULL, + page_is_redirect SMALLINT NOT NULL, + page_is_new SMALLINT NOT NULL, + page_random double NOT NULL, + page_touched varchar(14) NOT NULL, + page_latest int NOT NULL, + page_len int NOT NULL, + PRIMARY KEY (page_id), + UNIQUE (page_namespace,page_title) +); +CREATE INDEX IDX_PAGE_RANDOM ON "page" (page_random); +CREATE INDEX IDX_PAGE_LEN ON "page" (page_len); + +-- TODO: page_id auto_increment +--DROP TABLE "page_backup"; +CREATE TABLE "page_backup" ( + page_id int NOT NULL AUTO_INCREMENT, + page_namespace int NOT NULL, + page_title varchar(1024) NOT NULL, + page_restrictions varchar(1024) NULL, + page_counter bigint NOT NULL, + page_is_redirect SMALLINT NOT NULL, + page_is_new SMALLINT NOT NULL, + page_random double NOT NULL, + page_touched varchar(14) NOT NULL, + page_latest int NOT NULL, + page_len int NOT NULL, + PRIMARY KEY (page_id), + UNIQUE (page_namespace,page_title) +); +CREATE INDEX IDX_page_backup_RANDOM ON "page_backup" (page_random); +CREATE INDEX IDX_page_backup_LEN ON "page_backup" (page_len); + +--DROP TABLE "page_restrictions"; +CREATE TABLE "page_restrictions" ( + pr_page int NOT NULL, + pr_type varchar(60) NOT NULL, + pr_level varchar(60) NOT NULL, + pr_cascade SMALLINT NOT NULL, + pr_user int DEFAULT NULL, + pr_expiry varchar(14) DEFAULT NULL, + pr_id int NOT NULL AUTO_INCREMENT, + PRIMARY KEY (pr_id), + UNIQUE (pr_page,pr_type) +); +CREATE INDEX IDX_PR_TYPELEVEL ON "page_restrictions" (pr_type,pr_level); +CREATE INDEX IDX_PR_LEVEL ON "page_restrictions" (pr_level); +CREATE INDEX IDX_PR_CASCADE ON "page_restrictions" (pr_cascade); + +-- TOOD: rc_id auto_increment +--DROP TABLE "recentchanges"; +CREATE TABLE "recentchanges" ( + rc_id int NOT NULL AUTO_INCREMENT, + rc_timestamp varchar(14) NOT NULL, + rc_cur_time varchar(14) NOT NULL, + rc_user int NOT NULL, + rc_user_text varchar(255) NOT NULL, + rc_namespace int NOT NULL, + rc_title varchar(255) NOT NULL, + rc_comment varchar(255) NOT NULL, + rc_minor SMALLINT NOT NULL, + rc_bot SMALLINT NOT NULL, + rc_new SMALLINT NOT NULL DEFAULT '0', + rc_cur_id int NOT NULL, + rc_this_oldid int NOT NULL, + rc_last_oldid int NOT NULL, + rc_type SMALLINT NOT NULL, + rc_moved_to_ns SMALLINT NOT NULL, + rc_moved_to_title varchar(255) NOT NULL, + rc_patrolled SMALLINT NOT NULL DEFAULT '0', + rc_ip varchar(40) NOT NULL, + rc_old_len int DEFAULT NULL, + rc_new_len int DEFAULT NULL, + rc_deleted SMALLINT NOT NULL DEFAULT '0', + rc_logid int NOT NULL DEFAULT '0', + rc_log_type varchar(255) DEFAULT NULL, + rc_log_action varchar(255) DEFAULT NULL, + rc_params varchar(1024), + PRIMARY KEY (rc_id) +); +CREATE INDEX IDX_RC_TIMESTAMP ON "recentchanges" (rc_timestamp); +CREATE INDEX IDX_RC_NAMESPACE_TITLE ON "recentchanges" (rc_namespace,rc_title); +CREATE INDEX IDX_RC_CUR_ID ON "recentchanges" (rc_cur_id); +CREATE INDEX IDX_NEW_NAME_TIMESTAMP ON "recentchanges" (rc_new,rc_namespace,rc_timestamp); +CREATE INDEX IDX_RC_IP ON "recentchanges" (rc_ip); +CREATE INDEX IDX_RC_NS_USERTEXT ON "recentchanges" (rc_namespace,rc_user_text); +CREATE INDEX IDX_RC_USER_TEXT ON "recentchanges" (rc_user_text,rc_timestamp); + +-- TODO: rev_id auto_increment +--DROP TABLE "revision"; +CREATE TABLE "revision" ( + rev_id int NOT NULL AUTO_INCREMENT, + rev_page int NOT NULL, + rev_text_id int NOT NULL, + rev_comment varchar(1024) NOT NULL, + rev_user int NOT NULL, + rev_user_text varchar(255) NOT NULL, + rev_timestamp varchar(14) NOT NULL, + rev_minor_edit SMALLINT NOT NULL, + rev_deleted SMALLINT NOT NULL, + rev_len int DEFAULT NULL, + rev_parent_id int DEFAULT NULL, + PRIMARY KEY (rev_id), + UNIQUE (rev_page,rev_id) +); +CREATE INDEX IDX_REV_TIMESTAMP ON "revision" (rev_timestamp); +CREATE INDEX IDX_PAGE_TIMESTAMP ON "revision" (rev_page,rev_timestamp); +CREATE INDEX IDX_USER_TIMESTAMP ON "revision" (rev_user,rev_timestamp); +CREATE INDEX IDX_USERTEXT_TIMESTAMP ON "revision" (rev_user_text,rev_timestamp); + +-- TODO old_id auto_increment +--DROP TABLE "text"; +CREATE TABLE "text" ( + old_id int NOT NULL AUTO_INCREMENT, + old_text varchar(1048576) NOT NULL, + old_flags varchar(1024) NOT NULL, + old_page int DEFAULT NULL, + PRIMARY KEY (old_id) +); + +--DROP TABLE "user_groups"; +CREATE TABLE "user_groups" ( + ug_user int NOT NULL REFERENCES "useracct" (user_id), + ug_group varchar(16) NOT NULL, + UNIQUE (ug_user,ug_group) +); +CREATE INDEX IDX_UG_GROUP ON "user_groups" (ug_user); + +--DROP TABLE "value_backup"; +CREATE TABLE "value_backup" ( + table_name varchar(255) DEFAULT NULL, + maxid int DEFAULT NULL +); + +--DROP TABLE "watchlist"; +CREATE TABLE "watchlist" ( + wl_user int NOT NULL, + wl_namespace int NOT NULL, + wl_title varchar(255) NOT NULL, + wl_notificationtimestamp varchar(14) DEFAULT NULL, + UNIQUE (wl_user,wl_namespace,wl_title) +); +CREATE INDEX IDX_WL_NAMESPACE_TITLE ON "watchlist" (wl_namespace, wl_title); + + + diff --git a/src/com/oltpbenchmark/benchmarks/wikipedia/procedures/UpdatePage.java b/src/com/oltpbenchmark/benchmarks/wikipedia/procedures/UpdatePage.java index ca19e2aa1..937f98433 100644 --- a/src/com/oltpbenchmark/benchmarks/wikipedia/procedures/UpdatePage.java +++ b/src/com/oltpbenchmark/benchmarks/wikipedia/procedures/UpdatePage.java @@ -247,13 +247,13 @@ public void run(Connection conn, int textId, int pageId, conn.commit(); ps = this.getPreparedStatement(conn, updateWatchList); - param = 1; - ps.setString(param++, timestamp); - ps.setString(param++, pageTitle); - ps.setInt(param++, pageNamespace); for (Integer otherUserId : wlUser) { - ps.setInt(param, otherUserId.intValue()); - ps.addBatch(); + param = 1; + ps.setString(param++, timestamp); + ps.setString(param++, pageTitle); + ps.setInt(param++, pageNamespace); + ps.setInt(param, otherUserId.intValue()); + ps.addBatch(); } // FOR // ps.executeUpdate(); // This is an error // ps.executeBatch(); @@ -342,3 +342,4 @@ public void executeBatch(Connection conn, PreparedStatement p) throws SQLExcepti } + diff --git a/src/com/oltpbenchmark/types/DatabaseType.java b/src/com/oltpbenchmark/types/DatabaseType.java index c1395b48c..482f35eb1 100644 --- a/src/com/oltpbenchmark/types/DatabaseType.java +++ b/src/com/oltpbenchmark/types/DatabaseType.java @@ -48,7 +48,8 @@ public enum DatabaseType { MONETDB("nl.cwi.monetdb.jdbc.MonetDriver", false, false), NUODB("com.nuodb.jdbc.Driver", true, false), TIMESTEN("com.timesten.jdbc.TimesTenDriver", true, false), - PELOTON("org.postgresql.Driver", false, false) + PELOTON("org.postgresql.Driver", false, false), + CUBRID("cubrid.jdbc.driver.CUBRIDDriver", false, false) ; private DatabaseType(String driver, boolean escapeNames, boolean includeColNames) { diff --git a/src/com/oltpbenchmark/util/SQLUtil.java b/src/com/oltpbenchmark/util/SQLUtil.java index b42cc126c..52f781d6c 100644 --- a/src/com/oltpbenchmark/util/SQLUtil.java +++ b/src/com/oltpbenchmark/util/SQLUtil.java @@ -380,45 +380,45 @@ public static String getInsertSQL(Table catalog_tbl, boolean show_cols, int batc * @return */ public static String getInsertSQL(Table catalog_tbl, boolean show_cols, boolean escape_names, int batchSize, int...exclude_columns) { - StringBuilder sb = new StringBuilder(); - sb.append("INSERT INTO ") - .append(escape_names ? catalog_tbl.getEscapedName() : catalog_tbl.getName()); - - StringBuilder values = new StringBuilder(); - boolean first; - - // Column Names - // XXX: Disabled because of case issues with HSQLDB - if (show_cols) sb.append(" ("); - first = true; - - // These are the column offset that we want to exclude - Set excluded = new HashSet(); - for (int ex : exclude_columns) - excluded.add(ex); - - for (Column catalog_col : catalog_tbl.getColumns()) { - if (excluded.contains(catalog_col.getIndex())) continue; - if (first == false) { - if (show_cols) sb.append(", "); - values.append(", "); - } - if (show_cols) sb.append(escape_names ? catalog_col.getEscapedName() : catalog_col.getName()); - values.append("?"); - first = false; - } // FOR - if (show_cols) sb.append(")"); - - // Values - sb.append(" VALUES "); - first = true; - for (int i = 0; i < batchSize; i++) { - if (first == false) sb.append(", "); - sb.append("(").append(values.toString()).append(")"); - } // FOR -// sb.append(";"); - - return (sb.toString()); + StringBuilder sb = new StringBuilder(); + sb.append("INSERT INTO ") + .append(escape_names ? catalog_tbl.getEscapedName() : catalog_tbl.getName()); + + StringBuilder values = new StringBuilder(); + boolean first; + + // Column Names + // XXX: Disabled because of case issues with HSQLDB + if (show_cols) sb.append(" ("); + first = true; + + // These are the column offset that we want to exclude + Set excluded = new HashSet(); + for (int ex : exclude_columns) + excluded.add(ex); + + for (Column catalog_col : catalog_tbl.getColumns()) { + if (excluded.contains(catalog_col.getIndex())) continue; + if (first == false) { + if (show_cols) sb.append(", "); + values.append(", "); + } + if (show_cols) sb.append(escape_names ? catalog_col.getEscapedName() : catalog_col.getName()); + values.append("?"); + first = false; + } // FOR + if (show_cols) sb.append(")"); + + // Values + sb.append(" VALUES "); + first = true; + for (int i = 0; i < batchSize; i++) { + if (first == false) sb.append(", "); + sb.append("(").append(values.toString()).append(")"); + } // FOR +// sb.append(";"); + + return (sb.toString()); } public static String getMaxColSQL(DatabaseType dbType, Table catalog_tbl, String col) { @@ -430,4 +430,4 @@ public static String selectColValues(DatabaseType dbType, Table catalog_tbl, Str return String.format("SELECT %s FROM %s", col, catalog_tbl.getEscapedName()); } -} \ No newline at end of file +}