From 8e92254bbaacd3fce5287a5d6b9383790d494e08 Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Wed, 3 Jun 2026 18:14:33 +0800 Subject: [PATCH] fix(sqlserver): preserve procedure DDL batches --- crates/dbx-core/src/object_source_sql.rs | 26 ++++- crates/dbx-core/src/sql.rs | 139 ++++++++++++++++++++--- 2 files changed, 147 insertions(+), 18 deletions(-) diff --git a/crates/dbx-core/src/object_source_sql.rs b/crates/dbx-core/src/object_source_sql.rs index 4c36a69cdb..b3cecf3c2e 100644 --- a/crates/dbx-core/src/object_source_sql.rs +++ b/crates/dbx-core/src/object_source_sql.rs @@ -122,7 +122,7 @@ pub fn build_routine_rename_object_source_statements( pub fn build_executable_object_source_statements(input: EditableObjectSourceSqlInput) -> Result, String> { let source = input.source.trim(); if input.database_type == DatabaseType::SqlServer { - return Ok(vec![replace_sqlserver_create_with_alter(source)]); + return Ok(vec![replace_sqlserver_create_with_create_or_alter(source)]); } if matches!(input.database_type, DatabaseType::Postgres | DatabaseType::Gaussdb | DatabaseType::OpenGauss) @@ -367,8 +367,11 @@ fn routine_name_changed(source_name: &str, saved_name: &str) -> bool { !source_name.eq_ignore_ascii_case(saved_name) } -fn replace_sqlserver_create_with_alter(source: &str) -> String { - Regex::new(r"(?i)^CREATE\s+(?:OR\s+ALTER\s+)?").unwrap().replace(source, "ALTER ").to_string() +fn replace_sqlserver_create_with_create_or_alter(source: &str) -> String { + Regex::new(r"(?i)^(?:CREATE\s+(?:OR\s+ALTER\s+)?|ALTER\s+)") + .unwrap() + .replace(source, "CREATE OR ALTER ") + .to_string() } fn parse_object_source_kind(value: &str) -> Option { @@ -402,7 +405,7 @@ mod tests { } #[test] - fn sqlserver_edited_source_saves_as_alter() { + fn sqlserver_edited_source_saves_as_create_or_alter() { let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput { database_type: DatabaseType::SqlServer, object_type: ObjectSourceKind::Procedure, @@ -411,7 +414,20 @@ mod tests { source: "CREATE PROCEDURE dbo.usp_demo AS SELECT 1;".to_string(), }) .unwrap(); - assert_eq!(sql, "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;"); + assert_eq!(sql, "CREATE OR ALTER PROCEDURE dbo.usp_demo AS SELECT 1;"); + } + + #[test] + fn sqlserver_alter_source_saves_as_create_or_alter() { + let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput { + database_type: DatabaseType::SqlServer, + object_type: ObjectSourceKind::Procedure, + schema: Some("dbo".to_string()), + name: "usp_demo".to_string(), + source: "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;".to_string(), + }) + .unwrap(); + assert_eq!(sql, "CREATE OR ALTER PROCEDURE dbo.usp_demo AS SELECT 1;"); } #[test] diff --git a/crates/dbx-core/src/sql.rs b/crates/dbx-core/src/sql.rs index 0d1dc122c0..5f8d98d67f 100644 --- a/crates/dbx-core/src/sql.rs +++ b/crates/dbx-core/src/sql.rs @@ -355,6 +355,9 @@ pub fn find_statement_at_cursor(sql: &str, cursor_pos: usize) -> String { } pub fn find_statement_at_cursor_for_database(sql: &str, cursor_pos: usize, db_type: DatabaseType) -> String { + if db_type == DatabaseType::SqlServer { + return find_sqlserver_statement_at_cursor(sql, cursor_pos); + } find_statement_at_cursor_with_options(sql, cursor_pos, SqlParsingOptions::for_database_type(db_type)) } @@ -606,6 +609,15 @@ fn dollar_quote_tag_at_str(sql: &str, index: usize) -> Option { } pub fn split_sql_batches(sql: &str) -> Vec { + let ranges = split_sql_batch_ranges(sql); + if ranges.is_empty() { + let trimmed = sql.trim(); + return if trimmed.is_empty() { Vec::new() } else { vec![trimmed.to_string()] }; + } + ranges.into_iter().map(|range| range.text).collect() +} + +fn split_sql_batch_ranges(sql: &str) -> Vec { let mut batches = Vec::new(); let mut current_start = 0; let lines: Vec<&str> = sql.split('\n').collect(); @@ -620,10 +632,7 @@ pub fn split_sql_batches(sql: &str) -> Vec { if trimmed.eq_ignore_ascii_case("go") || trimmed.to_ascii_lowercase().starts_with("go ") && trimmed[2..].trim().is_empty() { - let batch = sql[current_start..line_start].trim(); - if has_executable_sql(batch) { - batches.push(batch.to_string()); - } + push_batch_range(&mut batches, sql, current_start, line_start); current_start = line_end.min(sql.len()); if current_start < sql.len() && sql.as_bytes()[current_start] == b'\n' { current_start += 1; @@ -631,19 +640,86 @@ pub fn split_sql_batches(sql: &str) -> Vec { } } - let trailing = sql[current_start..].trim(); - if has_executable_sql(trailing) { - batches.push(trailing.to_string()); - } + push_batch_range(&mut batches, sql, current_start, sql.len()); + batches +} - if batches.is_empty() { - let trimmed = sql.trim(); - if !trimmed.is_empty() { - batches.push(trimmed.to_string()); +fn push_batch_range(ranges: &mut Vec, sql: &str, start: usize, end: usize) { + let Some((relative_start, relative_end)) = executable_sql_bounds(&sql[start..end], SqlParsingOptions::default()) + else { + return; + }; + let statement_start = start + relative_start; + let statement_end = start + relative_end; + let text = sql[statement_start..statement_end].to_string(); + if !text.is_empty() { + ranges.push(SqlStatementRange { text, start: statement_start, end: statement_end }); + } +} + +fn find_sqlserver_statement_at_cursor(sql: &str, cursor_pos: usize) -> String { + let cursor = utf16_offset_to_byte_index(sql, cursor_pos); + let batches = split_sql_batch_ranges(sql); + + for (idx, batch) in batches.iter().enumerate() { + if cursor >= batch.start && cursor <= batch.end { + if starts_with_sqlserver_module_ddl(&batch.text) { + return batch.text.clone(); + } + let relative_cursor = sql[..cursor].encode_utf16().count() - sql[..batch.start].encode_utf16().count(); + return find_statement_at_cursor_with_options(&batch.text, relative_cursor, SqlParsingOptions::default()); + } + + if cursor < batch.start { + if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| batches.get(prev_idx)) { + if starts_with_sqlserver_module_ddl(&prev.text) { + return prev.text.clone(); + } + let relative_cursor = prev.text.encode_utf16().count(); + return find_statement_at_cursor_with_options( + &prev.text, + relative_cursor, + SqlParsingOptions::default(), + ); + } + return batch.text.clone(); } } - batches + batches.last().map(|batch| batch.text.clone()).unwrap_or_else(|| sql.trim().to_string()) +} + +fn starts_with_sqlserver_module_ddl(sql: &str) -> bool { + let tokens = first_sql_tokens(sql, 4); + if tokens.len() >= 4 + && tokens[0].eq_ignore_ascii_case("CREATE") + && tokens[1].eq_ignore_ascii_case("OR") + && tokens[2].eq_ignore_ascii_case("ALTER") + { + return is_sqlserver_module_keyword(&tokens[3]); + } + + tokens.len() >= 2 + && (tokens[0].eq_ignore_ascii_case("CREATE") || tokens[0].eq_ignore_ascii_case("ALTER")) + && is_sqlserver_module_keyword(&tokens[1]) +} + +fn is_sqlserver_module_keyword(token: &str) -> bool { + ["FUNCTION", "PROC", "PROCEDURE", "TRIGGER", "VIEW"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword)) +} + +fn first_sql_tokens(sql: &str, limit: usize) -> Vec { + let mut tokens = Vec::new(); + for token in sql.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_') { + if token.is_empty() { + continue; + } + tokens.push(token.to_string()); + if tokens.len() >= limit { + break; + } + } + tokens } fn parse_delimiter_command(line: &str) -> Option<&str> { @@ -1894,6 +1970,43 @@ SELECT 2;"; assert_eq!(super::find_statement_at_cursor(sql, next_cursor), "SELECT 2"); } + #[test] + fn sqlserver_current_statement_keeps_procedure_batch_with_inner_semicolons() { + let sql = "\ +CREATE OR ALTER PROCEDURE dbo.usp_demo +AS +BEGIN + SELECT 1; + SELECT 2; +END +GO +SELECT 3;"; + let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count(); + let next_cursor = sql[..sql.rfind("SELECT 3").unwrap()].encode_utf16().count(); + + assert_eq!( + super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer), + "CREATE OR ALTER PROCEDURE dbo.usp_demo\nAS\nBEGIN\n SELECT 1;\n SELECT 2;\nEND" + ); + assert_eq!(super::find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::SqlServer), "SELECT 3"); + } + + #[test] + fn sqlserver_current_statement_keeps_alter_procedure_batch() { + let sql = "\ +ALTER PROC dbo.usp_demo +AS +BEGIN + UPDATE dbo.users SET name = name; +END"; + let cursor = sql[..sql.find("UPDATE").unwrap()].encode_utf16().count(); + + assert_eq!( + super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer), + "ALTER PROC dbo.usp_demo\nAS\nBEGIN\n UPDATE dbo.users SET name = name;\nEND" + ); + } + #[test] fn mysql_hash_comments_split_statements_per_issue_428() { let sql = "SELECT 1; # mysql comment\n\nSELECT 2 # trailing comment";