feat: Upgrades to sqltk v0.6.0 and sqltk-parser v0.53.0-cipherstash.1, with corresponding adjustments to accommodate the parser upgrade.

damncabbage · damncabbage · commit ea904c19b5a1 · 2025-04-30T13:03:07.000+10:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -35,8 +35,8 @@ strip = "none"
 debug = true
 
 [workspace.dependencies]
-sqltk = { version = "0.5.0" }
-sqltk-parser = { version = "0.52.0" }
+sqltk = { version = "0.6.0" }
+sqltk-parser = { version = "0.53.0-cipherstash.1" }
 thiserror = "2.0.9"
 tokio = { version = "1.44", features = ["full"] }
 tracing = "0.1"
diff --git a/packages/eql-mapper/src/importer.rs b/packages/eql-mapper/src/importer.rs
@@ -220,6 +220,18 @@ impl<'ast> Importer<'ast> {
                 ))
             }
 
+            #[allow(unused_variables)]
+            TableFactor::OpenJsonTable {
+                json_expr,
+                json_path,
+                columns,
+                alias,
+            } => {
+                return Err(ImportError::UnsupportedTableFactorVariant(
+                    "OpenJsonTable".to_owned(),
+                ))
+            }
+
             #[allow(unused_variables)]
             TableFactor::Pivot {
                 table,
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/expr.rs b/packages/eql-mapper/src/inference/infer_type_impls/expr.rs
@@ -25,12 +25,12 @@ impl<'ast> InferType<'ast, Expr> for TypeInferencer<'ast> {
             }
 
             #[allow(unused_variables)]
