fix(gbase8s): make view source saves safer

crates/dbx-core/src/object_source_sql.rs

@@ -152,6 +152,14 @@ pub fn build_executable_object_source_statements(input: EditableObjectSourceSqlI
         )]);
     }
 
+    if is_oracle_like(input.database_type) && input.object_type == ObjectSourceKind::View {
+        return Ok(vec![executable_oracle_view_ddl(input.schema.as_deref(), &input.name, source)]);
+    }
+
+    if input.database_type == DatabaseType::Informix && input.object_type == ObjectSourceKind::View {
+        return Ok(executable_informix_view_statements(input.schema.as_deref(), &input.name, source));
+    }
+
     let create_statement = ensure_semicolon(source);
     let cleanup = build_routine_rename_cleanup(&input, source);
     Ok(if let Some(cleanup) = cleanup { vec![create_statement, cleanup] } else { vec![create_statement] })
@@ -185,6 +193,9 @@ pub fn build_editable_object_source(input: EditableObjectSourceSqlInput) -> Stri
         // Some providers return full view DDL instead of a bare SELECT body.
         return ensure_semicolon(source.trim());
     }
+    if input.database_type == DatabaseType::Informix && input.object_type == ObjectSourceKind::View {
+        return editable_informix_view_ddl(input.schema.as_deref(), &input.name, &source);
+    }
     match build_executable_object_source_statements(input) {
         Ok(statements) => statements.into_iter().next().unwrap_or_default(),
         Err(_) => ensure_semicolon(source.trim()),
@@ -329,6 +340,68 @@ fn executable_postgres_view_ddl(source: &str) -> Option<String> {
     None
 }
 
+fn executable_oracle_view_ddl(schema: Option<&str>, name: &str, source: &str) -> String {
+    let trimmed = source.trim();
+    if Regex::new(r"(?i)^CREATE\s+OR\s+REPLACE\s+").unwrap().is_match(trimmed) || source_starts_with_alter(trimmed) {
+        return ensure_semicolon(trimmed);
+    }
+
+    let create_view = Regex::new(r"(?i)^CREATE\s+((?:(?:NO)?FORCE\s+)?(?:(?:NON)?EDITIONABLE\s+)?VIEW\s+)").unwrap();
+    if create_view.is_match(trimmed) {
+        let replaced = create_view.replace(trimmed, "CREATE OR REPLACE $1");
+        return ensure_semicolon(replaced.as_ref());
+    }
+
+    format!("CREATE OR REPLACE VIEW {} AS\n{}", postgres_qualified_name(schema, name), ensure_semicolon(trimmed))
+}
+
+fn executable_informix_view_statements(schema: Option<&str>, name: &str, source: &str) -> Vec<String> {
+    let (target_name, create_tail) = informix_view_definition(schema, name, source);
+    if source_starts_with_alter(source.trim()) {
+        return vec![ensure_semicolon(source.trim())];
+    }
+
+    let validation_name = informix_validation_view_name(&target_name);
+    let mut statements = vec![
+        drop_informix_view_if_exists(&validation_name),
+        create_informix_view(&validation_name, &create_tail),
+        drop_informix_view_if_exists(&validation_name),
+    ];
+
+    let original_name = informix_identifier(name);
+    if !target_name.eq_ignore_ascii_case(&original_name) {
+        statements.push(drop_informix_view_if_exists(&original_name));
+    }
+    statements.push(drop_informix_view_if_exists(&target_name));
+    statements.push(create_informix_view(&target_name, &create_tail));
+    statements
+}
+
+fn editable_informix_view_ddl(schema: Option<&str>, name: &str, source: &str) -> String {
+    if source_starts_with_alter(source.trim()) {
+        return ensure_semicolon(source.trim());
+    }
+    let (target_name, create_tail) = informix_view_definition(schema, name, source);
+    create_informix_view(&target_name, &create_tail)
+}
+
+fn informix_view_definition(schema: Option<&str>, name: &str, source: &str) -> (String, String) {
+    let trimmed = source.trim();
+    let create_view = Regex::new(
+        r#"(?is)^\s*CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+((?:"(?:""|[^"])+"|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"(?:""|[^"])+"|[A-Za-z_][\w$]*))?)"#,
+    )
+    .unwrap();
+    if let Some(captures) = create_view.captures(trimmed) {
+        let view_name = captures.get(1).unwrap();
+        let target_name = strip_informix_owner_qualifiers(view_name.as_str(), schema);
+        let body = strip_informix_owner_qualifiers(&trimmed[view_name.end()..], schema);
+        return (target_name.trim().to_string(), body);
+    } else {
+        let body = strip_informix_owner_qualifiers(trimmed, schema);
+        (informix_identifier(name), format!(" AS\n{body}"))
+    }
+}
+
 fn postgres_qualified_name(schema: Option<&str>, name: &str) -> String {
     schema
         .into_iter()
@@ -339,6 +412,201 @@ fn postgres_qualified_name(schema: Option<&str>, name: &str) -> String {
         .join(".")
 }
 
+fn informix_identifier(name: &str) -> String {
+    if is_simple_informix_identifier(name) {
+        name.to_string()
+    } else {
+        quote_postgres_identifier(name)
+    }
+}
+
+fn create_informix_view(name: &str, create_tail: &str) -> String {
+    ensure_semicolon(&format!("CREATE VIEW {}{}", name.trim(), create_tail))
+}
+
+fn drop_informix_view_if_exists(name: &str) -> String {
+    format!("DROP VIEW IF EXISTS {};", name.trim())
+}
+
+fn informix_validation_view_name(target_name: &str) -> String {
+    let mut hash = 0x811c9dc5u32;
+    for byte in target_name.bytes() {
+        hash ^= byte as u32;
+        hash = hash.wrapping_mul(0x01000193);
+    }
+    format!("dbx_view_check_{hash:08x}")
+}
+
+fn strip_informix_owner_qualifiers(source: &str, schema: Option<&str>) -> String {
+    let Some(schema) = schema.map(str::trim).filter(|schema| !schema.is_empty()) else {
+        return source.to_string();
+    };
+
+    let mut result = String::with_capacity(source.len());
+    let mut index = 0;
+    while index < source.len() {
+        if let Some(end) = sql_single_quoted_literal_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some(end) = sql_line_comment_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some(end) = sql_block_comment_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some((end, replacement)) = informix_owner_qualifier_replacement(source, index, schema) {
+            result.push_str(replacement);
+            index = end;
+            continue;
+        }
+        let ch = source[index..].chars().next().unwrap();
+        result.push(ch);
+        index += ch.len_utf8();
+    }
+    result
+}
+
+fn informix_owner_qualifier_replacement<'a>(source: &'a str, start: usize, schema: &str) -> Option<(usize, &'a str)> {
+    if let Some((owner_end, owner)) = read_quoted_sql_identifier(source, start) {
+        if owner.eq_ignore_ascii_case(schema) {
+            let dot = skip_sql_whitespace(source, owner_end);
+            if source[dot..].starts_with('.') {
+                let ident_start = skip_sql_whitespace(source, dot + 1);
+                if let Some((ident_end, ident_text)) = read_informix_identifier_text(source, ident_start) {
+                    return Some((ident_end, ident_text));
+                }
+            }
+        }
+    }
+
+    if !is_simple_informix_identifier(schema) || !starts_with_ignore_ascii_case_at(source, start, schema) {
+        return None;
+    }
+    if source[..start].chars().next_back().is_some_and(is_informix_identifier_part) {
+        return None;
+    }
+    let owner_end = start + schema.len();
+    if source[owner_end..].chars().next().is_some_and(is_informix_identifier_part) {
+        return None;
+    }
+    let dot = skip_sql_whitespace(source, owner_end);
+    if !source[dot..].starts_with('.') {
+        return None;
+    }
+    let ident_start = skip_sql_whitespace(source, dot + 1);
+    read_informix_identifier_text(source, ident_start).map(|(ident_end, ident_text)| (ident_end, ident_text))
+}
+
+fn sql_single_quoted_literal_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with('\'') {
+        return None;
+    }
+    let mut index = start + 1;
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        index += ch.len_utf8();
+        if ch == '\'' {
+            if source[index..].starts_with('\'') {
+                index += 1;
+            } else {
+                return Some(index);
+            }
+        }
+    }
+    Some(source.len())
+}
+
+fn sql_line_comment_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with("--") {
+        return None;
+    }
+    let rest = &source[start..];
+    Some(start + rest.find('\n').map(|index| index + 1).unwrap_or(rest.len()))
+}
+
+fn sql_block_comment_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with("/*") {
+        return None;
+    }
+    let rest = &source[start + 2..];
+    Some(start + 2 + rest.find("*/").map(|index| index + 2).unwrap_or(rest.len()))
+}
+
+fn read_quoted_sql_identifier(source: &str, start: usize) -> Option<(usize, String)> {
+    if !source[start..].starts_with('"') {
+        return None;
+    }
+    let mut value = String::new();
+    let mut index = start + 1;
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        index += ch.len_utf8();
+        if ch == '"' {
+            if source[index..].starts_with('"') {
+                value.push('"');
+                index += 1;
+            } else {
+                return Some((index, value));
+            }
+        } else {
+            value.push(ch);
+        }
+    }
+    None
+}
+
+fn read_informix_identifier_text(source: &str, start: usize) -> Option<(usize, &str)> {
+    if let Some((end, _)) = read_quoted_sql_identifier(source, start) {
+        return Some((end, &source[start..end]));
+    }
+    let first = source[start..].chars().next()?;
+    if !is_informix_identifier_start(first) {
+        return None;
+    }
+    let mut end = start + first.len_utf8();
+    while end < source.len() {
+        let ch = source[end..].chars().next().unwrap();
+        if !is_informix_identifier_part(ch) {
+            break;
+        }
+        end += ch.len_utf8();
+    }
+    Some((end, &source[start..end]))
+}
+
+fn skip_sql_whitespace(source: &str, mut index: usize) -> usize {
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        if !ch.is_whitespace() {
+            break;
+        }
+        index += ch.len_utf8();
+    }
+    index
+}
+
+fn starts_with_ignore_ascii_case_at(source: &str, start: usize, needle: &str) -> bool {
+    source.get(start..start + needle.len()).is_some_and(|value| value.eq_ignore_ascii_case(needle))
+}
+
+fn is_informix_identifier_start(ch: char) -> bool {
+    ch == '_' || ch.is_ascii_alphabetic()
+}
+
+fn is_informix_identifier_part(ch: char) -> bool {
+    ch == '_' || ch == '$' || ch.is_ascii_alphanumeric()
+}
+
+fn is_simple_informix_identifier(name: &str) -> bool {
+    Regex::new(r"^[A-Za-z_][A-Za-z0-9_$]*$").unwrap().is_match(name)
+}
+
 fn mysql_qualified_name(schema: Option<&str>, name: &str) -> String {
     schema
         .into_iter()
@@ -504,6 +772,36 @@ mod tests {
         }
     }
 
