Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(sql-file): batch Oracle inserts as INSERT ALL

HARRISON970f9bbf1195
diff --git a/crates/dbx-core/src/data/sql_file_import.rs b/crates/dbx-core/src/data/sql_file_import.rs
index 13c38f3e5b..dfcd12b919 100644
--- a/crates/dbx-core/src/data/sql_file_import.rs
+++ b/crates/dbx-core/src/data/sql_file_import.rs
@@ -2860,6 +2860,14 @@ async fn execute_statement_with_progress(
}
Err(error) => {
if statement.source_statement_count > 1 && !token.is_cancelled() {
+ // A merged batch is an optimization, never a contract: replay the
+ // source statements one by one. Log it because the replay is
+ // orders of magnitude slower and would otherwise be invisible.
+ log::warn!(
+ "[sql_file_import] merged statement ({} source statements, {} bytes) failed, replaying individually: {error}",
+ statement.source_statement_count,
+ statement.sql.len()
+ );
return execute_merged_statement_fallback_with_progress(
state,
request,
@@ -4281,6 +4289,30 @@ mod tests {
assert_eq!(planned[2].kind, SqlFileImportStatementKind::Skip);
}
+ #[test]
+ fn oceanbase_oracle_insert_file_plans_one_insert_all_batch() {
+ let statements = split_sql_file_import_statements_with_control(
+ "INSERT INTO T (ID) VALUES (1);\nINSERT INTO T (ID) VALUES (2);\n",
+ Some(DatabaseType::OceanbaseOracle),
+ None,
+ );
+
+ let planned = plan_sql_file_statements(&statements, Some(DatabaseType::OceanbaseOracle), None, false, None);
+
+ assert_eq!(planned.len(), 1);
+ assert_eq!(planned[0].statement.source_statement_count, 2);
+ assert_eq!(
+ planned[0].statement.sql,
+ "INSERT ALL\nINTO T (ID) VALUES (1)\nINTO T (ID) VALUES (2)\nSELECT 1 FROM dual"
+ );
+
+ // A manual transaction must keep every source statement on its own error
+ // boundary, so it never merges.
+ let manual = plan_sql_file_statements(&statements, Some(DatabaseType::OceanbaseOracle), None, true, None);
+ assert_eq!(manual.len(), 2);
+ assert_eq!(manual[0].statement.sql, "INSERT INTO T (ID) VALUES (1)");
+ }
+
#[test]
fn stop_on_error_returns_err_with_terminal_error_progress() {
let decision = statement_error_decision(
diff --git a/crates/dbx-sql-core/src/sql.rs b/crates/dbx-sql-core/src/sql.rs
index 3a9e6903e9..316d9fe40d 100644
--- a/crates/dbx-sql-core/src/sql.rs
+++ b/crates/dbx-sql-core/src/sql.rs
@@ -2656,6 +2656,7 @@ pub fn optimize_sql_file_import_statements_with_max_insert_batch_statements(
let mut pending_insert: Option<PendingInsertBatch> = None;
let merge_adjacent_inserts =
db_type.as_ref().is_none_or(|db_type| !is_mysql_compatible_import_target(db_type, driver_profile));
+ let insert_batch_syntax = insert_batch_syntax(db_type.as_ref());
for statement in statements {
let action = db_type
@@ -2688,10 +2689,10 @@ pub fn optimize_sql_file_import_statements_with_max_insert_batch_statements(
Some(batch) if batch.can_accept(&insert, max_insert_batch_statements) => batch.push(insert),
Some(_) => {
flush_pending_insert(&mut optimized, &mut pending_insert);
- pending_insert = Some(PendingInsertBatch::new(insert));
+ pending_insert = Some(PendingInsertBatch::new(insert, insert_batch_syntax));
}
None => {
- pending_insert = Some(PendingInsertBatch::new(insert));
+ pending_insert = Some(PendingInsertBatch::new(insert, insert_batch_syntax));
}
}
} else {
@@ -2725,6 +2726,23 @@ fn flush_pending_insert(optimized: &mut Vec<SqlFileImportStatement>, pending_ins
const SQL_FILE_INSERT_BATCH_MAX_STATEMENTS: usize = 500;
const SQL_FILE_INSERT_BATCH_MAX_BYTES: usize = 4 * 1024 * 1024;
+/// How a merged insert batch must be spelled for its target dialect.
+///
+/// Oracle-family servers reject the MySQL multi-row `VALUES (…), (…)` form, so
+/// merging there has to produce `INSERT ALL … SELECT 1 FROM dual` instead.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum InsertBatchSyntax {
+ MultiRowValues,
+ OracleInsertAll,
+}
+
+fn insert_batch_syntax(db_type: Option<&DatabaseType>) -> InsertBatchSyntax {
+ match db_type {
+ Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle) => InsertBatchSyntax::OracleInsertAll,
+ _ => InsertBatchSyntax::MultiRowValues,
+ }
+}
+
#[derive(Debug, Clone)]
struct MergeableInsert {
prefix: String,
@@ -2741,12 +2759,14 @@ struct PendingInsertBatch {
source_sqls: Vec<String>,
source_statement_count: usize,
byte_len: usize,
+ syntax: InsertBatchSyntax,
}
impl PendingInsertBatch {
- fn new(insert: MergeableInsert) -> Self {
+ fn new(insert: MergeableInsert, syntax: InsertBatchSyntax) -> Self {
let byte_len = insert.prefix.len() + insert.values.len() + 16;
Self {
+ syntax,
prefix: insert.prefix,
prefix_key: insert.prefix_key,
values: vec![insert.values],
@@ -2773,10 +2793,49 @@ impl PendingInsertBatch {
if self.source_statement_count == 1 {
return self.source_sqls.first().cloned().unwrap_or_default();
}
+ if self.syntax == InsertBatchSyntax::OracleInsertAll {
+ if let Some(target) = oracle_insert_all_target(&self.prefix) {
+ let mut sql = String::with_capacity(
+ self.byte_len + "INSERT ALL\n".len() + "SELECT 1 FROM dual".len() + target.len() + 14,
+ );
+ sql.push_str("INSERT ALL\n");
+ for values in &self.values {
+ sql.push_str("INTO ");
+ sql.push_str(target);
+ sql.push_str(" VALUES ");
+ sql.push_str(values);
+ sql.push('\n');
+ }
+ sql.push_str("SELECT 1 FROM dual");
+ return sql;
+ }
+ }
format!("{} VALUES\n{}", self.prefix, self.values.join(",\n"))
}
}
+/// The `table (columns)` part of `INSERT INTO table (columns) VALUES …`, used
+/// as the repeated `INTO` clause of an `INSERT ALL` batch.
+fn oracle_insert_all_target(prefix: &str) -> Option<&str> {
+ let mut scanner = SqlScanner::default();
+ let mut seen_insert = false;
+ for (idx, ch) in prefix.char_indices() {
+ scanner.step(prefix, idx, ch);
+ if scanner.is_masked() {
+ continue;
+ }
+ if !seen_insert {
+ seen_insert = keyword_at(prefix, idx, "insert");
+ continue;
+ }
+ if keyword_at(prefix, idx, "into") {
+ let target = prefix[idx + "into".len()..].trim();
+ return (!target.is_empty()).then_some(target);
+ }
+ }
+ None
+}
+
fn parse_mergeable_insert(sql: &str, options: SqlParsingOptions) -> Option<MergeableInsert> {
let executable = leading_executable_sql_with_options(sql, options).trim().trim_end_matches(';').trim();
if !starts_with_keyword(executable, "insert") {
@@ -5144,6 +5203,39 @@ mod tests {
assert_eq!(optimized[1].sql, "SELECT 1");
}
+ #[test]
+ fn optimizes_adjacent_oracle_family_inserts_into_insert_all() {
+ let statements = vec![
+ "Insert into SYS_QUESTION (ID, NAME) values ('001', '市场监管')".to_string(),
+ "Insert into SYS_QUESTION (ID, NAME) values ('002', '网络交易')".to_string(),
+ ];
+
+ for db_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
+ let optimized = optimize_sql_file_import_statements(&statements, Some(db_type), None);
+
+ assert_eq!(optimized.len(), 1, "{db_type:?}");
+ assert_eq!(optimized[0].source_statement_count, 2, "{db_type:?}");
+ assert_eq!(
+ optimized[0].sql,
+ "INSERT ALL\n\
+ INTO SYS_QUESTION (ID, NAME) VALUES ('001', '市场监管')\n\
+ INTO SYS_QUESTION (ID, NAME) VALUES ('002', '网络交易')\n\
+ SELECT 1 FROM dual",
+ "{db_type:?}"
+ );
+ }
+ }
+
+ #[test]
+ fn keeps_single_oracle_insert_as_written() {
+ let statements = vec!["INSERT INTO users (id) VALUES (1)".to_string()];
+
+ let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::OceanbaseOracle), None);
+
+ assert_eq!(optimized.len(), 1);
+ assert_eq!(optimized[0].sql, statements[0]);
+ }
+
#[test]
fn keeps_mysql_insert_statements_separate_to_preserve_session_semantics() {
let statements = vec![