graph, store: Update sqlparser to latest version

lutter · lutter · commit 71d502be92f3 · 2025-10-29T17:23:10.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -82,7 +82,7 @@ serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 serde_regex = "1.1.0"
 serde_yaml = "0.9.21"
 slog = { version = "2.7.0", features = ["release_max_level_trace", "max_level_trace"] }
-sqlparser = { version = "0.46.0", features = ["visitor"] }
+sqlparser = { version = "0.59.0", features = ["visitor"] }
 strum = { version = "0.26", features = ["derive"] }
 syn = { version = "2.0.106", features = ["full"] }
 test-store = { path = "./store/test-store" }
diff --git a/graph/src/schema/input/mod.rs b/graph/src/schema/input/mod.rs
@@ -3090,8 +3090,10 @@ type Gravatar @entity {
                         } else {
                             let msgs: Vec<_> = errs.iter().map(|err| err.to_string()).collect();
                             panic!(
-                                    "{file_name} failed but not with the expected error `{msg}`: {errs:?} {msgs:?}",
-                                )
+                                "{file_name} failed but not with the expected error `{msg}`: \n\
+                                    actual: {errs:?}\n\
+                                    or {msgs:?}",
+                            )
                         }
                     }
                     (true, Ok(_)) => {
diff --git a/graph/src/schema/input/sqlexpr.rs b/graph/src/schema/input/sqlexpr.rs
@@ -37,7 +37,7 @@ pub trait ExprVisitor {
     fn visit_ident(&mut self, ident: &mut p::Ident) -> Result<(), ()>;
     /// Visit a function name. Must return `Err` if the function is not
     /// allowed
-    fn visit_func_name(&mut self, func: &mut p::Ident) -> Result<(), ()>;
+    fn visit_func_name(&mut self, func: &mut p::ObjectNamePart) -> Result<(), ()>;
     /// Called when we encounter a construct that is not supported like a
     /// subquery
     fn not_supported(&mut self, msg: String);
@@ -112,17 +112,16 @@ impl<'a> VisitExpr<'a> {
             Case {
                 operand,
                 conditions,
-                results,
                 else_result,
+                case_token: _,
+                end_token: _,
             } => {
                 if let Some(operand) = operand {
                     self.visit_expr(operand)?;
                 }
                 for condition in conditions {
-                    self.visit_expr(condition)?;
-                }
-                for result in results {
-                    self.visit_expr(result)?;
+                    self.visit_expr(&mut condition.condition)?;
+                    self.visit_expr(&mut condition.result)?;
                 }
                 if let Some(else_result) = else_result {
                     self.visit_expr(else_result)?;
@@ -152,7 +151,6 @@ impl<'a> VisitExpr<'a> {
             }
             CompoundIdentifier(_) => self.nope("CompoundIdentifier"),
             JsonAccess { .. } => self.nope("JsonAccess"),
-            CompositeAccess { .. } => self.nope("CompositeAccess"),
             IsUnknown(_) => self.nope("IsUnknown"),
             IsNotUnknown(_) => self.nope("IsNotUnknown"),
             InList { .. } => self.nope("InList"),
@@ -175,9 +173,7 @@ impl<'a> VisitExpr<'a> {
             Trim { .. } => self.nope("Trim"),
             Overlay { .. } => self.nope("Overlay"),
             Collate { .. } => self.nope("Collate"),
-            IntroducedString { .. } => self.nope("IntroducedString"),
             TypedString { .. } => self.nope("TypedString"),
-            MapAccess { .. } => self.nope("MapAccess"),
             Exists { .. } => self.nope("Exists"),
             Subquery(_) => self.nope("Subquery"),
             GroupingSets(_) => self.nope("GroupingSets"),
@@ -186,32 +182,41 @@ impl<'a> VisitExpr<'a> {
             Tuple(_) => self.nope("Tuple"),
             Struct { .. } => self.nope("Struct"),
             Named { .. } => self.nope("Named"),
-            ArrayIndex { .. } => self.nope("ArrayIndex"),
             Array(_) => self.nope("Array"),
             Interval(_) => self.nope("Interval"),
             MatchAgainst { .. } => self.nope("MatchAgainst"),
-            Wildcard => self.nope("Wildcard"),
-            QualifiedWildcard(_) => self.nope("QualifiedWildcard"),
+            Wildcard(_) => self.nope("Wildcard"),
+            QualifiedWildcard(_, _) => self.nope("QualifiedWildcard"),
             Dictionary(_) => self.nope("Dictionary"),
             OuterJoin(_) => self.nope("OuterJoin"),
             Prior(_) => self.nope("Prior"),
+            CompoundFieldAccess { .. } => self.nope("CompoundFieldAccess"),
+            IsNormalized { .. } => self.nope("IsNormalized"),
+            Prefixed { .. } => self.nope("Prefixed"),
+            Map(_) => self.nope("Map"),
+            Lambda(_) => self.nope("Lambda"),
+            MemberOf(_) => self.nope("MemberOf"),
         }
     }
 
     fn visit_func(&mut self, func: &mut p::Function) -> Result<(), ()> {
         let p::Function {
             name,
+            parameters,
             args: pargs,
             filter,
             null_treatment,
             over,
             within_group,
+            uses_odbc_syntax,
         } = func;
 
         if filter.is_some()
             || null_treatment.is_some()
             || over.is_some()
             || !within_group.is_empty()
+            || *uses_odbc_syntax
+            || !matches!(parameters, p::FunctionArguments::None)
         {
             return self.illegal_function(format!("call to {name} uses an illegal feature"));
         }
@@ -259,6 +264,15 @@ impl<'a> VisitExpr<'a> {
                                 ));
                             }
                         },
+                        ExprNamed {
+                            name: expr_name,
+                            arg: _,
+                            operator: _,
+                        } => {
+                            return self.illegal_function(format!(
+                                "call to {name} uses illegal ExprNamed {expr_name}"
+                            ));
+                        }
                     };
                 }
             }
