diff --git a/Cargo.lock b/Cargo.lock
index 88b3a697..b2e0ee88 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -705,7 +705,6 @@ dependencies = [
  "serde_json",
  "socket2",
  "sqltk",
- "sqltk-parser",
  "temp-env",
  "thiserror 2.0.12",
  "tokio",
@@ -1170,7 +1169,6 @@ dependencies = [
  "itertools 0.13.0",
  "pretty_assertions",
  "sqltk",
- "sqltk-parser",
  "thiserror 2.0.12",
  "tracing",
  "tracing-subscriber",
@@ -3458,9 +3456,9 @@ dependencies = [
 
 [[package]]
 name = "sqltk"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e10583ccac2be380f1dcc8ce79b751d9366e73802c31f6081e69e130545fdf3"
+checksum = "99d52192ed1973e2b1e3700a5bd80a8219eca3f497771e2edb9b40ea259b892d"
 dependencies = [
  "bigdecimal",
  "sqltk-parser",
@@ -3468,9 +3466,9 @@ dependencies = [
 
 [[package]]
 name = "sqltk-parser"
-version = "0.52.0"
+version = "0.53.0-cipherstash.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e443633c3788add36b38f86f1a9ca72fb1fd0a8141ae3e94fee41542a59daf47"
+checksum = "fefb748f5acb9818d39a574520b3e816b6c1797379461843d7cc17785c981405"
 dependencies = [
  "bigdecimal",
  "log",
diff --git a/Cargo.toml b/Cargo.toml
index b131db7c..577a9502 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,8 +35,7 @@ strip = "none"
 debug = true
 
 [workspace.dependencies]
-sqltk = { version = "0.5.0" }
-sqltk-parser = { version = "0.52.0" }
+sqltk = { version = "0.6.0" }
 thiserror = "2.0.9"
 tokio = { version = "1.44", features = ["full"] }
 tracing = "0.1"
diff --git a/packages/cipherstash-proxy/Cargo.toml b/packages/cipherstash-proxy/Cargo.toml
index bc285caa..d63a2513 100644
--- a/packages/cipherstash-proxy/Cargo.toml
+++ b/packages/cipherstash-proxy/Cargo.toml
@@ -41,7 +41,6 @@ serde = "1.0"
 serde_json = "1.0"
 socket2 = "0.5.7"
 sqltk = { workspace = true }
-sqltk-parser = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-postgres = { version = "0.7", features = [
diff --git a/packages/cipherstash-proxy/src/encrypt/schema/manager.rs b/packages/cipherstash-proxy/src/encrypt/schema/manager.rs
index dbf48730..fc000ccb 100644
--- a/packages/cipherstash-proxy/src/encrypt/schema/manager.rs
+++ b/packages/cipherstash-proxy/src/encrypt/schema/manager.rs
@@ -4,7 +4,7 @@ use crate::error::Error;
 use crate::{connect, log::SCHEMA};
 use arc_swap::ArcSwap;
 use eql_mapper::{Column, Schema, Table};
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::{task::JoinHandle, time};
diff --git a/packages/cipherstash-proxy/src/eql/mod.rs b/packages/cipherstash-proxy/src/eql/mod.rs
index 59cc764d..69266310 100644
--- a/packages/cipherstash-proxy/src/eql/mod.rs
+++ b/packages/cipherstash-proxy/src/eql/mod.rs
@@ -3,7 +3,7 @@ use cipherstash_client::{
     zerokms::{encrypted_record, EncryptedRecord},
 };
 use serde::{Deserialize, Serialize};
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct Plaintext {
diff --git a/packages/cipherstash-proxy/src/error.rs b/packages/cipherstash-proxy/src/error.rs
index 023cc4c8..a37e7413 100644
--- a/packages/cipherstash-proxy/src/error.rs
+++ b/packages/cipherstash-proxy/src/error.rs
@@ -324,8 +324,8 @@ impl From<serde_json::Error> for Error {
     }
 }
 
-impl From<sqltk_parser::parser::ParserError> for Error {
-    fn from(e: sqltk_parser::parser::ParserError) -> Self {
+impl From<sqltk::parser::parser::ParserError> for Error {
+    fn from(e: sqltk::parser::parser::ParserError) -> Self {
         Error::Mapping(MappingError::InvalidSqlStatement(e.to_string()))
     }
 }
diff --git a/packages/cipherstash-proxy/src/postgresql/data/from_sql.rs b/packages/cipherstash-proxy/src/postgresql/data/from_sql.rs
index a138406a..24daad7d 100644
--- a/packages/cipherstash-proxy/src/postgresql/data/from_sql.rs
+++ b/packages/cipherstash-proxy/src/postgresql/data/from_sql.rs
@@ -11,7 +11,7 @@ use cipherstash_config::ColumnType;
 use postgres_types::FromSql;
 use postgres_types::Type;
 use rust_decimal::Decimal;
-use sqltk_parser::ast::Value;
+use sqltk::parser::ast::Value;
 use std::str::FromStr;
 use tracing::debug;
 
diff --git a/packages/cipherstash-proxy/src/postgresql/frontend.rs b/packages/cipherstash-proxy/src/postgresql/frontend.rs
index 5a62cd2a..681b7f50 100644
--- a/packages/cipherstash-proxy/src/postgresql/frontend.rs
+++ b/packages/cipherstash-proxy/src/postgresql/frontend.rs
@@ -30,10 +30,10 @@ use eql_mapper::{self, EqlMapperError, EqlValue, TableColumn, TypeCheckedStateme
 use metrics::{counter, histogram};
 use pg_escape::quote_literal;
 use serde::Serialize;
+use sqltk::parser::ast::{self, Value};
+use sqltk::parser::dialect::PostgreSqlDialect;
+use sqltk::parser::parser::Parser;
 use sqltk::NodeKey;
-use sqltk_parser::ast::{self, Value};
-use sqltk_parser::dialect::PostgreSqlDialect;
-use sqltk_parser::parser::Parser;
 use std::collections::HashMap;
 use std::time::Instant;
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
diff --git a/packages/eql-mapper/Cargo.toml b/packages/eql-mapper/Cargo.toml
index 56c3caac..febb293e 100644
--- a/packages/eql-mapper/Cargo.toml
+++ b/packages/eql-mapper/Cargo.toml
@@ -16,7 +16,6 @@ derive_more = { version = "^1.0", features = ["display", "constructor"] }
 impl-trait-for-tuples = "0.2.3"
 itertools = "^0.13"
 sqltk = { workspace = true }
-sqltk-parser = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
diff --git a/packages/eql-mapper/src/display_helpers.rs b/packages/eql-mapper/src/display_helpers.rs
index e575d1b3..ca45080f 100644
--- a/packages/eql-mapper/src/display_helpers.rs
+++ b/packages/eql-mapper/src/display_helpers.rs
@@ -3,10 +3,10 @@ use std::{
     fmt::{Debug, Display},
 };
 
-use sqltk::NodeKey;
-use sqltk_parser::ast::{
+use sqltk::parser::ast::{
     Delete, Expr, Function, Insert, Query, Select, SelectItem, SetExpr, Statement, Value, Values,
 };
+use sqltk::NodeKey;
 
 use crate::{EqlValue, Param, Type};
 
@@ -108,7 +108,7 @@ impl Display for Fmt<&Vec<(Param, crate::Value)>> {
     }
 }
 
-impl Display for Fmt<&Vec<(EqlValue, &sqltk_parser::ast::Value)>> {
+impl Display for Fmt<&Vec<(EqlValue, &sqltk::parser::ast::Value)>> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let formatted = self
             .0
diff --git a/packages/eql-mapper/src/eql_mapper.rs b/packages/eql-mapper/src/eql_mapper.rs
index 64556e6e..d093d4b9 100644
--- a/packages/eql-mapper/src/eql_mapper.rs
+++ b/packages/eql-mapper/src/eql_mapper.rs
@@ -5,8 +5,8 @@ use crate::{
     DepMut, Fmt, Param, ParamError, ScopeError, ScopeTracker, TableResolver, Type,
     TypeCheckedStatement, TypeRegistry, Value,
 };
+use sqltk::parser::ast::{self as ast, Statement};
 use sqltk::{Break, NodeKey, Visitable, Visitor};
-use sqltk_parser::ast::{self as ast, Statement};
 use std::{
     cell::RefCell, collections::HashMap, marker::PhantomData, ops::ControlFlow, rc::Rc, sync::Arc,
 };
diff --git a/packages/eql-mapper/src/importer.rs b/packages/eql-mapper/src/importer.rs
index 1410c91c..ea94efd9 100644
--- a/packages/eql-mapper/src/importer.rs
+++ b/packages/eql-mapper/src/importer.rs
@@ -7,8 +7,8 @@ use crate::{
     unifier::{Projection, ProjectionColumns},
     Relation, ScopeError, ScopeTracker,
 };
+use sqltk::parser::ast::{Cte, Ident, Insert, TableAlias, TableFactor};
 use sqltk::{Break, Visitable, Visitor};
-use sqltk_parser::ast::{Cte, Ident, Insert, TableAlias, TableFactor};
 use std::{cell::RefCell, fmt::Debug, marker::PhantomData, ops::ControlFlow, rc::Rc, sync::Arc};
 
 /// `Importer` is a [`Visitor`] implementation that brings projections (from "FROM" clauses and subqueries) into lexical scope.
@@ -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,
@@ -307,7 +319,7 @@ impl<'ast> Visitor<'ast> for Importer<'ast> {
         // Most nodes that bring relations into scope use `exit` but in Insert's case we need to use `enter` because
         //
         // 1. There is no approprate child AST node of [`Insert`] on which to listen for an `exit` from except
-        // [`sqltk_parser::ast::ObjectName`], and `ObjectName` is used in contexts where it *should not* bring anything in
+        // [`sqltk::parser::ast::ObjectName`], and `ObjectName` is used in contexts where it *should not* bring anything in
         // to scope (it is not only used to identify tables).
         //
         // 2. Child nodes of the `Insert` need to resolve identifiers in the context of the scope, so exit would be too
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/delete_statement.rs b/packages/eql-mapper/src/inference/infer_type_impls/delete_statement.rs
index 39892532..af36000c 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/delete_statement.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/delete_statement.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::Delete;
+use sqltk::parser::ast::Delete;
 
 use crate::{
     inference::unifier::Type,
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/expr.rs b/packages/eql-mapper/src/inference/infer_type_impls/expr.rs
index eda87313..451c0d79 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/expr.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/expr.rs
@@ -3,7 +3,7 @@ use crate::{
     SqlIdent, TypeInferencer,
 };
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::{Array, BinaryOperator, Expr, Ident};
+use sqltk::parser::ast::{Array, BinaryOperator, Expr, Ident};
 
 #[trace_infer]
 impl<'ast> InferType<'ast, Expr> for TypeInferencer<'ast> {
@@ -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
index c6cf9709..88347df6 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/function.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/function.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::{Function, FunctionArg, FunctionArgExpr, FunctionArguments, Ident};
+use sqltk::parser::ast::{Function, FunctionArg, FunctionArgExpr, FunctionArguments, Ident};
 
 use crate::{
     inference::{type_error::TypeError, InferType},
@@ -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/insert_statement.rs b/packages/eql-mapper/src/inference/infer_type_impls/insert_statement.rs
index 9fcd753c..67ef1537 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/insert_statement.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/insert_statement.rs
@@ -10,7 +10,7 @@ use crate::{
     ColumnKind, TableColumn, TypeInferencer,
 };
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::{Ident, Insert};
+use sqltk::parser::ast::{Ident, Insert};
 
 #[trace_infer]
 impl<'ast> InferType<'ast, Insert> for TypeInferencer<'ast> {
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/query_statement.rs b/packages/eql-mapper/src/inference/infer_type_impls/query_statement.rs
index 77ce4aa5..bbd27f16 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/query_statement.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/query_statement.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::Query;
+use sqltk::parser::ast::Query;
 
 use crate::{
     inference::{InferType, TypeError},
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/select.rs b/packages/eql-mapper/src/inference/infer_type_impls/select.rs
index c527d7b4..5bb3c6b7 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/select.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/select.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::Select;
+use sqltk::parser::ast::Select;
 
 use crate::{
     inference::{type_error::TypeError, InferType},
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/select_item.rs b/packages/eql-mapper/src/inference/infer_type_impls/select_item.rs
index 31821a1c..11eb8241 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/select_item.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/select_item.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::SelectItem;
+use sqltk::parser::ast::SelectItem;
 
 use crate::{
     inference::{type_error::TypeError, InferType},
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
index ded92354..b1ab3c4a 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/select_items.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/select_items.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::{Expr, Function, SelectItem, WildcardAdditionalOptions};
+use sqltk::parser::ast::{Expr, Function, SelectItem, WildcardAdditionalOptions};
 
 use crate::{
     inference::{type_error::TypeError, unifier::Type, InferType},
@@ -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/inference/infer_type_impls/set_expr.rs b/packages/eql-mapper/src/inference/infer_type_impls/set_expr.rs
index 846e7d8f..8ef1f437 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/set_expr.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/set_expr.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::SetExpr;
+use sqltk::parser::ast::SetExpr;
 
 use crate::{inference::type_error::TypeError, inference::InferType, TypeInferencer};
 
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/statement.rs b/packages/eql-mapper/src/inference/infer_type_impls/statement.rs
index 1b53412a..b423be41 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/statement.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/statement.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::{AssignmentTarget, Statement};
+use sqltk::parser::ast::{AssignmentTarget, Statement};
 
 use crate::{inference::infer_type::InferType, unifier::Type, TypeError, TypeInferencer};
 
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/value.rs b/packages/eql-mapper/src/inference/infer_type_impls/value.rs
index a2d5dd61..42c47bc2 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/value.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/value.rs
@@ -1,5 +1,5 @@
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::Value;
+use sqltk::parser::ast::Value;
 
 use crate::{
     inference::{type_error::TypeError, InferType},
diff --git a/packages/eql-mapper/src/inference/infer_type_impls/values.rs b/packages/eql-mapper/src/inference/infer_type_impls/values.rs
index 1e4537ba..7dcafea1 100644
--- a/packages/eql-mapper/src/inference/infer_type_impls/values.rs
+++ b/packages/eql-mapper/src/inference/infer_type_impls/values.rs
@@ -3,7 +3,7 @@ use crate::{
     TypeInferencer,
 };
 use eql_mapper_macros::trace_infer;
-use sqltk_parser::ast::Values;
+use sqltk::parser::ast::Values;
 
 #[trace_infer]
 impl<'ast> InferType<'ast, Values> for TypeInferencer<'ast> {
diff --git a/packages/eql-mapper/src/inference/mod.rs b/packages/eql-mapper/src/inference/mod.rs
index 74c4d437..2e364944 100644
--- a/packages/eql-mapper/src/inference/mod.rs
+++ b/packages/eql-mapper/src/inference/mod.rs
@@ -11,10 +11,10 @@ use unifier::{Unifier, *};
 use std::{cell::RefCell, fmt::Debug, marker::PhantomData, ops::ControlFlow, rc::Rc, sync::Arc};
 
 use infer_type::InferType;
-use sqltk::{into_control_flow, AsNodeKey, Break, Visitable, Visitor};
-use sqltk_parser::ast::{
+use sqltk::parser::ast::{
     Delete, Expr, Function, Ident, Insert, Query, Select, SelectItem, SetExpr, Statement, Values,
 };
+use sqltk::{into_control_flow, AsNodeKey, Break, Visitable, Visitor};
 
 use crate::{ScopeError, ScopeTracker, TableResolver};
 
@@ -188,7 +188,7 @@ macro_rules! dispatch_all {
         dispatch!($self, $method, $node, SelectItem);
         dispatch!($self, $method, $node, Function);
         dispatch!($self, $method, $node, Values);
-        dispatch!($self, $method, $node, sqltk_parser::ast::Value);
+        dispatch!($self, $method, $node, sqltk::parser::ast::Value);
     };
 }
 
diff --git a/packages/eql-mapper/src/inference/unifier/mod.rs b/packages/eql-mapper/src/inference/unifier/mod.rs
index daac059a..e1f9e951 100644
--- a/packages/eql-mapper/src/inference/unifier/mod.rs
+++ b/packages/eql-mapper/src/inference/unifier/mod.rs
@@ -53,7 +53,7 @@ impl<'ast> Unifier<'ast> {
         self.registry.borrow_mut().get_param_type(param)
     }
 
-    /// [`sqltk_parser::ast::Value`] nodes with type `Type::Var(_)` after the inference phase is complete will be unified
+    /// [`sqltk::parser::ast::Value`] nodes with type `Type::Var(_)` after the inference phase is complete will be unified
     /// with [`NativeValue`].
     ///
     /// This can happen when a literal or param is never used in an expression that would constrain its type.
@@ -64,7 +64,7 @@ impl<'ast> Unifier<'ast> {
         let unresolved_value_nodes: Vec<_> = self
             .registry
             .borrow()
-            .get_nodes_and_types::<sqltk_parser::ast::Value>()
+            .get_nodes_and_types::<sqltk::parser::ast::Value>()
             .into_iter()
             .map(|(node, ty)| (node, ty.follow_tvars(&*self)))
             .filter(|(_, ty)| matches!(&**ty, Type::Var(_)))
@@ -341,11 +341,11 @@ impl<'ast> Unifier<'ast> {
 }
 
 pub(crate) mod test_util {
-    use sqltk::{AsNodeKey, Break, Visitable, Visitor};
-    use sqltk_parser::ast::{
+    use sqltk::parser::ast::{
         Delete, Expr, Function, FunctionArguments, Insert, Query, Select, SelectItem, SetExpr,
         Statement, Value, Values,
     };
+    use sqltk::{AsNodeKey, Break, Visitable, Visitor};
     use std::{any::type_name, convert::Infallible, fmt::Debug, ops::ControlFlow};
     use tracing::{event, Level};
 
diff --git a/packages/eql-mapper/src/inference/unifier/types.rs b/packages/eql-mapper/src/inference/unifier/types.rs
index cc4c9034..4c528eba 100644
--- a/packages/eql-mapper/src/inference/unifier/types.rs
+++ b/packages/eql-mapper/src/inference/unifier/types.rs
@@ -1,7 +1,7 @@
 use std::{any::type_name, ops::Index, sync::Arc};
 
 use derive_more::Display;
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
 use crate::{ColumnKind, Table, TypeError};
 
@@ -11,8 +11,8 @@ use super::Unifier;
 ///
 /// An expression can be:
 ///
-/// - a [`sqltk_parser::ast::Expr`] node
-/// - a [`sqltk_parser::ast::Statement`] or any other SQL AST node that produces a projection.
+/// - a [`sqltk::parser::ast::Expr`] node
+/// - a [`sqltk::parser::ast::Statement`] or any other SQL AST node that produces a projection.
 ///
 /// A `Type` is either a [`Constructor`] (fully or partially known type) or a [`TypeVar`] (a placeholder for an unknown type).
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Display, Hash)]
@@ -328,7 +328,7 @@ impl Type {
 #[display("PROJ[{}]", _0.iter().map(|pc| pc.to_string()).collect::<Vec<_>>().join(", "))]
 pub struct ProjectionColumns(pub(crate) Vec<ProjectionColumn>);
 
-/// The type of an [`sqltk_parser::ast::Expr`] or [`sqltk_parser::ast::Statement`] that returns a projection.
+/// The type of an [`sqltk::parser::ast::Expr`] or [`sqltk::parser::ast::Statement`] that returns a projection.
 ///
 /// It represents an ordered list of zero or more optionally aliased columns types.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Display, Hash)]
diff --git a/packages/eql-mapper/src/lib.rs b/packages/eql-mapper/src/lib.rs
index dfb7d024..3bd45186 100644
--- a/packages/eql-mapper/src/lib.rs
+++ b/packages/eql-mapper/src/lib.rs
@@ -41,9 +41,9 @@ mod test {
         Value,
     };
     use pretty_assertions::assert_eq;
+    use sqltk::parser::ast::Statement;
+    use sqltk::parser::ast::{self as ast};
     use sqltk::AsNodeKey;
-    use sqltk_parser::ast::Statement;
-    use sqltk_parser::ast::{self as ast};
     use std::collections::HashMap;
     use std::sync::Arc;
     use tracing::error;
diff --git a/packages/eql-mapper/src/model/relation.rs b/packages/eql-mapper/src/model/relation.rs
index 52f35af0..3d79e48d 100644
--- a/packages/eql-mapper/src/model/relation.rs
+++ b/packages/eql-mapper/src/model/relation.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
 use crate::unifier::Type;
 
diff --git a/packages/eql-mapper/src/model/schema.rs b/packages/eql-mapper/src/model/schema.rs
index 1b5607c0..dd6b22fa 100644
--- a/packages/eql-mapper/src/model/schema.rs
+++ b/packages/eql-mapper/src/model/schema.rs
@@ -6,7 +6,7 @@ use super::sql_ident::*;
 use crate::iterator_ext::IteratorExt;
 use core::fmt::Debug;
 use derive_more::Display;
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 use std::sync::Arc;
 use thiserror::Error;
 
@@ -228,7 +228,7 @@ macro_rules! schema {
         $schema.add_table(
             {
 
-                let mut $table = $crate::model::Table::new(::sqltk_parser::ast::Ident::new(stringify!($table_name)));
+                let mut $table = $crate::model::Table::new(::sqltk::parser::ast::Ident::new(stringify!($table_name)));
                 schema!(@add_columns $table $($columns)*);
                 $table
             }
@@ -239,14 +239,14 @@ macro_rules! schema {
     };
     (@add_column $table:ident $column_name:ident (EQL) ) => {
         $table.add_column(std::sync::Arc::new($crate::model::Column::eql(
-            ::sqltk_parser::ast::Ident::new(stringify!($column_name))
+            ::sqltk::parser::ast::Ident::new(stringify!($column_name))
         )), false);
     };
     (@add_column $table:ident $column_name:ident (PK) ) => {
         $table.add_column(
             std::sync::Arc::new(
                 $crate::model::Column::native(
-                    ::sqltk_parser::ast::Ident::new(stringify!($column_name))
+                    ::sqltk::parser::ast::Ident::new(stringify!($column_name))
                 )
             ),
             true
@@ -256,10 +256,10 @@ macro_rules! schema {
         $table.add_column(
             std::sync::Arc::new(
                 $crate::model::Column::new(
-                    ::sqltk_parser::ast::Ident::new(stringify!($column_name)),
+                    ::sqltk::parser::ast::Ident::new(stringify!($column_name)),
                     $crate::constraints::Scalar::Native {
                         table: $table.name.clone(),
-                        column: ::sqltk_parser::ast::Ident::new(stringify!($column_name))
+                        column: ::sqltk::parser::ast::Ident::new(stringify!($column_name))
                     }
                 )
             ),
@@ -270,7 +270,7 @@ macro_rules! schema {
         $table.add_column(
             std::sync::Arc::new(
                 $crate::model::Column::native(
-                    ::sqltk_parser::ast::Ident::new(stringify!($column_name)),
+                    ::sqltk::parser::ast::Ident::new(stringify!($column_name)),
                 )
             ),
             false
diff --git a/packages/eql-mapper/src/model/schema_delta.rs b/packages/eql-mapper/src/model/schema_delta.rs
index 5a5dcbf5..b79c6ba9 100644
--- a/packages/eql-mapper/src/model/schema_delta.rs
+++ b/packages/eql-mapper/src/model/schema_delta.rs
@@ -5,7 +5,7 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use sqltk_parser::ast::{
+use sqltk::parser::ast::{
     AlterTableOperation, ColumnDef, CreateTable, Ident, ObjectName, ObjectType, Statement,
     ViewColumnDef,
 };
diff --git a/packages/eql-mapper/src/model/sql_ident.rs b/packages/eql-mapper/src/model/sql_ident.rs
index 19f9d65b..acaa91da 100644
--- a/packages/eql-mapper/src/model/sql_ident.rs
+++ b/packages/eql-mapper/src/model/sql_ident.rs
@@ -3,7 +3,7 @@ use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
 
 use derive_more::Display;
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
 /// `SqlIdent` wraps an [`Ident`] (or `&Ident`) and defines a [`PartialEq`] implementation that respects the
 /// case-insensitive versus case-sensitive comparison rules for SQL identifiers depending on whether the identifier is
@@ -127,7 +127,7 @@ impl From<Ident> for SqlIdent<Ident> {
 
 #[cfg(test)]
 mod test {
-    use sqltk_parser::ast::Ident;
+    use sqltk::parser::ast::Ident;
 
     use crate::SqlIdent;
 
diff --git a/packages/eql-mapper/src/model/table_resolver.rs b/packages/eql-mapper/src/model/table_resolver.rs
index e8500938..6c130bd4 100644
--- a/packages/eql-mapper/src/model/table_resolver.rs
+++ b/packages/eql-mapper/src/model/table_resolver.rs
@@ -1,6 +1,6 @@
 use std::sync::{Arc, RwLock};
 
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
 use super::{Schema, SchemaError, SchemaTableColumn, SchemaWithEdits, Table};
 
diff --git a/packages/eql-mapper/src/model/type_system.rs b/packages/eql-mapper/src/model/type_system.rs
index d863f881..7ea05ce9 100644
--- a/packages/eql-mapper/src/model/type_system.rs
+++ b/packages/eql-mapper/src/model/type_system.rs
@@ -7,9 +7,9 @@
 
 use crate::unifier::{EqlValue, NativeValue};
 use derive_more::Display;
-use sqltk_parser::ast::Ident;
+use sqltk::parser::ast::Ident;
 
-/// The resolved type of a [`sqltk_parser::ast::Expr`] node.
+/// The resolved type of a [`sqltk::parser::ast::Expr`] node.
 #[derive(Debug, Clone, PartialEq, Eq, Display)]
 #[display("{self}")]
 pub enum Type {
diff --git a/packages/eql-mapper/src/scope_tracker.rs b/packages/eql-mapper/src/scope_tracker.rs
index f47c3e23..0b57bb90 100644
--- a/packages/eql-mapper/src/scope_tracker.rs
+++ b/packages/eql-mapper/src/scope_tracker.rs
@@ -5,8 +5,8 @@ use crate::iterator_ext::IteratorExt;
 use crate::model::SqlIdent;
 use crate::unifier::{Projection, ProjectionColumns};
 use crate::Relation;
+use sqltk::parser::ast::{Ident, ObjectName, Query, Statement};
 use sqltk::{into_control_flow, Break, Visitable, Visitor};
-use sqltk_parser::ast::{Ident, ObjectName, Query, Statement};
 use std::cell::RefCell;
 use std::fmt::Debug;
 use std::ops::ControlFlow;
diff --git a/packages/eql-mapper/src/test_helpers.rs b/packages/eql-mapper/src/test_helpers.rs
index 5bd962cf..cf36ba46 100644
--- a/packages/eql-mapper/src/test_helpers.rs
+++ b/packages/eql-mapper/src/test_helpers.rs
@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use sqltk_parser::{
+use sqltk::parser::{
     ast::{self as ast, Statement},
     dialect::PostgreSqlDialect,
     parser::Parser,
diff --git a/packages/eql-mapper/src/transformation_rules/fail_on_placeholder_change.rs b/packages/eql-mapper/src/transformation_rules/fail_on_placeholder_change.rs
index e55be29b..57633757 100644
--- a/packages/eql-mapper/src/transformation_rules/fail_on_placeholder_change.rs
+++ b/packages/eql-mapper/src/transformation_rules/fail_on_placeholder_change.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use sqltk_parser::ast::{Expr, Value};
+use sqltk::parser::ast::{Expr, Value};
 
 use crate::EqlMapperError;
 
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
index 12da2f3b..10840a44 100644
--- 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::parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, GroupByExpr, Ident, ObjectName,
+};
+use sqltk::parser::tokenizer::{Span, Token, TokenWithSpan};
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, GroupByExpr, Ident, ObjectName};
 
 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
index 96122cb3..d665db57 100644
--- a/packages/eql-mapper/src/transformation_rules/helpers.rs
+++ b/packages/eql-mapper/src/transformation_rules/helpers.rs
@@ -1,10 +1,10 @@
 use std::{collections::HashMap, convert::Infallible, ops::ControlFlow};
 
-use sqltk::{AsNodeKey, Break, NodeKey, Visitable, Visitor};
-use sqltk_parser::ast::{
+use sqltk::parser::ast::{
     Expr, Function, FunctionArg, FunctionArgExpr, FunctionArgumentList, FunctionArguments,
     GroupByExpr, ObjectName,
 };
+use sqltk::{AsNodeKey, Break, NodeKey, Visitable, Visitor};
 
 use crate::{Type, Value};
 
@@ -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
index d2ed0cb5..c26445cc 100644
--- 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::parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, Function, Ident, Select, SelectItem,
+};
+use sqltk::parser::tokenizer::{Span, Token, TokenWithSpan};
 use sqltk::{NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Function, Ident, Select, SelectItem};
 
 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/replace_plaintext_eql_literals.rs b/packages/eql-mapper/src/transformation_rules/replace_plaintext_eql_literals.rs
index 80d1b587..687649af 100644
--- a/packages/eql-mapper/src/transformation_rules/replace_plaintext_eql_literals.rs
+++ b/packages/eql-mapper/src/transformation_rules/replace_plaintext_eql_literals.rs
@@ -1,7 +1,7 @@
 use std::{any::type_name, collections::HashMap};
 
+use sqltk::parser::ast::Value;
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::Value;
 
 use crate::EqlMapperError;
 
diff --git a/packages/eql-mapper/src/transformation_rules/use_equivalent_eql_fns_on_eql_types.rs b/packages/eql-mapper/src/transformation_rules/use_equivalent_eql_fns_on_eql_types.rs
index a097aed1..6de21b74 100644
--- a/packages/eql-mapper/src/transformation_rules/use_equivalent_eql_fns_on_eql_types.rs
+++ b/packages/eql-mapper/src/transformation_rules/use_equivalent_eql_fns_on_eql_types.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashMap, sync::Arc};
 
+use sqltk::parser::ast::{Expr, Function, Ident, Select, SelectItem};
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Function, Ident, Select, SelectItem};
 
 use crate::{EqlMapperError, SqlIdent, Type};
 
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
index 76ca2410..17078487 100644
--- 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::parser::ast::{
+    helpers::attached_token::AttachedToken, Expr, Ident, ObjectName, OrderByExpr,
+};
+use sqltk::parser::tokenizer::{Span, Token, TokenWithSpan};
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Ident, ObjectName, OrderByExpr};
 
 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,
diff --git a/packages/eql-mapper/src/transformation_rules/wrap_grouped_eql_col_in_aggregate_fn.rs b/packages/eql-mapper/src/transformation_rules/wrap_grouped_eql_col_in_aggregate_fn.rs
index 90ded886..22d4aeb6 100644
--- a/packages/eql-mapper/src/transformation_rules/wrap_grouped_eql_col_in_aggregate_fn.rs
+++ b/packages/eql-mapper/src/transformation_rules/wrap_grouped_eql_col_in_aggregate_fn.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashMap, sync::Arc};
 
+use sqltk::parser::ast::{Expr, Ident, ObjectName, Select, SelectItem};
 use sqltk::{NodeKey, NodePath, Visitable};
-use sqltk_parser::ast::{Expr, Ident, ObjectName, Select, SelectItem};
 
 use crate::{EqlMapperError, Type};
 
diff --git a/packages/eql-mapper/src/type_checked_statement.rs b/packages/eql-mapper/src/type_checked_statement.rs
index d889cb1e..bb66aef8 100644
--- a/packages/eql-mapper/src/type_checked_statement.rs
+++ b/packages/eql-mapper/src/type_checked_statement.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashMap, sync::Arc};
 
+use sqltk::parser::ast::{self, Statement};
 use sqltk::{AsNodeKey, NodeKey, Transformable};
-use sqltk_parser::ast::{self, Statement};
 
 use crate::{
     DryRunnable, EqlMapperError, EqlValue, FailOnPlaceholderChange, GroupByEqlCol, Param,
@@ -73,7 +73,7 @@ impl<'ast> TypeCheckedStatement<'ast> {
     /// and inserting EQL helper functions where necessary.
     pub fn transform(
         &self,
-        encrypted_literals: HashMap<NodeKey<'ast>, sqltk_parser::ast::Value>,
+        encrypted_literals: HashMap<NodeKey<'ast>, sqltk::parser::ast::Value>,
     ) -> Result<Statement, EqlMapperError> {
         self.check_all_encrypted_literals_provided(&encrypted_literals)?;
         let mut transformer = self.make_transformer(encrypted_literals);
@@ -81,7 +81,7 @@ impl<'ast> TypeCheckedStatement<'ast> {
         self.statement.apply_transform(&mut transformer)
     }
 
-    pub fn literal_values(&self) -> Vec<&sqltk_parser::ast::Value> {
+    pub fn literal_values(&self) -> Vec<&sqltk::parser::ast::Value> {
         self.literals
             .iter()
             .map(|(_, value)| *value)
@@ -102,7 +102,7 @@ impl<'ast> TypeCheckedStatement<'ast> {
 
     fn check_all_encrypted_literals_provided(
         &self,
-        encrypted_literals: &HashMap<NodeKey<'ast>, sqltk_parser::ast::Value>,
+        encrypted_literals: &HashMap<NodeKey<'ast>, sqltk::parser::ast::Value>,
     ) -> Result<(), EqlMapperError> {
         if self.count_not_null_literals() != encrypted_literals.len() {
             return Err(EqlMapperError::Transform(format!(
@@ -135,7 +135,7 @@ impl<'ast> TypeCheckedStatement<'ast> {
 
     fn make_transformer(
         &self,
-        encrypted_literals: HashMap<NodeKey<'ast>, sqltk_parser::ast::Value>,
+        encrypted_literals: HashMap<NodeKey<'ast>, sqltk::parser::ast::Value>,
     ) -> DryRunnable<impl TransformationRule<'_>> {
         DryRunnable::new((
             WrapGroupedEqlColInAggregateFn::new(Arc::clone(&self.node_types)),