Apache DataFusion SQL Query Engine
feat: Upgrade to sqlparser-rs 0.62.0 (#22069)
Andy Grove0c4ace8b7746
diff --git a/Cargo.lock b/Cargo.lockindex d3a6442596..40d9204597 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -5737,9 +5737,9 @@ dependencies = [[[package]]name = "sqlparser"-version = "0.61.0"+version = "0.62.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"+checksum = "13c6d1b651dc4edf07eead2a0c6c78016ce971bc2c10da5266861b13f25e7cec"dependencies = ["log","recursive",diff --git a/Cargo.toml b/Cargo.tomlindex 2a573d80b3..78c271d524 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -192,7 +192,7 @@ regex = "1.12"rstest = "0.26.1"serde_json = "1"sha2 = "^0.11.0"-sqlparser = { version = "0.61.0", default-features = false, features = ["std", "visitor"] }+sqlparser = { version = "0.62.0", default-features = false, features = ["std", "visitor"] }strum = "0.28.0"strum_macros = "0.28.0"tempfile = "3"diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rsindex 8c58e8f709..36ef6cf1f5 100644--- a/datafusion/expr/src/expr.rs+++ b/datafusion/expr/src/expr.rs@@ -4014,8 +4014,8 @@ mod test {wildcard_with_options(wildcard_options(None,Some(ExcludeSelectItem::Multiple(vec![- Ident::from("c1"),- Ident::from("c2")+ Ident::from("c1").into(),+ Ident::from("c2").into()])),None,None,diff --git a/datafusion/expr/src/sql.rs b/datafusion/expr/src/sql.rsindex c9c3fa5336..d582a0f6b9 100644--- a/datafusion/expr/src/sql.rs+++ b/datafusion/expr/src/sql.rs@@ -45,8 +45,8 @@ impl Display for IlikeSelectItem {#[derive(Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]pub enum ExcludeSelectItem {- Single(Ident),- Multiple(Vec<Ident>),+ Single(ObjectName),+ Multiple(Vec<ObjectName>),}impl Display for ExcludeSelectItem {@@ -64,6 +64,37 @@ impl Display for ExcludeSelectItem {}}+#[derive(Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]+pub struct ObjectName(pub Vec<ObjectNamePart>);++impl Display for ObjectName {+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {+ let parts: Vec<String> = self.0.iter().map(|p| format!("{p}")).collect();+ write!(f, "{}", parts.join("."))+ }+}++#[derive(Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]+pub enum ObjectNamePart {+ Identifier(Ident),+}++impl ObjectNamePart {+ pub fn as_ident(&self) -> Option<&Ident> {+ match self {+ ObjectNamePart::Identifier(ident) => Some(ident),+ }+ }+}++impl Display for ObjectNamePart {+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {+ match self {+ ObjectNamePart::Identifier(ident) => write!(f, "{ident}"),+ }+ }+}+#[derive(Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]pub struct ExceptSelectItem {pub first_element: Ident,diff --git a/datafusion/expr/src/utils.rs b/datafusion/expr/src/utils.rsindex 659306d3bf..22abb454d4 100644--- a/datafusion/expr/src/utils.rs+++ b/datafusion/expr/src/utils.rs@@ -39,10 +39,10 @@ use datafusion_common::{};#[cfg(not(feature = "sql"))]-use crate::sql::{ExceptSelectItem, ExcludeSelectItem};+use crate::sql::{ExceptSelectItem, ExcludeSelectItem, Ident, ObjectName};use indexmap::IndexSet;#[cfg(feature = "sql")]-use sqlparser::ast::{ExceptSelectItem, ExcludeSelectItem};+use sqlparser::ast::{ExceptSelectItem, ExcludeSelectItem, Ident, ObjectName};pub use datafusion_functions_aggregate_common::order::AggregateOrderSensitivity;@@ -339,11 +339,32 @@ fn get_excluded_columns(idents.push(&excepts.first_element);idents.extend(&excepts.additional_elements);}+ // Declared outside the `if let` so `idents.extend(exclude_owned.iter())`+ // below can borrow references that outlive the inner scope.+ let exclude_owned: Vec<Ident>;if let Some(exclude) = opt_exclude {- match exclude {- ExcludeSelectItem::Single(ident) => idents.push(ident),- ExcludeSelectItem::Multiple(idents_inner) => idents.extend(idents_inner),- }+ let object_name_to_ident = |name: &ObjectName| -> Result<Ident> {+ if name.0.len() != 1 {+ return plan_err!(+ "EXCLUDE with multi-part identifiers is not supported: {name}"+ );+ }+ let part = &name.0[0];+ let Some(ident) = part.as_ident() else {+ return plan_err!(+ "EXCLUDE with non-identifier name part is not supported: {part}"+ );+ };+ Ok(ident.clone())+ };+ exclude_owned = match exclude {+ ExcludeSelectItem::Single(name) => vec![object_name_to_ident(name)?],+ ExcludeSelectItem::Multiple(names) => names+ .iter()+ .map(object_name_to_ident)+ .collect::<Result<Vec<_>>>()?,+ };+ idents.extend(exclude_owned.iter());}// Excluded columns should be uniquelet n_elem = idents.len();diff --git a/datafusion/sql/src/expr/function.rs b/datafusion/sql/src/expr/function.rsindex 1790e66a02..67abb8b822 100644--- a/datafusion/sql/src/expr/function.rs+++ b/datafusion/sql/src/expr/function.rs@@ -927,10 +927,15 @@ impl<S: ContextProvider> SqlToRel<'_, S> {);}+ if lambda.params.iter().any(|p| p.data_type.is_some()) {+ return not_impl_err!(+ "Lambda parameters with explicit data types are not supported"+ );+ }let params = lambda.params.iter()- .map(|p| crate::utils::normalize_ident(p.clone()))+ .map(|p| crate::utils::normalize_ident(p.name.clone())).collect();let lambda_parameters = std::iter::zip(lambda_params, ¶ms)@@ -1181,19 +1186,19 @@ impl<S: ContextProvider> SqlToRel<'_, S> {/// After normalization with [normalize_ident], check whether all params are unique////// [normalize_ident]: crate::utils::normalize_ident-fn all_unique(params: &[sqlparser::ast::Ident]) -> bool {+fn all_unique(params: &[sqlparser::ast::LambdaFunctionParameter]) -> bool {match params.len() {0 | 1 => true,2 => {- crate::utils::normalize_ident(params[0].clone())- != crate::utils::normalize_ident(params[1].clone())+ crate::utils::normalize_ident(params[0].name.clone())+ != crate::utils::normalize_ident(params[1].name.clone())}_ => {let mut set = HashSet::with_capacity(params.len());params.iter()- .map(|p| crate::utils::normalize_ident(p.clone()))+ .map(|p| crate::utils::normalize_ident(p.name.clone())).all(|p| set.insert(p))}}diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rsindex 5cbc1c84bd..daf092ecd4 100644--- a/datafusion/sql/src/expr/mod.rs+++ b/datafusion/sql/src/expr/mod.rs@@ -900,7 +900,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {negated: bool,expr: SQLExpr,pattern: SQLExpr,- escape_char: Option<Value>,+ escape_char: Option<ValueWithSpan>,schema: &DFSchema,planner_context: &mut PlannerContext,case_insensitive: bool,@@ -910,7 +910,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {return not_impl_err!("ANY in LIKE expression");}let pattern = self.sql_expr_to_logical_expr(pattern, schema, planner_context)?;- let escape_char = match escape_char {+ let escape_char = match escape_char.map(|v| v.value) {Some(Value::SingleQuotedString(char)) if char.len() == 1 => {Some(char.chars().next().unwrap())}@@ -935,7 +935,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {negated: bool,expr: SQLExpr,pattern: SQLExpr,- escape_char: Option<Value>,+ escape_char: Option<ValueWithSpan>,schema: &DFSchema,planner_context: &mut PlannerContext,) -> Result<Expr> {@@ -944,7 +944,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if pattern_type != DataType::Utf8 && pattern_type != DataType::Null {return plan_err!("Invalid pattern in SIMILAR TO expression");}- let escape_char = match escape_char {+ let escape_char = match escape_char.map(|v| v.value) {Some(Value::SingleQuotedString(char)) if char.len() == 1 => {Some(char.chars().next().unwrap())}diff --git a/datafusion/sql/src/query.rs b/datafusion/sql/src/query.rsindex e320d2ee6e..76124cbc7e 100644--- a/datafusion/sql/src/query.rs+++ b/datafusion/sql/src/query.rs@@ -171,6 +171,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {// Apply to all fieldscolumns: vec![],explicit: true,+ at: None,},),PipeOperator::Union {diff --git a/datafusion/sql/src/select.rs b/datafusion/sql/src/select.rsindex 09d8566c4a..b7f7d80e70 100644--- a/datafusion/sql/src/select.rs+++ b/datafusion/sql/src/select.rs@@ -839,6 +839,9 @@ impl<S: ContextProvider> SqlToRel<'_, S> {Ok(SelectExpr::Expression(expr))}+ SelectItem::ExprWithAliases { .. } => {+ not_impl_err!("SELECT item with multiple aliases is not supported")+ }SelectItem::Wildcard(options) => {Self::check_wildcard_options(&options)?;if empty_from {@@ -886,11 +889,14 @@ impl<S: ContextProvider> SqlToRel<'_, S> {opt_rename,opt_replace: _opt_replace,opt_ilike: _opt_ilike,+ opt_alias,wildcard_token: _wildcard_token,} = options;if opt_rename.is_some() {not_impl_err!("wildcard * with RENAME not supported ")+ } else if opt_alias.is_some() {+ not_impl_err!("wildcard * with AS alias not supported")} else {Ok(())}diff --git a/datafusion/sql/src/statement.rs b/datafusion/sql/src/statement.rsindex 587ed02d13..e7088c8a3d 100644--- a/datafusion/sql/src/statement.rs+++ b/datafusion/sql/src/statement.rs@@ -344,6 +344,12 @@ impl<S: ContextProvider> SqlToRel<'_, S> {require_user,partition_of,for_values,+ snapshot,+ with_storage_lifecycle_policy,+ diststyle,+ distkey,+ sortkey,+ backup,}) => {if temporary {return not_impl_err!("Temporary tables not supported");@@ -497,6 +503,24 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if for_values.is_some() {return not_impl_err!("PARTITION OF .. FOR VALUES .. not supported");}+ if snapshot {+ return not_impl_err!("Snapshot tables not supported");+ }+ if with_storage_lifecycle_policy.is_some() {+ return not_impl_err!("WITH STORAGE LIFECYCLE POLICY not supported");+ }+ if diststyle.is_some() {+ return not_impl_err!("DISTSTYLE not supported");+ }+ if distkey.is_some() {+ return not_impl_err!("DISTKEY not supported");+ }+ if sortkey.is_some() {+ return not_impl_err!("SORTKEY not supported");+ }+ if backup.is_some() {+ return not_impl_err!("BACKUP not supported");+ }// Merge inline constraints and existing constraintslet mut all_constraints = constraints;let inline_constraints = calc_inline_constraints_from_columns(&columns);@@ -604,6 +628,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {or_alter,secure,name_before_not_exists,+ copy_grants,}) => {if materialized {return not_impl_err!("Materialized views not supported")?;@@ -623,6 +648,9 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if to.is_some() {return not_impl_err!("To not supported")?;}+ if copy_grants {+ return not_impl_err!("COPY GRANTS not supported")?;+ }// put the statement back together temporarily to get the SQL// string representation@@ -643,6 +671,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {or_alter,secure,name_before_not_exists,+ copy_grants,});let sql = stmt.to_string();let Statement::CreateView(ast::CreateView {@@ -1000,7 +1029,12 @@ impl<S: ContextProvider> SqlToRel<'_, S> {settings,format_clause,insert_token: _, // record the location the `INSERT` token- optimizer_hint,+ optimizer_hints,+ output,+ multi_table_insert_type,+ multi_table_into_clauses,+ multi_table_when_clauses,+ multi_table_else_clause,}) => {let table_name = match table {TableObject::TableName(table_name) => table_name,@@ -1009,6 +1043,11 @@ impl<S: ContextProvider> SqlToRel<'_, S> {"INSERT INTO Table functions not supported");}+ TableObject::TableQuery(_) => {+ return not_impl_err!(+ "INSERT INTO subquery target not supported"+ );+ }};if let Some(or) = or {match or {@@ -1056,9 +1095,19 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if format_clause.is_some() {plan_err!("Inserts with format clause not supported")?;}- if optimizer_hint.is_some() {+ if !optimizer_hints.is_empty() {plan_err!("Optimizer hints not supported")?;}+ if output.is_some() {+ plan_err!("Insert OUTPUT clause not supported")?;+ }+ if multi_table_insert_type.is_some()+ || !multi_table_into_clauses.is_empty()+ || !multi_table_when_clauses.is_empty()+ || multi_table_else_clause.is_some()+ {+ plan_err!("Multi-table INSERT not supported")?;+ }// optional keywords don't change behaviorlet _ = into;let _ = has_table_keyword;@@ -1073,7 +1122,9 @@ impl<S: ContextProvider> SqlToRel<'_, S> {or,limit,update_token: _,- optimizer_hint,+ optimizer_hints,+ output,+ order_by,}) => {let from_clauses =from.map(|update_table_from_kind| match update_table_from_kind {@@ -1103,9 +1154,15 @@ impl<S: ContextProvider> SqlToRel<'_, S> {if limit.is_some() {return not_impl_err!("Update-limit clause not supported")?;}- if optimizer_hint.is_some() {+ if !optimizer_hints.is_empty() {plan_err!("Optimizer hints not supported")?;}+ if output.is_some() {+ plan_err!("Update OUTPUT clause not supported")?;+ }+ if !order_by.is_empty() {+ plan_err!("Update ORDER BY not supported")?;+ }self.update_to_plan(table, &assignments, update_from, selection)}@@ -1118,7 +1175,8 @@ impl<S: ContextProvider> SqlToRel<'_, S> {order_by,limit,delete_token: _,- optimizer_hint,+ optimizer_hints,+ output,}) => {if !tables.is_empty() {plan_err!("DELETE <TABLE> not supported")?;@@ -1136,9 +1194,12 @@ impl<S: ContextProvider> SqlToRel<'_, S> {plan_err!("Delete-order-by clause not yet supported")?;}- if optimizer_hint.is_some() {+ if !optimizer_hints.is_empty() {plan_err!("Optimizer hints not supported")?;}+ if output.is_some() {+ plan_err!("Delete OUTPUT clause not supported")?;+ }let table_name = self.get_delete_target(from)?;self.delete_to_plan(&table_name, selection, limit)@@ -1260,7 +1321,14 @@ impl<S: ContextProvider> SqlToRel<'_, S> {..}) => {let return_type = match return_type {- Some(t) => Some(self.convert_data_type_to_field(&t)?),+ Some(ast::FunctionReturnType::DataType(t)) => {+ Some(self.convert_data_type_to_field(&t)?)+ }+ Some(ast::FunctionReturnType::SetOf(_)) => {+ return not_impl_err!(+ "RETURNS SETOF in CREATE FUNCTION is not supported"+ );+ }None => None,};let mut planner_context = PlannerContext::new();@@ -1882,6 +1950,16 @@ impl<S: ContextProvider> SqlToRel<'_, S> {TableConstraint::FulltextOrSpatial { .. } => {_plan_err!("Indexes are not currently supported")}+ TableConstraint::PrimaryKeyUsingIndex(_) => {+ _plan_err!(+ "PRIMARY KEY USING INDEX constraints are not currently supported"+ )+ }+ TableConstraint::UniqueUsingIndex(_) => {+ _plan_err!(+ "UNIQUE USING INDEX constraints are not currently supported"+ )+ }}).collect::<Result<Vec<_>>>()?;Ok(Constraints::new_unverified(constraints))@@ -2276,7 +2354,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {fn insert_to_plan(&self,table_name: ObjectName,- columns: Vec<Ident>,+ columns: Vec<ObjectName>,source: Box<Query>,overwrite: bool,replace_into: bool,@@ -2286,6 +2364,24 @@ impl<S: ContextProvider> SqlToRel<'_, S> {let table_source = self.context_provider.get_table_source(table_name.clone())?;let table_schema = DFSchema::try_from(table_source.schema())?;+ let columns: Vec<Ident> = columns+ .into_iter()+ .map(|name| {+ if name.0.len() != 1 {+ return not_impl_err!(+ "Multi-part column names in INSERT not supported: {name}"+ );+ }+ let part = &name.0[0];+ let Some(ident) = part.as_ident() else {+ return not_impl_err!(+ "Non-identifier column name part in INSERT not supported: {part}"+ );+ };+ Ok(ident.clone())+ })+ .collect::<Result<Vec<_>>>()?;+// Get insert fields and target table's value indices//// If value_indices[i] = Some(j), it means that the value of the i-th target table's column is@@ -2329,7 +2425,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {let mut prepare_param_data_types = BTreeMap::new();if let SetExpr::Values(ast::Values { rows, .. }) = (*source.body).clone() {for row in rows.iter() {- for (idx, val) in row.iter().enumerate() {+ for (idx, val) in row.content.iter().enumerate() {if let SQLExpr::Value(ValueWithSpan {value: Value::Placeholder(name),span: _,@@ -2581,7 +2677,7 @@ ON p.function_name = r.routine_nameNone => Ok(()),// BEGIN TRANSACTIONSome(BeginTransactionKind::Transaction) => Ok(()),- Some(BeginTransactionKind::Work) => {+ Some(BeginTransactionKind::Work) | Some(BeginTransactionKind::Tran) => {not_impl_err!("Transaction kind not supported: {kind:?}")}}diff --git a/datafusion/sql/src/unparser/ast.rs b/datafusion/sql/src/unparser/ast.rsindex d8d5ec9e40..4b4e56c40c 100644--- a/datafusion/sql/src/unparser/ast.rs+++ b/datafusion/sql/src/unparser/ast.rs@@ -358,7 +358,7 @@ impl SelectBuilder {}pub fn build(&self) -> Result<ast::Select, BuilderError> {Ok(ast::Select {- optimizer_hint: None,+ optimizer_hints: vec![],distinct: self.distinct.clone(),select_modifiers: None,top_before_distinct: false,@@ -477,6 +477,9 @@ pub struct RelationBuilder {}#[derive(Clone)]+// Boxing variants would penalize the common builder path; this enum is+// constructed-then-consumed locally rather than stored at scale.+#[expect(clippy::large_enum_variant)]enum TableFactorBuilder {Table(TableRelationBuilder),Derived(DerivedRelationBuilder),@@ -794,6 +797,7 @@ impl FlattenRelationBuilder {lateral: true,name: ast::ObjectName::from(vec![ast::Ident::new("FLATTEN")]),args,+ with_ordinality: false,alias: self.alias.clone(),})}diff --git a/datafusion/sql/src/unparser/expr.rs b/datafusion/sql/src/unparser/expr.rsindex 2124d5739c..dde383ea26 100644--- a/datafusion/sql/src/unparser/expr.rs+++ b/datafusion/sql/src/unparser/expr.rs@@ -317,7 +317,8 @@ impl Unparser<'_> {negated: *negated,expr: Box::new(self.expr_to_sql_inner(expr)?),pattern: Box::new(self.expr_to_sql_inner(pattern)?),- escape_char: escape_char.map(|c| SingleQuotedString(c.to_string())),+ escape_char: escape_char+ .map(|c| SingleQuotedString(c.to_string()).into()),any: false,}),Expr::Like(Like {@@ -333,7 +334,7 @@ impl Unparser<'_> {expr: Box::new(self.expr_to_sql_inner(expr)?),pattern: Box::new(self.expr_to_sql_inner(pattern)?),escape_char: escape_char- .map(|c| SingleQuotedString(c.to_string())),+ .map(|c| SingleQuotedString(c.to_string()).into()),any: false,})} else {@@ -342,7 +343,7 @@ impl Unparser<'_> {expr: Box::new(self.expr_to_sql_inner(expr)?),pattern: Box::new(self.expr_to_sql_inner(pattern)?),escape_char: escape_char- .map(|c| SingleQuotedString(c.to_string())),+ .map(|c| SingleQuotedString(c.to_string()).into()),any: false,})}@@ -598,7 +599,10 @@ impl Unparser<'_> {params: ast::OneOrManyWithParens::Many(params.iter()- .map(|param| self.new_ident_quoted_if_needs(param.clone()))+ .map(|param| ast::LambdaFunctionParameter {+ name: self.new_ident_quoted_if_needs(param.clone()),+ data_type: None,+ }).collect(),),body: Box::new(self.expr_to_sql_inner(body)?),diff --git a/datafusion/sql/src/unparser/plan.rs b/datafusion/sql/src/unparser/plan.rsindex 2c36fe0b2c..43d7ef49d9 100644--- a/datafusion/sql/src/unparser/plan.rs+++ b/datafusion/sql/src/unparser/plan.rs@@ -434,6 +434,7 @@ impl Unparser<'_> {name: Ident::with_quote('"', &flatten_alias_name),columns: vec![],explicit: true,+ at: None,}));if !select.already_projected() {@@ -1208,6 +1209,7 @@ impl Unparser<'_> {name: Ident::with_quote('"', &alias),columns: vec![],explicit: true,+ at: None,}));}relation.flatten(flatten_relation);@@ -1902,6 +1904,7 @@ impl Unparser<'_> {name: self.new_ident_quoted_if_needs(alias),columns,explicit: true,+ at: None,}}diff --git a/datafusion/sql/src/values.rs b/datafusion/sql/src/values.rsindex c8cdf1254f..a1df1fe1b1 100644--- a/datafusion/sql/src/values.rs+++ b/datafusion/sql/src/values.rs@@ -43,7 +43,8 @@ impl<S: ContextProvider> SqlToRel<'_, S> {let values = rows.into_iter().map(|row| {- row.into_iter()+ row.content+ .into_iter().map(|v| self.sql_to_expr(v, &empty_schema, planner_context)).collect::<Result<Vec<_>>>()})diff --git a/datafusion/sqllogictest/test_files/array/array_transform.slt b/datafusion/sqllogictest/test_files/array/array_transform.sltindex f726d265d9..f87253695d 100644--- a/datafusion/sqllogictest/test_files/array/array_transform.slt+++ b/datafusion/sqllogictest/test_files/array/array_transform.slt@@ -411,13 +411,13 @@ SELECT array_transform([1, 2], (e, i, j) -> i);query error DataFusion error: Error during planning: lambda parameters names must be unique, got \(v, v\)SELECT array_transform([1], (v, v) -> v*2);-query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,12\)\.\.Location\(1,13\)\) \}\), body: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,17\)\.\.Location\(1,18\)\) \}\), syntax: Arrow \}\)+query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(LambdaFunctionParameter \{ name: Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,12\)\.\.Location\(1,13\)\) \}, data_type: None \}\), body: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,17\)\.\.Location\(1,18\)\) \}\), syntax: Arrow \}\)SELECT abs(v -> v);-query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,8\)\.\.Location\(1,9\)\) \}\), body: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,13\)\.\.Location\(1,14\)\) \}\), syntax: Arrow \}\)+query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(LambdaFunctionParameter \{ name: Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,8\)\.\.Location\(1,9\)\) \}, data_type: None \}\), body: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,13\)\.\.Location\(1,14\)\) \}\), syntax: Arrow \}\)SELECT v -> v;-query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,34\)\.\.Location\(1,35\)\) \}\), body: BinaryOp \{ left: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,39\)\.\.Location\(1,40\)\) \}\), op: Plus, right: Value\(ValueWithSpan \{ value: Number\("1", false\), span: Span\(Location\(1,41\)\.\.Location\(1,42\)\) \}\) \}, syntax: Arrow \}\)+query error DataFusion error: This feature is not implemented: Unsupported ast node in sqltorel: Lambda\(LambdaFunction \{ params: One\(LambdaFunctionParameter \{ name: Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,34\)\.\.Location\(1,35\)\) \}, data_type: None \}\), body: BinaryOp \{ left: Identifier\(Ident \{ value: "v", quote_style: None, span: Span\(Location\(1,39\)\.\.Location\(1,40\)\) \}\), op: Plus, right: Value\(ValueWithSpan \{ value: Number\("1", false\), span: Span\(Location\(1,41\)\.\.Location\(1,42\)\) \}\) \}, syntax: Arrow \}\)SELECT array_transform([1], v -> v -> v+1);query error DataFusion error: SQL error: ParserError\("Expected: an expression, found: \) at Line: 1, Column: 30"\)