자동 포멧팅 기능 개선

Author: letspurify-ux

crates/tns-thin/src/exec.rs

@@ -157,6 +157,8 @@ pub enum OracleVectorValue {
 pub struct ColumnMetadata {
     pub name: String,
     pub column_type: OracleColumnType,
+    pub precision: i8,
+    pub scale: i8,
     pub charset_form: u8,
     pub ora_type_num: u8,
     pub buffer_size: u32,

crates/tns-thin/src/session.rs

@@ -990,13 +990,21 @@ fn fetch_interval_columns_decodes_vendor_formats() {
             OracleColumnType::IntervalDaySecond,
         ]
     );
+    assert_eq!(
+        result
+            .columns
+            .iter()
+            .map(|column| (column.precision, column.scale))
+            .collect::<Vec<_>>(),
+        vec![(9, 0), (9, 0), (9, 9), (9, 9)]
+    );
     assert_eq!(
         rows_to_strings(&result.result.rows),
         vec![vec![
-            "+2021-10".to_string(),
-            "-05-03".to_string(),
-            "+02 12:23:34.456000".to_string(),
-            "-00 10:20:30.456789".to_string(),
+            "+000002021-10".to_string(),
+            "-000000005-03".to_string(),
+            "+000000002 12:23:34.456000000".to_string(),
+            "-000000000 10:20:30.456789000".to_string(),
         ]]
     );
 }

crates/tns-thin/tests/live_tns.rs