+    fn informix_view_statements(name: &str, source: &str) -> Vec<String> {
+        build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Informix,
+            object_type: ObjectSourceKind::View,
+            schema: Some("gbasedbt".to_string()),
+            name: name.to_string(),
+            source: source.to_string(),
+        })
+        .unwrap()
+    }
+
+    fn expected_informix_view_replace_statements(
+        original_name: &str,
+        target_name: &str,
+        create_tail: &str,
+    ) -> Vec<String> {
+        let validation_name = informix_validation_view_name(target_name);
+        let mut statements = vec![
+            drop_informix_view_if_exists(&validation_name),
+            create_informix_view(&validation_name, create_tail),
+            drop_informix_view_if_exists(&validation_name),
+        ];
+        if !target_name.eq_ignore_ascii_case(original_name) {
+            statements.push(drop_informix_view_if_exists(original_name));
+        }
+        statements.push(drop_informix_view_if_exists(target_name));
+        statements.push(create_informix_view(target_name, create_tail));
+        statements
+    }
+
     #[test]
     fn sqlserver_edited_source_saves_as_alter() {
         let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
@@ -693,6 +991,141 @@ mod tests {
         }
     }
 
+    #[test]
+    fn oracle_view_body_saves_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "SELECT id, name FROM users WHERE active = 1".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"DBX_TEST\".\"V_ACTIVE_USERS\" AS\nSELECT id, name FROM users WHERE active = 1;"
+        );
+    }
+
+    #[test]
+    fn oracle_view_create_source_saves_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "CREATE FORCE EDITIONABLE VIEW DBX_TEST.V_ACTIVE_USERS AS SELECT id FROM users".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "CREATE OR REPLACE FORCE EDITIONABLE VIEW DBX_TEST.V_ACTIVE_USERS AS SELECT id FROM users;");
+    }
+
+    #[test]
+    fn oracle_view_source_opened_for_editing_shows_create_or_replace_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "SELECT id, name FROM users WHERE active = 1".to_string(),
+        });
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"DBX_TEST\".\"V_ACTIVE_USERS\" AS\nSELECT id, name FROM users WHERE active = 1;"
+        );
+    }
+
+    #[test]
+    fn informix_view_body_saves_with_validate_drop_create() {
+        let statements = informix_view_statements("demo_view", "SELECT id, name FROM users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " AS\nSELECT id, name FROM users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_strips_owner_qualifier_before_save() {
+        let statements =
+            informix_view_statements("demo_view", "create view \"gbasedbt\".demo_view (id) as select id from users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " (id) as select id from users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_preserves_sql_target_name() {
+        let statements = informix_view_statements("new_view", "create view codex_created_view as select id from users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("new_view", "codex_created_view", " as select id from users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_strips_same_owner_table_references() {
+        let statements = informix_view_statements(
+            "dba_db_links",
+            "create view \"gbasedbt\".dba_db_links as select x0.db_link from \"gbasedbt\".user_db_links x0",
+        );
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements(
+                "dba_db_links",
+                "dba_db_links",
+                " as select x0.db_link from user_db_links x0",
+            )
+        );
+    }
+
+    #[test]
+    fn informix_view_body_strips_same_owner_table_references() {
+        let statements = informix_view_statements("demo_view", "SELECT id FROM gbasedbt.users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " AS\nSELECT id FROM users")
+        );
+    }
+
+    #[test]
+    fn informix_owner_qualifier_rewrite_skips_strings_and_comments() {
+        let statements = informix_view_statements(
+            "demo_view",
+            "SELECT 'gbasedbt.users' AS literal, id FROM gbasedbt.users -- gbasedbt.audit\n/* gbasedbt.logs */",
+        );
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements(
+                "demo_view",
+                "demo_view",
+                " AS\nSELECT 'gbasedbt.users' AS literal, id FROM users -- gbasedbt.audit\n/* gbasedbt.logs */",
+            )
+        );
+    }
+
+    #[test]
+    fn informix_view_source_opened_for_editing_shows_unqualified_create_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Informix,
+            object_type: ObjectSourceKind::View,
+            schema: Some("gbasedbt".to_string()),
+            name: "demo_view".to_string(),
+            source: "create view \"gbasedbt\".demo_view as select id from users".to_string(),
+        });
+
+        assert_eq!(sql, "CREATE VIEW demo_view as select id from users;");
+    }
+
     #[test]
     fn view_ddl_wraps_postgres_body_as_create_or_replace_view() {
         let sql = build_view_ddl_sql(BuildViewDdlInput {