@@ -304,7 +318,27 @@ impl<'a> VisitExpr<'a> {
             | AtQuestion
             | Question
             | QuestionAnd
-            | QuestionPipe => self.not_supported(format!("binary operator {op} is not supported")),
+            | QuestionPipe
+            | Match
+            | Regexp
+            | Overlaps
+            | DoubleHash
+            | LtDashGt
+            | AndLt
+            | AndGt
+            | LtLtPipe
+            | PipeGtGt
+            | AndLtPipe
+            | PipeAndGt
+            | LtCaret
+            | GtCaret
+            | QuestionHash
+            | QuestionDash
+            | QuestionDashPipe
+            | QuestionDoublePipe
+            | At
+            | TildeEq
+            | Assignment => self.not_supported(format!("binary operator {op} is not supported")),
         }
     }
 
@@ -313,7 +347,9 @@ impl<'a> VisitExpr<'a> {
         match op {
             Plus | Minus | Not => Ok(()),
             PGBitwiseNot | PGSquareRoot | PGCubeRoot | PGPostfixFactorial | PGPrefixFactorial
-            | PGAbs => self.not_supported(format!("unary operator {op} is not supported")),
+            | PGAbs | BangNot | Hash | AtDashAt | DoubleAt | QuestionDash | QuestionPipe => {
+                self.not_supported(format!("unary operator {op} is not supported"))
+            }
         }
     }
 }
@@ -346,8 +382,19 @@ impl<F: CheckIdentFn> ExprVisitor for Validator<F> {
         }
     }
 
