From 1ec6fe6986db682d51fe1f6e8309e9dd7543fe11 Mon Sep 17 00:00:00 2001 From: Jia-Xuan Liu Date: Thu, 12 Dec 2024 00:51:17 +0800 Subject: [PATCH 1/7] plan compound_field_access syntax --- Cargo.toml | 2 +- datafusion/sql/src/expr/mod.rs | 221 +++++++++++++++++----------- datafusion/sql/src/unparser/expr.rs | 10 +- 3 files changed, 145 insertions(+), 88 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2b854c6703496..bae417bcee57a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -147,7 +147,7 @@ recursive = "0.1.1" regex = "1.8" rstest = "0.23.0" serde_json = "1" -sqlparser = { version = "0.53.0", features = ["visitor"] } +sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev ="df3c5652b10493df4db484f358514bb210673744", features = ["visitor"] } tempfile = "3" tokio = { version = "1.36", features = ["macros", "rt", "sync"] } url = "2.2" diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rs index 9b40ebdaf6a5a..39d678fdadaca 100644 --- a/datafusion/sql/src/expr/mod.rs +++ b/datafusion/sql/src/expr/mod.rs @@ -21,14 +21,15 @@ use datafusion_expr::planner::{ PlannerResult, RawBinaryExpr, RawDictionaryExpr, RawFieldAccessExpr, }; use sqlparser::ast::{ - BinaryOperator, CastFormat, CastKind, DataType as SQLDataType, DictionaryField, - Expr as SQLExpr, ExprWithAlias as SQLExprWithAlias, MapEntry, StructField, Subscript, - TrimWhereField, Value, + AccessExpr, BinaryOperator, CastFormat, CastKind, DataType as SQLDataType, + DictionaryField, Expr as SQLExpr, ExprWithAlias as SQLExprWithAlias, MapEntry, StructField, Subscript, + TrimWhereField, + Value, }; use datafusion_common::{ - internal_datafusion_err, internal_err, not_impl_err, plan_err, DFSchema, Result, - ScalarValue, + internal_datafusion_err, internal_err, not_impl_err, plan_err, Column, DFSchema, + Result, ScalarValue, }; use datafusion_expr::expr::ScalarFunction; use datafusion_expr::expr::{InList, WildcardOptions}; @@ -235,15 +236,14 @@ impl SqlToRel<'_, S> { SQLExpr::Identifier(id) => { self.sql_identifier_to_expr(id, schema, planner_context) } - - SQLExpr::MapAccess { .. } => { - not_impl_err!("Map Access") - } - // ["foo"], [4] or [4:5] - SQLExpr::Subscript { expr, subscript } => { - self.sql_subscript_to_expr(*expr, subscript, schema, planner_context) - } + SQLExpr::CompoundFieldAccess { root, access_chain } => self + .sql_compound_field_access_to_expr( + *root, + access_chain, + schema, + planner_context, + ), SQLExpr::CompoundIdentifier(ids) => { self.sql_compound_identifier_to_expr(ids, schema, planner_context) @@ -984,84 +984,141 @@ impl SqlToRel<'_, S> { Ok(Expr::Cast(Cast::new(Box::new(expr), dt))) } - fn sql_subscript_to_expr( + fn sql_compound_field_access_to_expr( &self, - expr: SQLExpr, - subscript: Box, + root: SQLExpr, + access_chain: Vec, schema: &DFSchema, planner_context: &mut PlannerContext, ) -> Result { - let expr = self.sql_expr_to_logical_expr(expr, schema, planner_context)?; - - let field_access = match *subscript { - Subscript::Index { index } => { - // index can be a name, in which case it is a named field access - match index { - SQLExpr::Value( - Value::SingleQuotedString(s) | Value::DoubleQuotedString(s), - ) => GetFieldAccess::NamedStructField { - name: ScalarValue::from(s), - }, - SQLExpr::JsonAccess { .. } => { - return not_impl_err!("JsonAccess"); + let mut root = self.sql_expr_to_logical_expr(root, schema, planner_context)?; + let fields = access_chain + .into_iter() + .map(|field| match field { + AccessExpr::Subscript(subscript) => { + match subscript { + Subscript::Index { index } => { + // index can be a name, in which case it is a named field access + match index { + SQLExpr::Value( + Value::SingleQuotedString(s) + | Value::DoubleQuotedString(s), + ) => Ok(Some(GetFieldAccess::NamedStructField { + name: ScalarValue::from(s), + })), + SQLExpr::JsonAccess { .. } => { + not_impl_err!("JsonAccess") + } + // otherwise treat like a list index + _ => Ok(Some(GetFieldAccess::ListIndex { + key: Box::new(self.sql_expr_to_logical_expr( + index, + schema, + planner_context, + )?), + })), + } + } + Subscript::Slice { + lower_bound, + upper_bound, + stride, + } => { + // Means access like [:2] + let lower_bound = if let Some(lower_bound) = lower_bound { + self.sql_expr_to_logical_expr( + lower_bound, + schema, + planner_context, + ) + } else { + not_impl_err!("Slice subscript requires a lower bound") + }?; + + // means access like [2:] + let upper_bound = if let Some(upper_bound) = upper_bound { + self.sql_expr_to_logical_expr( + upper_bound, + schema, + planner_context, + ) + } else { + not_impl_err!("Slice subscript requires an upper bound") + }?; + + // stride, default to 1 + let stride = if let Some(stride) = stride { + self.sql_expr_to_logical_expr( + stride, + schema, + planner_context, + )? + } else { + lit(1i64) + }; + + Ok(Some(GetFieldAccess::ListRange { + start: Box::new(lower_bound), + stop: Box::new(upper_bound), + stride: Box::new(stride), + })) + } } - // otherwise treat like a list index - _ => GetFieldAccess::ListIndex { - key: Box::new(self.sql_expr_to_logical_expr( - index, - schema, - planner_context, - )?), - }, } - } - Subscript::Slice { - lower_bound, - upper_bound, - stride, - } => { - // Means access like [:2] - let lower_bound = if let Some(lower_bound) = lower_bound { - self.sql_expr_to_logical_expr(lower_bound, schema, planner_context) - } else { - not_impl_err!("Slice subscript requires a lower bound") - }?; - - // means access like [2:] - let upper_bound = if let Some(upper_bound) = upper_bound { - self.sql_expr_to_logical_expr(upper_bound, schema, planner_context) - } else { - not_impl_err!("Slice subscript requires an upper bound") - }?; - - // stride, default to 1 - let stride = if let Some(stride) = stride { - self.sql_expr_to_logical_expr(stride, schema, planner_context)? - } else { - lit(1i64) - }; - - GetFieldAccess::ListRange { - start: Box::new(lower_bound), - stop: Box::new(upper_bound), - stride: Box::new(stride), + AccessExpr::Dot(expr) => { + let expr = + self.sql_expr_to_logical_expr(expr, schema, planner_context)?; + match expr { + Expr::Column(Column { name, relation }) => { + if let Some(relation) = &relation { + // If the first part of the dot access is a column reference, we should + // check if the column is from the same table as the root expression. + // If it is, we should replace the root expression with the column reference. + // Otherwise, we should treat the dot access as a named field access. + if relation.table() == root.schema_name().to_string() { + root = Expr::Column(Column { + name, + relation: Some(relation.clone()), + }); + Ok(None) + } else { + plan_err!( + "table name mismatch: {} != {}", + relation.table(), + root.schema_name() + ) + } + } else { + Ok(Some(GetFieldAccess::NamedStructField { + name: ScalarValue::from(name), + })) + } + } + _ => not_impl_err!( + "Dot access not supported for non-column expr: {expr:?}" + ), + } } - } - }; + }) + .collect::>>()?; - let mut field_access_expr = RawFieldAccessExpr { expr, field_access }; - for planner in self.context_provider.get_expr_planners() { - match planner.plan_field_access(field_access_expr, schema)? { - PlannerResult::Planned(expr) => return Ok(expr), - PlannerResult::Original(expr) => { - field_access_expr = expr; + fields + .into_iter() + .flatten() + .try_fold(root, |expr, field_access| { + let mut field_access_expr = RawFieldAccessExpr { expr, field_access }; + for planner in self.context_provider.get_expr_planners() { + match planner.plan_field_access(field_access_expr, schema)? { + PlannerResult::Planned(expr) => return Ok(expr), + PlannerResult::Original(expr) => { + field_access_expr = expr; + } + } } - } - } - - not_impl_err!( - "GetFieldAccess not supported by ExprPlanner: {field_access_expr:?}" - ) + not_impl_err!( + "GetFieldAccess not supported by ExprPlanner: {field_access_expr:?}" + ) + }) } } diff --git a/datafusion/sql/src/unparser/expr.rs b/datafusion/sql/src/unparser/expr.rs index d012d34377206..2b8e53c4243d2 100644 --- a/datafusion/sql/src/unparser/expr.rs +++ b/datafusion/sql/src/unparser/expr.rs @@ -18,8 +18,8 @@ use datafusion_expr::expr::Unnest; use sqlparser::ast::Value::SingleQuotedString; use sqlparser::ast::{ - self, Array, BinaryOperator, Expr as AstExpr, Function, Ident, Interval, ObjectName, - Subscript, TimezoneInfo, UnaryOperator, + self, AccessExpr, Array, BinaryOperator, Expr as AstExpr, Function, Ident, Interval, + ObjectName, Subscript, TimezoneInfo, UnaryOperator, }; use std::sync::Arc; use std::vec; @@ -523,9 +523,9 @@ impl Unparser<'_> { } let array = self.expr_to_sql(&args[0])?; let index = self.expr_to_sql(&args[1])?; - Ok(ast::Expr::Subscript { - expr: Box::new(array), - subscript: Box::new(Subscript::Index { index }), + Ok(ast::Expr::CompoundFieldAccess { + root: Box::new(array), + access_chain: vec![AccessExpr::Subscript(Subscript::Index { index })], }) } From 43e930784b6b95526cc068bd2f53821023e184ad Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Thu, 26 Dec 2024 15:29:59 +0800 Subject: [PATCH 2/7] fix compile --- datafusion/sql/src/expr/mod.rs | 5 ++--- datafusion/sql/src/planner.rs | 3 ++- datafusion/sql/src/statement.rs | 6 +++++- datafusion/sql/src/unparser/ast.rs | 1 + datafusion/sql/src/unparser/dialect.rs | 14 +++++++------- datafusion/sql/src/unparser/expr.rs | 3 ++- 6 files changed, 19 insertions(+), 13 deletions(-) diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rs index 39d678fdadaca..fcdb6825ce738 100644 --- a/datafusion/sql/src/expr/mod.rs +++ b/datafusion/sql/src/expr/mod.rs @@ -22,9 +22,8 @@ use datafusion_expr::planner::{ }; use sqlparser::ast::{ AccessExpr, BinaryOperator, CastFormat, CastKind, DataType as SQLDataType, - DictionaryField, Expr as SQLExpr, ExprWithAlias as SQLExprWithAlias, MapEntry, StructField, Subscript, - TrimWhereField, - Value, + DictionaryField, Expr as SQLExpr, ExprWithAlias as SQLExprWithAlias, MapEntry, + StructField, Subscript, TrimWhereField, Value, }; use datafusion_common::{ diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs index 628bcb2fbdcd9..c6975891482f7 100644 --- a/datafusion/sql/src/planner.rs +++ b/datafusion/sql/src/planner.rs @@ -430,7 +430,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> { SQLDataType::UnsignedBigInt(_) | SQLDataType::UnsignedInt8(_) => Ok(DataType::UInt64), SQLDataType::Float(_) => Ok(DataType::Float32), SQLDataType::Real | SQLDataType::Float4 => Ok(DataType::Float32), - SQLDataType::Double | SQLDataType::DoublePrecision | SQLDataType::Float8 => Ok(DataType::Float64), + SQLDataType::Double(_) | SQLDataType::DoublePrecision | SQLDataType::Float8 => Ok(DataType::Float64), SQLDataType::Char(_) | SQLDataType::Text | SQLDataType::String(_) => Ok(DataType::Utf8), @@ -514,6 +514,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> { | SQLDataType::Regclass | SQLDataType::Custom(_, _) | SQLDataType::Array(_) + | SQLDataType::AnyType | SQLDataType::Enum(_, _) | SQLDataType::Set(_) | SQLDataType::MediumInt(_) diff --git a/datafusion/sql/src/statement.rs b/datafusion/sql/src/statement.rs index dfd3a4fd76a2a..43cdc8032c091 100644 --- a/datafusion/sql/src/statement.rs +++ b/datafusion/sql/src/statement.rs @@ -56,7 +56,7 @@ use datafusion_expr::{ }; use sqlparser::ast::{ self, BeginTransactionKind, NullsDistinctOption, ShowStatementIn, - ShowStatementOptions, SqliteOnConflict, + ShowStatementOptions, SqliteOnConflict, UpdateTableFromKind, }; use sqlparser::ast::{ Assignment, AssignmentTarget, ColumnDef, CreateIndex, CreateTable, @@ -890,6 +890,10 @@ impl SqlToRel<'_, S> { if or.is_some() { plan_err!("ON conflict not supported")?; } + let from = from.map(|update| match update { + UpdateTableFromKind::BeforeSet(t) + | UpdateTableFromKind::AfterSet(t) => t, + }); self.update_to_plan(table, assignments, from, selection) } diff --git a/datafusion/sql/src/unparser/ast.rs b/datafusion/sql/src/unparser/ast.rs index e320a4510e465..6d77c01ea8881 100644 --- a/datafusion/sql/src/unparser/ast.rs +++ b/datafusion/sql/src/unparser/ast.rs @@ -466,6 +466,7 @@ impl TableRelationBuilder { partitions: self.partitions.clone(), with_ordinality: false, json_path: None, + sample: None, }) } fn create_empty() -> Self { diff --git a/datafusion/sql/src/unparser/dialect.rs b/datafusion/sql/src/unparser/dialect.rs index 3a44d7f0ec48d..e673dfa50669d 100644 --- a/datafusion/sql/src/unparser/dialect.rs +++ b/datafusion/sql/src/unparser/dialect.rs @@ -17,18 +17,18 @@ use std::sync::Arc; +use super::{utils::character_length_to_sql, utils::date_part_to_sql, Unparser}; use arrow_schema::TimeUnit; use datafusion_common::Result; use datafusion_expr::Expr; use regex::Regex; +use sqlparser::ast::ExactNumberInfo; use sqlparser::tokenizer::Span; use sqlparser::{ ast::{self, BinaryOperator, Function, Ident, ObjectName, TimezoneInfo}, keywords::ALL_KEYWORDS, }; -use super::{utils::character_length_to_sql, utils::date_part_to_sql, Unparser}; - /// `Dialect` to use for Unparsing /// /// The default dialect tries to avoid quoting identifiers unless necessary (e.g. `a` instead of `"a"`) @@ -60,7 +60,7 @@ pub trait Dialect: Send + Sync { /// Does the dialect use DOUBLE PRECISION to represent Float64 rather than DOUBLE? /// E.g. Postgres uses DOUBLE PRECISION instead of DOUBLE fn float64_ast_dtype(&self) -> ast::DataType { - ast::DataType::Double + ast::DataType::Double(ExactNumberInfo::None) } /// The SQL type to use for Arrow Utf8 unparsing @@ -272,13 +272,13 @@ impl PostgreSqlDialect { { if let ast::Expr::Cast { data_type, .. } = expr { // Don't create an additional cast wrapper if we can update the existing one - *data_type = ast::DataType::Numeric(ast::ExactNumberInfo::None); + *data_type = ast::DataType::Numeric(ExactNumberInfo::None); } else { // Wrap the expression in a new cast *expr = ast::Expr::Cast { kind: ast::CastKind::Cast, expr: Box::new(expr.clone()), - data_type: ast::DataType::Numeric(ast::ExactNumberInfo::None), + data_type: ast::DataType::Numeric(ExactNumberInfo::None), format: None, }; } @@ -469,7 +469,7 @@ impl Default for CustomDialect { supports_nulls_first_in_sort: true, use_timestamp_for_date64: false, interval_style: IntervalStyle::SQLStandard, - float64_ast_dtype: ast::DataType::Double, + float64_ast_dtype: ast::DataType::Double(ExactNumberInfo::None), utf8_cast_dtype: ast::DataType::Varchar(None), large_utf8_cast_dtype: ast::DataType::Text, date_field_extract_style: DateFieldExtractStyle::DatePart, @@ -650,7 +650,7 @@ impl CustomDialectBuilder { supports_nulls_first_in_sort: true, use_timestamp_for_date64: false, interval_style: IntervalStyle::PostgresVerbose, - float64_ast_dtype: ast::DataType::Double, + float64_ast_dtype: ast::DataType::Double(ExactNumberInfo::None), utf8_cast_dtype: ast::DataType::Varchar(None), large_utf8_cast_dtype: ast::DataType::Text, date_field_extract_style: DateFieldExtractStyle::DatePart, diff --git a/datafusion/sql/src/unparser/expr.rs b/datafusion/sql/src/unparser/expr.rs index 2b8e53c4243d2..f401668e53ab3 100644 --- a/datafusion/sql/src/unparser/expr.rs +++ b/datafusion/sql/src/unparser/expr.rs @@ -1633,6 +1633,7 @@ mod tests { use datafusion_functions_nested::expr_fn::{array_element, make_array}; use datafusion_functions_nested::map::map; use datafusion_functions_window::row_number::row_number_udwf; + use sqlparser::ast::ExactNumberInfo; use crate::unparser::dialect::{ CharacterLengthStyle, CustomDialect, CustomDialectBuilder, DateFieldExtractStyle, @@ -2123,7 +2124,7 @@ mod tests { #[test] fn custom_dialect_float64_ast_dtype() -> Result<()> { for (float64_ast_dtype, identifier) in [ - (ast::DataType::Double, "DOUBLE"), + (ast::DataType::Double(ExactNumberInfo::None), "DOUBLE"), (ast::DataType::DoublePrecision, "DOUBLE PRECISION"), ] { let dialect = CustomDialectBuilder::new() From 1108f75abb52a0d42d254b0e09234122b878df56 Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Fri, 27 Dec 2024 14:26:54 +0800 Subject: [PATCH 3/7] uprgrade sqlparser --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index bae417bcee57a..3460ccd954ca0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -147,7 +147,7 @@ recursive = "0.1.1" regex = "1.8" rstest = "0.23.0" serde_json = "1" -sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev ="df3c5652b10493df4db484f358514bb210673744", features = ["visitor"] } +sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev ="e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b", features = ["visitor"] } tempfile = "3" tokio = { version = "1.36", features = ["macros", "rt", "sync"] } url = "2.2" From 7096b765b869b622f623e97c960a44ba5c988a42 Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Fri, 27 Dec 2024 14:35:08 +0800 Subject: [PATCH 4/7] update lock --- datafusion-cli/Cargo.lock | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/datafusion-cli/Cargo.lock b/datafusion-cli/Cargo.lock index 863bb5181f451..febbe53f7f720 100644 --- a/datafusion-cli/Cargo.lock +++ b/datafusion-cli/Cargo.lock @@ -3765,18 +3765,17 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" [[package]] name = "sqlparser" version = "0.53.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05a528114c392209b3264855ad491fcce534b94a38771b0a0b97a79379275ce8" +source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b#e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b" dependencies = [ "log", + "recursive", "sqlparser_derive", ] [[package]] name = "sqlparser_derive" version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c" +source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b#e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b" dependencies = [ "proc-macro2", "quote", From 8bb87352a0f7574e12a3e5e4ed017d370a5956d7 Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Fri, 27 Dec 2024 14:53:14 +0800 Subject: [PATCH 5/7] taplo fmt --- Cargo.toml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 3460ccd954ca0..716fc2dfeec78 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -147,7 +147,9 @@ recursive = "0.1.1" regex = "1.8" rstest = "0.23.0" serde_json = "1" -sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev ="e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b", features = ["visitor"] } +sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev = "e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b", features = [ + "visitor", +] } tempfile = "3" tokio = { version = "1.36", features = ["macros", "rt", "sync"] } url = "2.2" From 572ea6ec11903a390f5b73abc4fbe9640d047388 Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Sat, 28 Dec 2024 19:41:14 +0800 Subject: [PATCH 6/7] upgrade sqlparser --- Cargo.toml | 2 +- datafusion/sql/src/parser.rs | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 716fc2dfeec78..5c56ace7135bc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -147,7 +147,7 @@ recursive = "0.1.1" regex = "1.8" rstest = "0.23.0" serde_json = "1" -sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev = "e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b", features = [ +sqlparser = { git = "https://github.com/apache/datafusion-sqlparser-rs.git", rev = "6cbcfda74618e9d42caf4875b135288be1594cf0", features = [ "visitor", ] } tempfile = "3" diff --git a/datafusion/sql/src/parser.rs b/datafusion/sql/src/parser.rs index f185d65fa1947..7e39141720f5c 100644 --- a/datafusion/sql/src/parser.rs +++ b/datafusion/sql/src/parser.rs @@ -563,7 +563,7 @@ impl<'a> DFParser<'a> { loop { if let Token::Word(_) = self.parser.peek_token().token { - let identifier = self.parser.parse_identifier(false)?; + let identifier = self.parser.parse_identifier()?; partitions.push(identifier.to_string()); } else { return self.expected("partition name", self.parser.peek_token()); @@ -666,7 +666,7 @@ impl<'a> DFParser<'a> { } fn parse_column_def(&mut self) -> Result { - let name = self.parser.parse_identifier(false)?; + let name = self.parser.parse_identifier()?; let data_type = self.parser.parse_data_type()?; let collation = if self.parser.parse_keyword(Keyword::COLLATE) { Some(self.parser.parse_object_name(false)?) @@ -676,7 +676,7 @@ impl<'a> DFParser<'a> { let mut options = vec![]; loop { if self.parser.parse_keyword(Keyword::CONSTRAINT) { - let name = Some(self.parser.parse_identifier(false)?); + let name = Some(self.parser.parse_identifier()?); if let Some(option) = self.parser.parse_optional_column_option()? { options.push(ColumnOptionDef { name, option }); } else { From 56a96ab5b5de4f8e31cc4d95d95481afccc3897c Mon Sep 17 00:00:00 2001 From: Jax Liu Date: Sat, 28 Dec 2024 21:03:27 +0800 Subject: [PATCH 7/7] cargo update --- datafusion-cli/Cargo.lock | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/datafusion-cli/Cargo.lock b/datafusion-cli/Cargo.lock index febbe53f7f720..982d0280e74b0 100644 --- a/datafusion-cli/Cargo.lock +++ b/datafusion-cli/Cargo.lock @@ -1757,7 +1757,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.52.0", ] [[package]] @@ -3142,7 +3142,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.59.0", + "windows-sys 0.52.0", ] [[package]] @@ -3402,7 +3402,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.59.0", + "windows-sys 0.52.0", ] [[package]] @@ -3765,7 +3765,7 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" [[package]] name = "sqlparser" version = "0.53.0" -source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b#e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b" +source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=6cbcfda74618e9d42caf4875b135288be1594cf0#6cbcfda74618e9d42caf4875b135288be1594cf0" dependencies = [ "log", "recursive", @@ -3775,7 +3775,7 @@ dependencies = [ [[package]] name = "sqlparser_derive" version = "0.3.0" -source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b#e9c3305008b4e0a28fb42a2fe6b18b3bd2a8291b" +source = "git+https://github.com/apache/datafusion-sqlparser-rs.git?rev=6cbcfda74618e9d42caf4875b135288be1594cf0#6cbcfda74618e9d42caf4875b135288be1594cf0" dependencies = [ "proc-macro2", "quote", @@ -3798,7 +3798,7 @@ dependencies = [ "cfg-if", "libc", "psm", - "windows-sys 0.59.0", + "windows-sys 0.52.0", ] [[package]] @@ -3879,7 +3879,7 @@ dependencies = [ "fastrand", "once_cell", "rustix", - "windows-sys 0.59.0", + "windows-sys 0.52.0", ] [[package]]