@@ -1184,6 +1184,8 @@ pub const MYSQL_SQL_KEYWORDS: &[&str] = &[
     "OVERLAPS",
     "PACK_KEYS",
     "PAGE_CHECKSUM",
+    "PAGE_COMPRESSED",
+    "PAGE_COMPRESSION_LEVEL",
     "PARSER",
     "PARSE_VCOL_EXPR",
     "PARTIAL",
@@ -2075,14 +2077,25 @@ pub(crate) fn is_mysql_dash_comment_start(bytes: &[u8], idx: usize) -> bool {
     match bytes.get(idx + 2) {
         None => true,
         Some(byte) if byte.is_ascii_whitespace() || byte.is_ascii_control() => true,
-        // A dash ruler (`--------…` to end of line) is a comment banner, not a
-        // chain of minus operators. MySQL's `-- ` rule alone would open the
-        // comment at the *last* two dashes and re-render everything before it as
-        // operators, so re-formatting kept peeling the ruler apart.
-        Some(b'-') => bytes[idx + 2..]
-            .iter()
-            .take_while(|byte| **byte != b'\n' && **byte != b'\r')
-            .all(|byte| *byte == b'-' || byte.is_ascii_whitespace()),
+        // A dash ruler is a comment banner, not a chain of minus operators. The
+        // `-- ` rule applied to the first two dashes alone would open the comment
+        // at the *last* two dashes of the run and re-render everything before it
+        // as operators, so re-formatting kept peeling the ruler apart.
+        //
+        // The `-- ` rule is therefore applied to the whole dash *run*: whatever
+        // follows the run must be whitespace or end-of-line. That accepts both a
+        // bare ruler and a titled banner (`----- banner -----`), while leaving
+        // `---x` and `1---1` as operators, which is what the server computes.
+        Some(b'-') => {
+            let run_end = bytes[idx..]
+                .iter()
+                .position(|byte| *byte != b'-')
+                .map_or(bytes.len(), |offset| idx + offset);
+            match bytes.get(run_end) {
+                None => true,
+                Some(byte) => byte.is_ascii_whitespace() || byte.is_ascii_control(),
+            }
+        }
         Some(_) => false,
     }
 }

src/sql_text.rs

@@ -7528,6 +7528,7 @@ pub const MARIADB_FUNCTIONS: &[&str] = &[
     "UUID_SHORT",
     "UUID_V4",
     "UUID_V7",
+    "VALUE",
     "VALUES",
     "VARIANCE",
     "VAR_POP",
@@ -10744,6 +10745,13 @@ const MARIADB_SIGNATURES: &[BuiltinSignature] = &[
         ],
         argument_separator_keywords: &[],
     },
+    BuiltinSignature {
+        name: "VALUE",
+        syntaxes: &[
+            "VALUE(col_name)",
+        ],
+        argument_separator_keywords: &[],
+    },
     BuiltinSignature {
         name: "VALUES",
         syntaxes: &[

src/ui/builtin_signatures.rs

@@ -32,7 +32,7 @@ fn assert_catalog(db_type: DatabaseType, names: &[&str], expected_len: usize) {
 fn builtin_signature_catalogs_match_official_manual_indices() {
     assert_catalog(DatabaseType::Oracle, ORACLE_FUNCTIONS, 464);
     assert_catalog(DatabaseType::MySQL, MYSQL_FUNCTIONS, 408);
-    assert_catalog(DatabaseType::MariaDB, MARIADB_FUNCTIONS, 475);
+    assert_catalog(DatabaseType::MariaDB, MARIADB_FUNCTIONS, 476);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

src/ui/builtin_signatures_live_tests.rs

@@ -51,6 +51,9 @@ const ORACLE_BUILTIN_PACKAGES: &[&str] = &[
     "DBMS_MVIEW",
     "DBMS_ALERT",
     "DBMS_PIPE",
+    "DBMS_XMLGEN",
+    "DBMS_ILM",
+    "UTL_CALL_STACK",
     "UTL_FILE",
     "UTL_RAW",
     "UTL_HTTP",

src/ui/intellisense.rs

@@ -14252,9 +14252,41 @@ impl SqlEditorWidget {
             ),
             OracleValue::Lob(_) => Some("[LOB]".to_string()),
             OracleValue::Cursor(_) => Some("[CURSOR]".to_string()),
-            OracleValue::Object(_) => Some("[OBJECT]".to_string()),
-            OracleValue::Array(_) => Some("[ARRAY]".to_string()),
-            OracleValue::IndexedArray(_) => Some("[INDEXED ARRAY]".to_string()),
+            OracleValue::Object(_) | OracleValue::Array(_) | OracleValue::IndexedArray(_) => {
+                serde_json::to_string(&Self::oracle_thin_value_json(value)).ok()
+            }
+        }
+    }
+
+    fn oracle_thin_value_json(value: &OracleValue) -> serde_json::Value {
+        match value {
+            OracleValue::Null => serde_json::Value::Null,
+            OracleValue::Number(value) => value
+                .parse::<serde_json::Number>()
+                .map(serde_json::Value::Number)
+                .unwrap_or_else(|_| serde_json::Value::String(value.clone())),
+            OracleValue::Boolean(value) => serde_json::Value::Bool(*value),
+            OracleValue::Text(value) => serde_json::Value::String(value.clone()),
+            OracleValue::Object(attributes) => {
+                let mut object = serde_json::Map::new();
+                for (name, value) in attributes {
+                    object.insert(name.clone(), Self::oracle_thin_value_json(value));
+                }
+                serde_json::Value::Object(object)
+            }
+            OracleValue::Array(values) => {
+                serde_json::Value::Array(values.iter().map(Self::oracle_thin_value_json).collect())
+            }
+            OracleValue::IndexedArray(values) => {
+                let mut object = serde_json::Map::new();
+                for (index, value) in values {
+                    object.insert(index.to_string(), Self::oracle_thin_value_json(value));
+                }
+                serde_json::Value::Object(object)
+            }
+            _ => {
+                serde_json::Value::String(Self::oracle_thin_string_cell(value).unwrap_or_default())
+            }
         }
     }
 
@@ -21251,6 +21283,42 @@ impl SqlEditorWidget {
     }
 }
 
+#[cfg(test)]
+mod oracle_thin_value_render_tests {
+    use super::{OracleValue, SqlEditorWidget};
+
+    #[test]
+    fn decoded_oracle_collections_render_their_elements() {
+        let value = OracleValue::Array(vec![
+            OracleValue::Number("10".to_string()),
+            OracleValue::Null,
+            OracleValue::Text("thirty".to_string()),
+            OracleValue::Object(vec![(
+                "NESTED".to_string(),
+                OracleValue::Array(vec![OracleValue::Boolean(true)]),
+            )]),
+        ]);
+
+        assert_eq!(
+            SqlEditorWidget::oracle_thin_string_cell(&value).as_deref(),
+            Some(r#"[10,null,"thirty",{"NESTED":[true]}]"#)
+        );
+    }
+
+    #[test]
+    fn decoded_oracle_indexed_arrays_keep_indexes_and_values() {
+        let value = OracleValue::IndexedArray(vec![
+            (5, OracleValue::Text("x".to_string())),
+            (9, OracleValue::Number("42".to_string())),
+        ]);
+
+        assert_eq!(
+            SqlEditorWidget::oracle_thin_string_cell(&value).as_deref(),
+            Some(r#"{"5":"x","9":42}"#)
+        );
+    }
+}
+
 #[cfg(test)]
 mod oracle_current_schema_statement_tests {
     use super::SqlEditorWidget;

src/ui/sql_editor/execution.rs

@@ -3561,7 +3561,7 @@ fn formatting_sweep_additional_non_parenthesized_child_lists_have_typed_frames()
     let cases: &[(DatabaseType, &str, &[ListOwnerKind])] = &[
         (
             DatabaseType::Oracle,
-            "SELECT * FROM sales MATCH_RECOGNIZE (ORDER BY sale_id SUBSET ab = (A, B), cd = (C, D) PATTERN (A B C D) DEFINE A AS amount > 0); SELECT a, b FROM t FOR UPDATE OF a, b; CREATE OR REPLACE TRIGGER trg BEFORE UPDATE OF a, b ON t FOLLOWS trg_a, trg_b BEGIN NULL; END; GRANT SELECT, UPDATE ON t TO app_a, app_b; ALTER TABLE t ADD c NUMBER, ADD d NUMBER; LOCK TABLE t_a, t_b IN EXCLUSIVE MODE; FLASHBACK TABLE t_a, t_b TO SCN 1; BEGIN FOR i IN 1..2, REVERSE 5..6, 9..9 LOOP NULL; END LOOP; END;",
+            "SELECT * FROM sales MATCH_RECOGNIZE (ORDER BY sale_id SUBSET ab = (A, B), cd = (C, D) PATTERN (A B C D) DEFINE A AS amount > 0); SELECT a, b FROM t FOR UPDATE OF a, b; CREATE OR REPLACE TRIGGER trg BEFORE UPDATE OF a, b ON t FOLLOWS trg_a, trg_b BEGIN NULL; END; GRANT SELECT, UPDATE ON t TO app_a, app_b; ALTER TABLE t ADD c NUMBER, ADD d NUMBER; LOCK TABLE t_a, t_b IN EXCLUSIVE MODE; FLASHBACK TABLE t_a, t_b TO SCN 1; CREATE AUDIT POLICY pol ACTIONS SELECT ON t_a, UPDATE ON t_b; BEGIN FOR i IN 1..2, REVERSE 5..6, 9..9 LOOP NULL; END LOOP; END;",
             &[
                 ListOwnerKind::Subset,
                 ListOwnerKind::ForUpdateColumns,
@@ -3572,6 +3572,7 @@ fn formatting_sweep_additional_non_parenthesized_child_lists_have_typed_frames()
                 ListOwnerKind::AlterActions,
                 ListOwnerKind::LockTables,
                 ListOwnerKind::FlashbackTargets,
+                ListOwnerKind::AuditActions,
                 ListOwnerKind::IterationControls,
             ],
         ),
@@ -3708,7 +3709,7 @@ fn formatting_sweep_list_owner_inventory_covers_every_typed_variant() {
         ),
         (
             DatabaseType::Oracle,
-            "ALTER TABLE t ADD a NUMBER, ADD b NUMBER; LOCK TABLE t_a, t_b IN EXCLUSIVE MODE; FLASHBACK TABLE t_a, t_b TO SCN 1; CREATE OR REPLACE TRIGGER trg_order BEFORE INSERT ON t FOLLOWS trg_a, trg_b BEGIN NULL; END; CREATE MATERIALIZED VIEW LOG ON t WITH PRIMARY KEY, ROWID INCLUDING NEW VALUES; BEGIN FOR i IN 1..2, REVERSE 5..6 LOOP NULL; END LOOP; END;",
+            "ALTER TABLE t ADD a NUMBER, ADD b NUMBER; LOCK TABLE t_a, t_b IN EXCLUSIVE MODE; FLASHBACK TABLE t_a, t_b TO SCN 1; CREATE AUDIT POLICY pol ACTIONS SELECT ON t_a, UPDATE ON t_b; CREATE OR REPLACE TRIGGER trg_order BEFORE INSERT ON t FOLLOWS trg_a, trg_b BEGIN NULL; END; CREATE MATERIALIZED VIEW LOG ON t WITH PRIMARY KEY, ROWID INCLUDING NEW VALUES; BEGIN FOR i IN 1..2, REVERSE 5..6 LOOP NULL; END LOOP; END;",
         ),
         (
             DatabaseType::Oracle,

src/ui/sql_editor/format_sweep_tests.rs

@@ -2253,6 +2253,7 @@ pub(super) enum ListOwnerKind {
     PropertyGraphProperties,
     TriggerOrdering,
     FlashbackTargets,
+    AuditActions,
 }
 
 impl ListOwnerKind {
@@ -2319,6 +2320,7 @@ impl ListOwnerKind {
         Self::PropertyGraphProperties,
         Self::TriggerOrdering,
         Self::FlashbackTargets,
+        Self::AuditActions,
     ];
 
     fn depth(self, header_indent: usize) -> usize {
@@ -7472,6 +7474,33 @@ impl SqlEditorWidget {
         }
     }
 
+    /// Whether `idx` sits inside a `CREATE|ALTER AUDIT POLICY` statement, and if
+    /// so whether its ACTIONS list has already been opened. Inside that list
+    /// every word names an audited action or its ON target, so SELECT / UPDATE /
+    /// ON own no clause there the way they do everywhere else.
+    fn oracle_audit_policy_position(tokens: &[SqlToken], idx: usize) -> Option<bool> {
+        let mut leading = tokens.iter().take(idx).filter_map(|token| match token {
+            SqlToken::Word(word) => Some(word.to_ascii_uppercase()),
+            _ => None,
+        });
+        if !matches!(leading.next().as_deref(), Some("CREATE") | Some("ALTER")) {
+            return None;
+        }
+
+        let mut saw_audit_policy = false;
+        let mut prev: Option<String> = None;
+        for word in leading {
+            if word == "ACTIONS" && saw_audit_policy {
+                return Some(true);
+            }
+            if word == "POLICY" && prev.as_deref() == Some("AUDIT") {
+                saw_audit_policy = true;
+            }
+            prev = Some(word);
+        }
+        saw_audit_policy.then_some(false)
+    }
+
     fn is_multiset_set_operator_from_indices(
         tokens: &[SqlToken],
         prev_word_upper: Option<&str>,
@@ -12956,6 +12985,14 @@ impl SqlEditorWidget {
                         && Self::is_mysql_index_hint_phrase_word(tokens, idx, upper);
                     let ddl_option_phrase_word = current_scope.paren_depth == 0
                         && Self::is_ddl_option_phrase_word(tokens, idx, upper);
+                    // `HIERARCHY h (child CHILD OF parent JOIN KEY t.c REFERENCES
+                    // parent)` in CREATE DIMENSION: `JOIN KEY` is a dimension
+                    // phrase, not a join, and it lives inside the hierarchy parens
+                    // so it cannot be gated on paren_depth.
+                    let oracle_dimension_join_key =
+                        !mysql_compatible && upper == "JOIN" && next_word_is("KEY");
+                    let oracle_audit_policy_action_word = !mysql_compatible
+                        && matches!(Self::oracle_audit_policy_position(tokens, idx), Some(true));
                     let keyword_suppresses_structural_handling = keyword_preserves_original_case
                         || treat_control_keyword_as_identifier
                         || follows_alias_control_keyword
@@ -12964,7 +13001,9 @@ impl SqlEditorWidget {
                         || oracle_iteration_collection_keyword
                         || oracle_type_method_order_modifier
                         || mysql_index_hint_phrase_word
-                        || ddl_option_phrase_word;
+                        || ddl_option_phrase_word
+                        || oracle_dimension_join_key
+                        || oracle_audit_policy_action_word;
                     let model_bracket_member = construct_flag_active!(ModelActive)
                         && delimiter_frame_state.innermost_is_bracket();
                     let on_duplicate_key_values_function =
@@ -16322,6 +16361,18 @@ impl SqlEditorWidget {
                             ListOwnerKind::TriggerUpdateColumns,
                         );
                     }
+                    if upper == "ACTIONS"
+                        && !mysql_compatible
+                        && matches!(Self::oracle_audit_policy_position(tokens, idx), Some(false))
+                    {
+                        format_stack.push_list_owner_kind_for_render(
+                            current_scope,
+                            ListOwnerKind::AuditActions,
+                            idx,
+                            tokens,
+                            line_indent,
+                        );
+                    }
                     if matches!(upper, "FOLLOWS" | "PRECEDES")
                         && format_stack.trigger_header_is_active()
                     {