-            Expr::Wildcard => {
+            Expr::Wildcard(_) => {
                 self.unify_node_with_type(this_expr, self.resolve_wildcard()?)?;
             }
 
             #[allow(unused_variables)]
-            Expr::QualifiedWildcard(object_name) => {
+            Expr::QualifiedWildcard(object_name, _) => {
                 self.unify_node_with_type(
                     this_expr,
                     self.resolve_qualified_wildcard(&object_name.0)?,
@@ -345,6 +345,13 @@ impl<'ast> InferType<'ast, Expr> for TypeInferencer<'ast> {
                 self.unify_node_with_type(this_expr, self.get_node_type(function))?;
             }
 
+            // `<arbitrary-expr>.<function-call>.<function-call-expr>...`
+            Expr::Method(_) => {
+                return Err(TypeError::UnsupportedSqlFeature(
+                    "MSSQL Expression Method".into(),
+                ))
+            }
+
             // When operand is Some(operand), all conditions must be of type expr and expr must support equality
             // When operand is None, all conditions must be native (they are boolean)
             // The elements of `results` and else_result must be the same type
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/function.rs b/packages/eql-mapper/src/inference/infer_type_impls/function.rs
@@ -44,7 +44,7 @@ impl<'ast> InferType<'ast, Function> for TypeInferencer<'ast> {
                 FunctionArguments::List(args_list) => {
                     if args_list.args.len() == 1 {
                         match &args_list.args[0] {
-                            FunctionArg::Named { .. } => {
+                            FunctionArg::Named { .. } | FunctionArg::ExprNamed { .. } => {
                                 return Err(TypeError::FunctionCall(format!(
                                     "{} cannot be called with named arguments",
                                     fn_name.last().unwrap(),
@@ -97,6 +97,22 @@ impl<'ast> InferType<'ast, Function> for TypeInferencer<'ast> {
                     self.unify_node_with_type(function, Type::any_native())?;
                     for arg in &args_list.args {
                         match arg {
+                            FunctionArg::ExprNamed {
+                                name,
+                                arg,
+                                operator: _,
+                            } => {
+                                self.unify_node_with_type(name, Type::any_native())?;
+                                match arg {
+                                    FunctionArgExpr::Expr(expr) => {
+                                        self.unify_node_with_type(expr, Type::any_native())?;
+                                    }
+                                    // Aggregate functions like COUNT(table.*)
+                                    FunctionArgExpr::QualifiedWildcard(_) => {}
+                                    // Aggregate functions like COUNT(*)
+                                    FunctionArgExpr::Wildcard => {}
+                                }
+                            }
                             FunctionArg::Named { arg, .. } | FunctionArg::Unnamed(arg) => match arg
                             {
                                 FunctionArgExpr::Expr(expr) => {
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/select_items.rs b/packages/eql-mapper/src/inference/infer_type_impls/select_items.rs
@@ -39,6 +39,7 @@ impl<'ast> InferType<'ast, Vec<SelectItem>> for TypeInferencer<'ast> {
                     #[allow(unused_variables)]
                     SelectItem::QualifiedWildcard(object_name, options) => {
                         let WildcardAdditionalOptions {
+                            wildcard_token: _,
                             opt_ilike: None,
                             opt_exclude: None,
                             opt_except: None,
@@ -56,6 +57,7 @@ impl<'ast> InferType<'ast, Vec<SelectItem>> for TypeInferencer<'ast> {
 
                     SelectItem::Wildcard(options) => {
                         let WildcardAdditionalOptions {
+                            wildcard_token: _,
                             opt_ilike: None,
                             opt_exclude: None,
                             opt_except: None,
diff --git a/packages/eql-mapper/src/transformation_rules/group_by_eql_col.rs b/packages/eql-mapper/src/transformation_rules/group_by_eql_col.rs
@@ -1,7 +1,10 @@
 use std::{collections::HashMap, mem, sync::Arc};
 
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, GroupByExpr, Ident, ObjectName};
+use sqltk_parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, GroupByExpr, Ident, ObjectName,
+};
+use sqltk_parser::tokenizer::{Span, Token, TokenWithSpan};
 
 use crate::{EqlMapperError, Type, Value};
 
@@ -30,7 +33,10 @@ impl<'ast> TransformationRule<'ast> for GroupByEqlCol<'ast> {
             // Nodes are modified starting from the leaf nodes, to target_node *is* what we want to be wrapping.
             // So we steal the existing value and replace the original with a cheap placeholder (Expr::Wildcard).
             // Stealing the original subtree means we can avoid cloning it.
-            let transformed_expr = mem::replace(target_node, Expr::Wildcard);
+            let transformed_expr = mem::replace(
+                target_node,
+                Expr::Wildcard(AttachedToken(TokenWithSpan::new(Token::EOF, Span::empty()))),
+            );
 
             *target_node = helpers::wrap_in_1_arg_function(
                 transformed_expr,
diff --git a/packages/eql-mapper/src/transformation_rules/helpers.rs b/packages/eql-mapper/src/transformation_rules/helpers.rs
@@ -44,6 +44,7 @@ pub(crate) fn wrap_in_1_arg_function(expr: Expr, name: ObjectName) -> Expr {
         null_treatment: None,
         over: None,
         within_group: vec![],
+        uses_odbc_syntax: false,
     })
 }
 
diff --git a/packages/eql-mapper/src/transformation_rules/preserve_effective_aliases.rs b/packages/eql-mapper/src/transformation_rules/preserve_effective_aliases.rs
@@ -1,7 +1,10 @@
 use std::mem;
 
 use sqltk::{NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Function, Ident, Select, SelectItem};
+use sqltk_parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, Function, Ident, Select, SelectItem,
+};
+use sqltk_parser::tokenizer::{Span, Token, TokenWithSpan};
 
 use crate::EqlMapperError;
 
@@ -105,7 +108,13 @@ impl PreserveEffectiveAliases {
                 {
                     if effective_target_alias != effective_source_alias {
                         *target_node = SelectItem::ExprWithAlias {
-                            expr: mem::replace(expr, Expr::Wildcard),
+                            expr: mem::replace(
+                                expr,
+                                Expr::Wildcard(AttachedToken(TokenWithSpan::new(
+                                    Token::EOF,
+                                    Span::empty(),
+                                ))),
+                            ),
                             alias: effective_source_alias,
                         };
 
diff --git a/packages/eql-mapper/src/transformation_rules/wrap_eql_cols_in_order_by_with_ore_fn.rs b/packages/eql-mapper/src/transformation_rules/wrap_eql_cols_in_order_by_with_ore_fn.rs
@@ -1,7 +1,10 @@
 use std::{collections::HashMap, mem, sync::Arc};
 
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Ident, ObjectName, OrderByExpr};
+use sqltk_parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, Ident, ObjectName, OrderByExpr,
+};
+use sqltk_parser::tokenizer::{Span, Token, TokenWithSpan};
 
 use crate::{EqlMapperError, Type, Value};
 
@@ -44,7 +47,10 @@ impl<'ast> TransformationRule<'ast> for WrapEqlColsInOrderByWithOreFn<'ast> {
             if let Some((_order_by_expr,)) = node_path.last_1_as::<OrderByExpr>() {
                 let target_node = target_node.downcast_mut::<OrderByExpr>().unwrap();
 
-                let expr_to_wrap = mem::replace(&mut target_node.expr, Expr::Wildcard);
+                let expr_to_wrap = mem::replace(
+                    &mut target_node.expr,
+                    Expr::Wildcard(AttachedToken(TokenWithSpan::new(Token::EOF, Span::empty()))),
+                );
 
                 target_node.expr = wrap_in_1_arg_function(
                     expr_to_wrap,

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ pub(crate) fn wrap_in_1_arg_function(expr: Expr, name: ObjectName) -> Expr {`
`44`	`44`	`null_treatment: None,`
`45`	`45`	`over: None,`
`46`	`46`	`within_group: vec![],`
	`47`	`+ uses_odbc_syntax: false,`
`47`	`48`	`})`
`48`	`49`	`}`
`49`	`50`