polyglot-sql 0.4.0__tar.gz → 0.4.2__tar.gz

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.4.0"
+version = "0.4.2"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.4.0"
+version = "0.4.2"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.4.0
+Version: 0.4.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/Cargo.toml

@@ -28,7 +28,7 @@ generate = []
 transpile = ["generate"]
 builder = ["generate"]
 ast-tools = []
-semantic = ["generate", "ast-tools"]
+semantic = ["ast-tools"]
 openlineage = ["semantic"]
 diff = ["generate"]
 planner = []
@@ -106,7 +106,7 @@ thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.4.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.4.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -1587,6 +1587,38 @@ mod tests {
         assert_eq!(result, expected, "SQL: {}", sql);
     }
 
+    #[test]
+    fn test_safe_namespace_parses_as_function() {
+        let expr = parse_one(
+            "SELECT SAFE.PARSE_JSON(data) AS json_data FROM t",
+            DialectType::BigQuery,
+        )
+        .expect("parse");
+
+        let Expression::Select(select) = expr else {
+            panic!("expected SELECT");
+        };
+        let Expression::Alias(alias) = &select.expressions[0] else {
+            panic!("expected alias");
+        };
+        let Expression::Function(function) = &alias.this else {
+            panic!("expected SAFE namespace call to parse as Function");
+        };
+
+        assert_eq!(function.name, "SAFE.PARSE_JSON");
+        assert_eq!(function.args.len(), 1);
+    }
+
+    #[test]
+    fn test_safe_namespace_identity() {
+        bigquery_identity("SAFE.PARSE_JSON(data)", "SAFE.PARSE_JSON(data)");
+        bigquery_identity(
+            "SAFE.PARSE_DATE('%Y-%m-%d', date_col)",
+            "SAFE.PARSE_DATE('%F', date_col)",
+        );
+        bigquery_identity("SAFE.DIVIDE(a, b)", "SAFE.DIVIDE(a, b)");
+    }
+
     #[test]
     fn test_cast_char_to_string() {
         bigquery_identity("CAST(x AS CHAR)", "CAST(x AS STRING)");

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/expressions.rs

@@ -8346,7 +8346,7 @@ pub struct IndexColumn {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]
 pub struct DropIndex {
-    pub name: Identifier,
+    pub name: TableRef,
     pub table: Option<TableRef>,
     pub if_exists: bool,
     /// PostgreSQL CONCURRENTLY modifier
@@ -8357,7 +8357,7 @@ pub struct DropIndex {
 impl DropIndex {
     pub fn new(name: impl Into<String>) -> Self {
         Self {
-            name: Identifier::new(name),
+            name: TableRef::new(name),
             table: None,
             if_exists: false,
             concurrently: false,

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/generator.rs

@@ -11108,7 +11108,7 @@ impl Generator {
         }
 
         self.write_space();
-        self.generate_identifier(&di.name)?;
+        self.generate_table(&di.name)?;
 
         if let Some(ref table) = di.table {
             self.write_space();
@@ -38852,6 +38852,15 @@ mod tests {
     fn test_drop_index() {
         let result = roundtrip("DROP INDEX idx_name");
         assert_eq!(result, "DROP INDEX idx_name");
+
+        let result = roundtrip(r#"DROP INDEX IF EXISTS "idx_tokenKey__pb_users_auth_""#);
+        assert_eq!(
+            result,
+            r#"DROP INDEX IF EXISTS "idx_tokenKey__pb_users_auth_""#
+        );
+
+        let result = roundtrip(r#"DROP INDEX "public"."IdxMixed""#);
+        assert_eq!(result, r#"DROP INDEX "public"."IdxMixed""#);
     }
 
     #[test]

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/lineage.rs

@@ -714,7 +714,7 @@ fn to_node_inner(
     }
 
     // 7. Column references — trace each column to its source
-    let col_refs = find_column_refs_in_expr(&select_expr);
+    let col_refs = find_column_refs_in_expr(&select_expr, dialect);
     for col_ref in col_refs {
         let col_name = &col_ref.column;
         if let Some(ref table_id) = col_ref.table {
@@ -1265,13 +1265,30 @@ struct SimpleColumnRef {
 }
 
 /// Find all column references in an expression (does not recurse into subqueries).
-fn find_column_refs_in_expr(expr: &Expression) -> Vec<SimpleColumnRef> {
+fn find_column_refs_in_expr(
+    expr: &Expression,
+    dialect: Option<DialectType>,
+) -> Vec<SimpleColumnRef> {
     let mut refs = Vec::new();
-    collect_column_refs(expr, &mut refs);
+    collect_column_refs(expr, dialect, &mut refs);
     refs
 }
 
-fn collect_column_refs(expr: &Expression, refs: &mut Vec<SimpleColumnRef>) {
+fn is_bigquery_safe_namespace_receiver(expr: &Expression) -> bool {
+    match expr {
+        Expression::Column(col) => {
+            col.table.is_none() && !col.name.quoted && col.name.name.eq_ignore_ascii_case("SAFE")
+        }
+        Expression::Identifier(id) => !id.quoted && id.name.eq_ignore_ascii_case("SAFE"),
+        _ => false,
+    }
+}
+
+fn collect_column_refs(
+    expr: &Expression,
+    dialect: Option<DialectType>,
+    refs: &mut Vec<SimpleColumnRef>,
+) {
     let mut stack: Vec<&Expression> = vec![expr];
 
     while let Some(current) = stack.pop() {
@@ -1638,7 +1655,11 @@ fn collect_column_refs(expr: &Expression, refs: &mut Vec<SimpleColumnRef>) {
                 stack.push(&d.this);
             }
             Expression::MethodCall(m) => {
-                stack.push(&m.this);
+                if !matches!(dialect, Some(DialectType::BigQuery))
+                    || !is_bigquery_safe_namespace_receiver(&m.this)
+                {
+                    stack.push(&m.this);
+                }
                 for arg in &m.args {
                     stack.push(arg);
                 }
@@ -2989,6 +3010,71 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_lineage_bigquery_safe_namespace_issue207() {
+        let query = r#"
+WITH import_cte AS (
+  SELECT timestamp, data, operation
+  FROM `project`.`dataset`.`source_table`
+),
+transform_cte AS (
+  SELECT
+    timestamp,
+    SAFE.PARSE_JSON(data) AS json_data
+  FROM import_cte
+)
+SELECT json_data FROM transform_cte
+"#;
+        let expr = parse_one(query, DialectType::BigQuery).expect("parse");
+        let node = lineage("json_data", &expr, Some(DialectType::BigQuery), false)
+            .expect("lineage should resolve SAFE.PARSE_JSON arguments");
+        let names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
+
+        assert!(
+            names.iter().any(|name| name == "source_table.data"),
+            "expected source_table.data in lineage, got {names:?}"
+        );
+        assert!(
+            !names
+                .iter()
+                .any(|name| name.eq_ignore_ascii_case("import_cte.safe")),
+            "did not expect SAFE namespace receiver in lineage, got {names:?}"
+        );
+    }
+
+    #[test]
+    fn test_lineage_bigquery_safe_namespace_method_call_guard() {
+        let expr = parse("SELECT SAFE.PARSE_JSON(data) AS json_data FROM t");
+        let node = lineage("json_data", &expr, Some(DialectType::BigQuery), false)
+            .expect("lineage should resolve SAFE.PARSE_JSON arguments");
+        let names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
+
+        assert!(
+            names.iter().any(|name| name == "t.data"),
+            "expected t.data in lineage, got {names:?}"
+        );
+        assert!(
+            !names.iter().any(|name| name.eq_ignore_ascii_case("t.safe")),
+            "did not expect SAFE namespace receiver in lineage, got {names:?}"
+        );
+    }
+
+    #[test]
+    fn test_lineage_method_call_receiver_control() {
+        let expr = parse("SELECT obj.METHOD(arg) AS out FROM t");
+        let node = lineage("out", &expr, None, false).expect("lineage");
+        let names: Vec<_> = node.walk().map(|n| n.name.clone()).collect();
+
+        assert!(
+            names.iter().any(|name| name == "t.obj"),
+            "expected ordinary method receiver to remain in lineage, got {names:?}"
+        );
+        assert!(
+            names.iter().any(|name| name == "t.arg"),
+            "expected method argument in lineage, got {names:?}"
+        );
+    }
+
     #[test]
     fn test_lineage_upper_function() {
         let expr = parse("SELECT UPPER(name) AS upper_name FROM users");

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/openlineage.rs

@@ -550,11 +550,24 @@ fn input_fields_for_output(
     let description = output_field
         .expression
         .as_ref()
-        .map(|expr| expr.sql_for(options.dialect));
+        .and_then(|expr| transformation_description(expr, options.dialect));
 
     terminal_fields_to_openlineage(terminals, subtype, description, options, warnings)
 }
 
+fn transformation_description(expr: &Expression, dialect: DialectType) -> Option<String> {
+    #[cfg(feature = "generate")]
+    {
+        Some(expr.sql_for(dialect))
+    }
+
+    #[cfg(not(feature = "generate"))]
+    {
+        let _ = (expr, dialect);
+        None
+    }
+}
+
 fn terminal_fields_to_openlineage(
     terminals: Vec<TerminalField>,
     subtype: &str,
@@ -1113,6 +1126,45 @@ mod tests {
             .all(|f| f.transformations[0].subtype == "TRANSFORMATION"));
     }
 
+    #[test]
+    fn omits_bigquery_safe_namespace_from_column_lineage_issue207() {
+        let mut opts = options();
+        opts.dialect = DialectType::BigQuery;
+
+        let result = openlineage_column_lineage(
+            r#"
+WITH import_cte AS (
+  SELECT timestamp, data, operation
+  FROM `project`.`dataset`.`source_table`
+),
+transform_cte AS (
+  SELECT
+    timestamp,
+    SAFE.PARSE_JSON(data) AS json_data
+  FROM import_cte
+)
+SELECT json_data FROM transform_cte
+"#,
+            &opts,
+        )
+        .expect("lineage");
+        let field = result.facet.fields.get("json_data").expect("json_data");
+
+        assert!(
+            field.input_fields.iter().any(|input| input.field == "data"),
+            "expected data input field, got {:?}",
+            field.input_fields
+        );
+        assert!(
+            !field
+                .input_fields
+                .iter()
+                .any(|input| input.field.eq_ignore_ascii_case("safe")),
+            "did not expect SAFE namespace as input field, got {:?}",
+            field.input_fields
+        );
+    }
+
     #[test]
     fn emits_aggregation_column_lineage() {
         let result =

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/optimizer/subquery.rs

@@ -1176,7 +1176,7 @@ fn extract_subquery_to_cte(
 ) -> Expression {
     match source {
         Expression::Subquery(sub) => {
-            let inner_sql = crate::generator::Generator::sql(&sub.this).unwrap_or_default();
+            let subquery_key = subquery_identity_key(&sub.this);
             let alias_name = sub
                 .alias
                 .as_ref()
@@ -1184,7 +1184,7 @@ fn extract_subquery_to_cte(
                 .unwrap_or_default();
 
             // Check for duplicate subquery (reuse existing CTE)
-            if let Some(existing_name) = seen_sql.get(&inner_sql) {
+            if let Some(existing_name) = seen_sql.get(&subquery_key) {
                 let mut tref = TableRef::new(existing_name.as_str());
                 if !alias_name.is_empty() {
                     tref.alias = Some(Identifier::new(&alias_name));
@@ -1199,7 +1199,7 @@ fn extract_subquery_to_cte(
                 find_new_name(taken, "_cte")
             };
             taken.insert(cte_name.clone());
-            seen_sql.insert(inner_sql, cte_name.clone());
+            seen_sql.insert(subquery_key, cte_name.clone());
 
             // Create CTE
             new_ctes.push(Cte {
@@ -1223,6 +1223,22 @@ fn extract_subquery_to_cte(
     }
 }
 
+fn subquery_identity_key(expr: &Expression) -> String {
+    #[cfg(feature = "generate")]
+    {
+        crate::generator::Generator::sql(expr).unwrap_or_else(|_| structural_subquery_key(expr))
+    }
+
+    #[cfg(not(feature = "generate"))]
+    {
+        structural_subquery_key(expr)
+    }
+}
+
+fn structural_subquery_key(expr: &Expression) -> String {
+    serde_json::to_string(expr).unwrap_or_else(|_| format!("{expr:?}"))
+}
+
 /// Unnest correlated subqueries where possible.
 ///
 /// This transforms correlated subqueries into JOINs for better performance.

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/src/parser.rs

@@ -619,6 +619,39 @@ impl Parser {
         parser.parse()
     }
 
+    fn is_bigquery_safe_namespace_receiver(expr: &Expression) -> bool {
+        match expr {
+            Expression::Column(col) => {
+                col.table.is_none()
+                    && !col.name.quoted
+                    && col.name.name.eq_ignore_ascii_case("SAFE")
+            }
+            Expression::Identifier(id) => !id.quoted && id.name.eq_ignore_ascii_case("SAFE"),
+            _ => false,
+        }
+    }
+
+    fn parse_method_call_expression(
+        &self,
+        this: Expression,
+        method: Identifier,
+        args: Vec<Expression>,
+    ) -> Expression {
+        if matches!(
+            self.config.dialect,
+            Some(crate::dialects::DialectType::BigQuery)
+        ) && Self::is_bigquery_safe_namespace_receiver(&this)
+            && !method.quoted
+        {
+            return Expression::Function(Box::new(Function::new(
+                format!("SAFE.{}", method.name),
+                args,
+            )));
+        }
+
+        Expression::MethodCall(Box::new(MethodCall { this, method, args }))
+    }
+
     /// Parse all remaining statements from the token stream.
     ///
     /// Consumes tokens until the end of input, splitting on semicolons.
@@ -18529,12 +18562,9 @@ impl Parser {
 
         let if_exists = self.match_keywords(&[TokenType::If, TokenType::Exists]);
 
-        // Parse potentially qualified index name (a.b.c)
-        let mut name_parts = vec![self.expect_identifier()?];
-        while self.match_token(TokenType::Dot) {
-            name_parts.push(self.expect_identifier()?);
-        }
-        let name = Identifier::new(name_parts.join("."));
+        // Parse potentially qualified index name (a.b.c), preserving quoted
+        // state independently for every part.
+        let name = self.parse_table_ref()?;
 
         // Optional ON table
         let table = if self.match_token(TokenType::On) {
@@ -30474,18 +30504,15 @@ impl Parser {
                     self.parse_function_arguments()?
                 };
                 self.expect(TokenType::RParen)?;
-                let method_call = Expression::MethodCall(Box::new(MethodCall {
-                    this: Expression::boxed_column(Column {
-                        name: ident.clone(),
-                        table: None,
-                        join_mark: false,
-                        trailing_comments: Vec::new(),
-                        span: None,
-                        inferred_type: None,
-                    }),
-                    method: col_ident,
-                    args,
-                }));
+                let this = Expression::boxed_column(Column {
+                    name: ident.clone(),
+                    table: None,
+                    join_mark: false,
+                    trailing_comments: Vec::new(),
+                    span: None,
+                    inferred_type: None,
+                });
+                let method_call = self.parse_method_call_expression(this, col_ident, args);
                 return self.maybe_parse_subscript(method_call);
             }
 
@@ -32324,11 +32351,11 @@ impl Parser {
                         self.parse_expression_list()?
                     };
                     self.expect(TokenType::RParen)?;
-                    let method_call = Expression::MethodCall(Box::new(MethodCall {
-                        this: Expression::Identifier(Identifier::new(name)),
-                        method: col_ident,
+                    let method_call = self.parse_method_call_expression(
+                        Expression::Identifier(Identifier::new(name)),
+                        col_ident,
                         args,
-                    }));
+                    );
                     return self.maybe_parse_subscript(method_call);
                 }
 
@@ -37834,11 +37861,11 @@ impl Parser {
                         };
                         self.expect(TokenType::RParen)?;
                         // Create a method call expression (DotAccess with function call)
-                        expr = Expression::MethodCall(Box::new(MethodCall {
-                            this: expr,
-                            method: Identifier::new(field_name),
+                        expr = self.parse_method_call_expression(
+                            expr,
+                            Identifier::new(field_name),
                             args,
-                        }));
+                        );
                     } else {
                         let mut ident = Identifier::new(field_name);
                         if is_quoted {
@@ -60646,10 +60673,27 @@ OPTIONS (
 
         if let Expression::DropIndex(di) = &result[0] {
             assert!(di.if_exists);
+            assert_eq!(di.name.name.name, "idx_email");
+            assert!(!di.name.name.quoted);
             assert!(di.table.is_some());
         }
     }
 
+    #[test]
+    fn test_parse_drop_index_preserves_qualified_quoted_name() {
+        let result = Parser::parse_sql(r#"DROP INDEX IF EXISTS "public"."IdxEmail""#).unwrap();
+
+        if let Expression::DropIndex(di) = &result[0] {
+            let schema = di.name.schema.as_ref().expect("schema");
+            assert_eq!(schema.name, "public");
+            assert!(schema.quoted);
+            assert_eq!(di.name.name.name, "IdxEmail");
+            assert!(di.name.name.quoted);
+        } else {
+            panic!("Expected DropIndex");
+        }
+    }
+
     #[test]
     fn test_parse_create_view() {
         let result =

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/tests/identity_roundtrip.rs

@@ -777,6 +777,7 @@ mod ddl_drop_tests {
     #[test]
     fn test_drop_index() {
         assert_roundtrip("DROP INDEX a.b.c");
+        assert_roundtrip(r#"DROP INDEX "a"."B""#);
     }
 
     #[test]

{polyglot_sql-0.4.0 → polyglot_sql-0.4.2}/crates/polyglot-sql/tests/sqlglot_compat.rs

@@ -330,6 +330,22 @@ mod ddl_tests {
             roundtrip("DROP INDEX IF EXISTS idx"),
             "DROP INDEX IF EXISTS idx"
         );
+        assert_eq!(
+            transpile(
+                r#"DROP INDEX IF EXISTS "idx_tokenKey__pb_users_auth_""#,
+                DialectType::PostgreSQL,
+                DialectType::PostgreSQL
+            ),
+            r#"DROP INDEX IF EXISTS "idx_tokenKey__pb_users_auth_""#
+        );
+        assert_eq!(
+            transpile(
+                "DROP INDEX IF EXISTS `idx_tokenKey__pb_users_auth_`",
+                DialectType::SQLite,
+                DialectType::PostgreSQL
+            ),
+            r#"DROP INDEX IF EXISTS "idx_tokenKey__pb_users_auth_""#
+        );
     }
 
     #[test]