-    fn visit_func_name(&mut self, func: &mut p::Ident) -> Result<(), ()> {
-        let p::Ident { value, quote_style } = &func;
+    fn visit_func_name(&mut self, func: &mut p::ObjectNamePart) -> Result<(), ()> {
+        let func = match func {
+            p::ObjectNamePart::Identifier(ident) => ident,
+            p::ObjectNamePart::Function(p::ObjectNamePartFunction { name, args: _ }) => {
+                self.not_supported(format!("function {name} is an object naming function"));
+                return Err(());
+            }
+        };
+        let p::Ident {
+            value,
+            quote_style,
+            span: _,
+        } = &func;
         let whitelisted = match quote_style {
             Some(_) => FN_WHITELIST.contains(&value.as_str()),
             None => FN_WHITELIST
diff --git a/graph/src/schema/test_schemas/ts_expr_syntax_err.graphql b/graph/src/schema/test_schemas/ts_expr_syntax_err.graphql
@@ -1,4 +1,4 @@
-# fail: ExprParseError("sql parser error: Expected an expression:, found: EOF")
+# fail: ExprParseError("sql parser error: Expected: an expression, found: EOF"
 type Data @entity(timeseries: true) {
   id: Int8!
   timestamp: Timestamp!
diff --git a/store/postgres/src/relational/rollup.rs b/store/postgres/src/relational/rollup.rs
@@ -105,7 +105,7 @@ fn rewrite<'a>(table: &'a Table, expr: &str) -> Result<(String, Vec<&'a str>), S
             }
         }
 
-        fn visit_func_name(&mut self, _func: &mut p::Ident) -> Result<(), ()> {
+        fn visit_func_name(&mut self, _func: &mut p::ObjectNamePart) -> Result<(), ()> {
             Ok(())
         }
 
diff --git a/store/postgres/src/sql/parser_tests.yaml b/store/postgres/src/sql/parser_tests.yaml
@@ -48,7 +48,7 @@
                 from (select "id", "timestamp", "pool", "token_0", "token_1", "sender", "recipient", "origin", "amount_0", "amount_1", "amount_usd", "sqrt_price_x96", "tick", "log_index"
                         from "sgd0815"."swap" where block$ <= 2147483647) as sm,
                      unnest(sm.amounts_out, sm.tokens_out) as smo (amount, token)) as tp
-                  join tokens as t on t.address = tp.token
+                  inner join tokens as t on t.address = tp.token
                group by tp.date, t.symbol, t.decimals
                order by tp.date desc, amount desc
 - name: pg_sleep forbidden
diff --git a/store/postgres/src/sql/validation.rs b/store/postgres/src/sql/validation.rs

Original file line number	Diff line number	Diff line change
`@@ -3090,8 +3090,10 @@ type Gravatar @entity {`
`3090`	`3090`	`} else {`
`3091`	`3091`	`let msgs: Vec<_> = errs.iter().map(\|err\| err.to_string()).collect();`
`3092`	`3092`	`panic!(`
`3093`		- "{file_name} failed but not with the expected error `{msg}`: {errs:?} {msgs:?}",
`3094`		`- )`
	`3093`	+ "{file_name} failed but not with the expected error `{msg}`: \n\
	`3094`	`+ actual: {errs:?}\n\`
	`3095`	`+ or {msgs:?}",`
	`3096`	`+ )`
`3095`	`3097`	`}`
`3096`	`3098`	`}`
`3097`	`3099`	`(true, Ok(_)) => {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# fail: ExprParseError("sql parser error: Expected an expression:, found: EOF")`
	`1`	`+# fail: ExprParseError("sql parser error: Expected: an expression, found: EOF"`
`2`	`2`	`type Data @entity(timeseries: true) {`
`3`	`3`	`id: Int8!`
`4`	`4`	`timestamp: Timestamp!`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ fn rewrite<'a>(table: &'a Table, expr: &str) -> Result<(String, Vec<&'a str>), S`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`- fn visit_func_name(&mut self, _func: &mut p::Ident) -> Result<(), ()> {`
	`108`	`+ fn visit_func_name(&mut self, _func: &mut p::ObjectNamePart) -> Result<(), ()> {`
`109`	`109`	`Ok(())`
`110`	`110`	`}`
`111`	`111`