mirrors/datafusion-sqlparse
1
0
Fork 0
mirror of https://github.com/apache/datafusion-sqlparser-rs.git synced 2025-08-04 06:18:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Enhance object name path segments (#1539)

Browse source
This commit is contained in:
Ayman Elkfrawy 2025-01-26 06:13:51 -08:00 • committed by GitHub
parent fd6c98e933
commit 211b15e790
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
20 changed files with 584 additions and 466 deletions
Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -53,7 +53,7 @@ println!("AST: {:?}", ast);
This outputs This outputs
```rust ```rust
AST: [Query(Query { ctes: [], body: Select(Select { distinct: false, projection: [UnnamedExpr(Identifier("a")), UnnamedExpr(Identifier("b")), UnnamedExpr(Value(Long(123))), UnnamedExpr(Function(Function { name: ObjectName(["myfunc"]), args: [Identifier("b")], filter: None, over: None, distinct: false }))], from: [TableWithJoins { relation: Table { name: ObjectName(["table_1"]), alias: None, args: [], with_hints: [] }, joins: [] }], selection: Some(BinaryOp { left: BinaryOp { left: Identifier("a"), op: Gt, right: Identifier("b") }, op: And, right: BinaryOp { left: Identifier("b"), op: Lt, right: Value(Long(100)) } }), group_by: [], having: None }), order_by: [OrderByExpr { expr: Identifier("a"), asc: Some(false) }, OrderByExpr { expr: Identifier("b"), asc: None }], limit: None, offset: None, fetch: None })] AST: [Query(Query { ctes: [], body: Select(Select { distinct: false, projection: [UnnamedExpr(Identifier("a")), UnnamedExpr(Identifier("b")), UnnamedExpr(Value(Long(123))), UnnamedExpr(Function(Function { name:ObjectName([Identifier(Ident { value: "myfunc", quote_style: None })]), args: [Identifier("b")], filter: None, over: None, distinct: false }))], from: [TableWithJoins { relation: Table { name: ObjectName([Identifier(Ident { value: "table_1", quote_style: None })]), alias: None, args: [], with_hints: [] }, joins: [] }], selection: Some(BinaryOp { left: BinaryOp { left: Identifier("a"), op: Gt, right: Identifier("b") }, op: And, right: BinaryOp { left: Identifier("b"), op: Lt, right: Value(Long(100)) } }), group_by: [], having: None }), order_by: [OrderByExpr { expr: Identifier("a"), asc: Some(false) }, OrderByExpr { expr: Identifier("b"), asc: None }], limit: None, offset: None, fetch: None })]
``` ```

4
src/ast/helpers/stmt_create_table.rs
View file

@ -42,7 +42,7 @@ use crate::parser::ParserError;
/// ```rust /// ```rust
/// use sqlparser::ast::helpers::stmt_create_table::CreateTableBuilder; /// use sqlparser::ast::helpers::stmt_create_table::CreateTableBuilder;
/// use sqlparser::ast::{ColumnDef, DataType, Ident, ObjectName}; /// use sqlparser::ast::{ColumnDef, DataType, Ident, ObjectName};
/// let builder = CreateTableBuilder::new(ObjectName(vec![Ident::new("table_name")])) /// let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")]))
/// .if_not_exists(true) /// .if_not_exists(true)
/// .columns(vec![ColumnDef { /// .columns(vec![ColumnDef {
/// name: Ident::new("c1"), /// name: Ident::new("c1"),
@ -602,7 +602,7 @@ mod tests {
#[test] #[test]
pub fn test_from_valid_statement() { pub fn test_from_valid_statement() {
let builder = CreateTableBuilder::new(ObjectName(vec![Ident::new("table_name")])); let builder = CreateTableBuilder::new(ObjectName::from(vec![Ident::new("table_name")]));
let stmt = builder.clone().build(); let stmt = builder.clone().build();

32
src/ast/mod.rs
View file

@ -267,7 +267,13 @@ impl fmt::Display for Ident {
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))] #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub struct ObjectName(pub Vec<Ident>); pub struct ObjectName(pub Vec<ObjectNamePart>);
impl From<Vec<Ident>> for ObjectName {
fn from(idents: Vec<Ident>) -> Self {
ObjectName(idents.into_iter().map(ObjectNamePart::Identifier).collect())
}
}
impl fmt::Display for ObjectName { impl fmt::Display for ObjectName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -275,6 +281,30 @@ impl fmt::Display for ObjectName {
} }
} }
/// A single part of an ObjectName
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
pub enum ObjectNamePart {
Identifier(Ident),
}
impl ObjectNamePart {
pub fn as_ident(&self) -> Option<&Ident> {
match self {
ObjectNamePart::Identifier(ident) => Some(ident),
}
}
}
impl fmt::Display for ObjectNamePart {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ObjectNamePart::Identifier(ident) => write!(f, "{}", ident),
}
}
}
/// Represents an Array Expression, either /// Represents an Array Expression, either
/// `ARRAY[..]`, or `[..]` /// `ARRAY[..]`, or `[..]`
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)] #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

40
src/ast/spans.rs
View file

@ -28,13 +28,13 @@ use super::{
FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments, FunctionArg, FunctionArgExpr, FunctionArgumentClause, FunctionArgumentList, FunctionArguments,
GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join, GroupByExpr, HavingBound, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join,
JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern, JoinConstraint, JoinOperator, JsonPath, JsonPathElem, LateralView, MatchRecognizePattern,
Measure, NamedWindowDefinition, ObjectName, Offset, OnConflict, OnConflictAction, OnInsert, Measure, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
OrderBy, OrderByExpr, Partition, PivotValueSource, ProjectionSelect, Query, ReferentialAction, OnConflictAction, OnInsert, OrderBy, OrderByExpr, Partition, PivotValueSource,
RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem, ProjectionSelect, Query, ReferentialAction, RenameSelectItem, ReplaceSelectElement,
SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption, Statement, Subscript,
TableConstraint, TableFactor, TableObject, TableOptionsClustered, TableWithJoins, SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint, TableFactor, TableObject,
UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WildcardAdditionalOptions, With, TableOptionsClustered, TableWithJoins, UpdateTableFromKind, Use, Value, Values, ViewColumnDef,
WithFill, WildcardAdditionalOptions, With, WithFill,
}; };
/// Given an iterator of spans, return the [Span::union] of all spans. /// Given an iterator of spans, return the [Span::union] of all spans.
@ -1358,7 +1358,7 @@ impl Spanned for Expr {
.union_opt(&overlay_for.as_ref().map(|i| i.span())), .union_opt(&overlay_for.as_ref().map(|i| i.span())),
Expr::Collate { expr, collation } => expr Expr::Collate { expr, collation } => expr
.span() .span()
.union(&union_spans(collation.0.iter().map(|i| i.span))), .union(&union_spans(collation.0.iter().map(|i| i.span()))),
Expr::Nested(expr) => expr.span(), Expr::Nested(expr) => expr.span(),
Expr::Value(value) => value.span(), Expr::Value(value) => value.span(),
Expr::TypedString { .. } => Span::empty(), Expr::TypedString { .. } => Span::empty(),
@ -1462,7 +1462,7 @@ impl Spanned for Expr {
object_name object_name
.0 .0
.iter() .iter()
.map(|i| i.span) .map(|i| i.span())
.chain(iter::once(token.0.span)), .chain(iter::once(token.0.span)),
), ),
Expr::OuterJoin(expr) => expr.span(), Expr::OuterJoin(expr) => expr.span(),
@ -1507,7 +1507,15 @@ impl Spanned for ObjectName {
fn span(&self) -> Span { fn span(&self) -> Span {
let ObjectName(segments) = self; let ObjectName(segments) = self;
union_spans(segments.iter().map(|i| i.span)) union_spans(segments.iter().map(|i| i.span()))
}
}
impl Spanned for ObjectNamePart {
fn span(&self) -> Span {
match self {
ObjectNamePart::Identifier(ident) => ident.span,
}
} }
} }
@ -1538,7 +1546,7 @@ impl Spanned for Function {
union_spans( union_spans(
name.0 name.0
.iter() .iter()
.map(|i| i.span) .map(|i| i.span())
.chain(iter::once(args.span())) .chain(iter::once(args.span()))
.chain(iter::once(parameters.span())) .chain(iter::once(parameters.span()))
.chain(filter.iter().map(|i| i.span())) .chain(filter.iter().map(|i| i.span()))
@ -1624,7 +1632,7 @@ impl Spanned for SelectItem {
object_name object_name
.0 .0
.iter() .iter()
.map(|i| i.span) .map(|i| i.span())
.chain(iter::once(wildcard_additional_options.span())), .chain(iter::once(wildcard_additional_options.span())),
), ),
SelectItem::Wildcard(wildcard_additional_options) => wildcard_additional_options.span(), SelectItem::Wildcard(wildcard_additional_options) => wildcard_additional_options.span(),
@ -1734,7 +1742,7 @@ impl Spanned for TableFactor {
} => union_spans( } => union_spans(
name.0 name.0
.iter() .iter()
.map(|i| i.span) .map(|i| i.span())
.chain(alias.as_ref().map(|alias| { .chain(alias.as_ref().map(|alias| {
union_spans( union_spans(
iter::once(alias.name.span) iter::once(alias.name.span)
@ -1779,7 +1787,7 @@ impl Spanned for TableFactor {
} => union_spans( } => union_spans(
name.0 name.0
.iter() .iter()
.map(|i| i.span) .map(|i| i.span())
.chain(args.iter().map(|i| i.span())) .chain(args.iter().map(|i| i.span()))
.chain(alias.as_ref().map(|alias| alias.span())), .chain(alias.as_ref().map(|alias| alias.span())),
), ),
@ -1930,7 +1938,7 @@ impl Spanned for FunctionArgExpr {
match self { match self {
FunctionArgExpr::Expr(expr) => expr.span(), FunctionArgExpr::Expr(expr) => expr.span(),
FunctionArgExpr::QualifiedWildcard(object_name) => { FunctionArgExpr::QualifiedWildcard(object_name) => {
union_spans(object_name.0.iter().map(|i| i.span)) union_spans(object_name.0.iter().map(|i| i.span()))
} }
FunctionArgExpr::Wildcard => Span::empty(), FunctionArgExpr::Wildcard => Span::empty(),
} }
@ -2141,7 +2149,7 @@ impl Spanned for TableObject {
fn span(&self) -> Span { fn span(&self) -> Span {
match self { match self {
TableObject::TableName(ObjectName(segments)) => { TableObject::TableName(ObjectName(segments)) => {
union_spans(segments.iter().map(|i| i.span)) union_spans(segments.iter().map(|i| i.span()))
} }
TableObject::TableFunction(func) => func.span(), TableObject::TableFunction(func) => func.span(),
} }

6
src/ast/visitor.rs
View file

@ -403,7 +403,7 @@ where
/// ``` /// ```
/// # use sqlparser::parser::Parser; /// # use sqlparser::parser::Parser;
/// # use sqlparser::dialect::GenericDialect; /// # use sqlparser::dialect::GenericDialect;
/// # use sqlparser::ast::{ObjectName, visit_relations_mut}; /// # use sqlparser::ast::{ObjectName, ObjectNamePart, Ident, visit_relations_mut};
/// # use core::ops::ControlFlow; /// # use core::ops::ControlFlow;
/// let sql = "SELECT a FROM foo"; /// let sql = "SELECT a FROM foo";
/// let mut statements = Parser::parse_sql(&GenericDialect{}, sql) /// let mut statements = Parser::parse_sql(&GenericDialect{}, sql)
@ -411,7 +411,7 @@ where
/// ///
/// // visit statements, renaming table foo to bar /// // visit statements, renaming table foo to bar
/// visit_relations_mut(&mut statements, |table| { /// visit_relations_mut(&mut statements, |table| {
/// table.0[0].value = table.0[0].value.replace("foo", "bar"); /// table.0[0] = ObjectNamePart::Identifier(Ident::new("bar"));
/// ControlFlow::<()>::Continue(()) /// ControlFlow::<()>::Continue(())
/// }); /// });
/// ///
@ -529,7 +529,7 @@ where
/// if matches!(expr, Expr::Identifier(col_name) if col_name.value == "x") { /// if matches!(expr, Expr::Identifier(col_name) if col_name.value == "x") {
/// let old_expr = std::mem::replace(expr, Expr::Value(Value::Null)); /// let old_expr = std::mem::replace(expr, Expr::Value(Value::Null));
/// *expr = Expr::Function(Function { /// *expr = Expr::Function(Function {
/// name: ObjectName(vec![Ident::new("f")]), /// name: ObjectName::from(vec![Ident::new("f")]),
/// uses_odbc_syntax: false, /// uses_odbc_syntax: false,
/// args: FunctionArguments::List(FunctionArgumentList { /// args: FunctionArguments::List(FunctionArgumentList {
/// duplicate_treatment: None, /// duplicate_treatment: None,

2
src/dialect/snowflake.rs
View file

@ -651,7 +651,7 @@ pub fn parse_snowflake_stage_name(parser: &mut Parser) -> Result<ObjectName, Par
break; break;
} }
} }
Ok(ObjectName(idents)) Ok(ObjectName::from(idents))
} }
_ => { _ => {
parser.prev_token(); parser.prev_token();

93
src/parser/mod.rs
View file

@ -988,7 +988,7 @@ impl<'a> Parser<'a> {
} }
Token::Mul => { Token::Mul => {
return Ok(Expr::QualifiedWildcard( return Ok(Expr::QualifiedWildcard(
ObjectName(id_parts), ObjectName::from(id_parts),
AttachedToken(next_token), AttachedToken(next_token),
)); ));
} }
@ -1128,7 +1128,7 @@ impl<'a> Parser<'a> {
if dialect_of!(self is PostgreSqlDialect | GenericDialect) => if dialect_of!(self is PostgreSqlDialect | GenericDialect) =>
{ {
Ok(Some(Expr::Function(Function { Ok(Some(Expr::Function(Function {
name: ObjectName(vec![w.clone().into_ident(w_span)]), name: ObjectName::from(vec![w.clone().into_ident(w_span)]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::None, args: FunctionArguments::None,
@ -1143,7 +1143,7 @@ impl<'a> Parser<'a> {
| Keyword::CURRENT_DATE | Keyword::CURRENT_DATE
| Keyword::LOCALTIME | Keyword::LOCALTIME
| Keyword::LOCALTIMESTAMP => { | Keyword::LOCALTIMESTAMP => {
Ok(Some(self.parse_time_functions(ObjectName(vec![w.clone().into_ident(w_span)]))?)) Ok(Some(self.parse_time_functions(ObjectName::from(vec![w.clone().into_ident(w_span)]))?))
} }
Keyword::CASE => Ok(Some(self.parse_case_expr()?)), Keyword::CASE => Ok(Some(self.parse_case_expr()?)),
Keyword::CONVERT => Ok(Some(self.parse_convert_expr(false)?)), Keyword::CONVERT => Ok(Some(self.parse_convert_expr(false)?)),
@ -1187,7 +1187,7 @@ impl<'a> Parser<'a> {
let query = self.parse_query()?; let query = self.parse_query()?;
self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?;
Ok(Some(Expr::Function(Function { Ok(Some(Expr::Function(Function {
name: ObjectName(vec![w.clone().into_ident(w_span)]), name: ObjectName::from(vec![w.clone().into_ident(w_span)]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::Subquery(query), args: FunctionArguments::Subquery(query),
@ -1232,7 +1232,7 @@ impl<'a> Parser<'a> {
if let Some(expr) = self.parse_outer_join_expr(&id_parts) { if let Some(expr) = self.parse_outer_join_expr(&id_parts) {
Ok(expr) Ok(expr)
} else { } else {
let mut expr = self.parse_function(ObjectName(id_parts))?; let mut expr = self.parse_function(ObjectName::from(id_parts))?;
// consume all period if it's a method chain // consume all period if it's a method chain
expr = self.try_parse_method(expr)?; expr = self.try_parse_method(expr)?;
let fields = vec![]; let fields = vec![];
@ -1553,7 +1553,7 @@ impl<'a> Parser<'a> {
return self.expected("an identifier or a '*' after '.'", self.peek_token()); return self.expected("an identifier or a '*' after '.'", self.peek_token());
}; };
Ok(Expr::QualifiedWildcard( Ok(Expr::QualifiedWildcard(
ObjectName(Self::exprs_to_idents(root, chain)?), ObjectName::from(Self::exprs_to_idents(root, chain)?),
AttachedToken(wildcard_token), AttachedToken(wildcard_token),
)) ))
} else if self.peek_token().token == Token::LParen { } else if self.peek_token().token == Token::LParen {
@ -1566,7 +1566,7 @@ impl<'a> Parser<'a> {
if let Some(expr) = self.parse_outer_join_expr(&id_parts) { if let Some(expr) = self.parse_outer_join_expr(&id_parts) {
Ok(expr) Ok(expr)
} else { } else {
self.parse_function(ObjectName(id_parts)) self.parse_function(ObjectName::from(id_parts))
} }
} else { } else {
if Self::is_all_ident(&root, &chain) { if Self::is_all_ident(&root, &chain) {
@ -1694,7 +1694,7 @@ impl<'a> Parser<'a> {
Token::Word(word) => word.into_ident(tok.span), Token::Word(word) => word.into_ident(tok.span),
_ => return p.expected("identifier", tok), _ => return p.expected("identifier", tok),
}; };
let func = match p.parse_function(ObjectName(vec![name]))? { let func = match p.parse_function(ObjectName::from(vec![name]))? {
Expr::Function(func) => func, Expr::Function(func) => func,
_ => return p.expected("function", p.peek_token()), _ => return p.expected("function", p.peek_token()),
}; };
@ -2197,7 +2197,7 @@ impl<'a> Parser<'a> {
Some(expr) => Ok(expr), Some(expr) => Ok(expr),
// Snowflake supports `position` as an ordinary function call // Snowflake supports `position` as an ordinary function call
// without the special `IN` syntax. // without the special `IN` syntax.
None => self.parse_function(ObjectName(vec![ident])), None => self.parse_function(ObjectName::from(vec![ident])),
} }
} }
@ -4044,6 +4044,21 @@ impl<'a> Parser<'a> {
Ok(values) Ok(values)
} }
/// Parse a period-separated list of 1+ items accepted by `F`
fn parse_period_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
where
F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
{
let mut values = vec![];
loop {
values.push(f(self)?);
if !self.consume_token(&Token::Period) {
break;
}
}
Ok(values)
}
/// Parse a keyword-separated list of 1+ items accepted by `F` /// Parse a keyword-separated list of 1+ items accepted by `F`
pub fn parse_keyword_separated<T, F>( pub fn parse_keyword_separated<T, F>(
&mut self, &mut self,
@ -4757,7 +4772,9 @@ impl<'a> Parser<'a> {
let mut data_type = self.parse_data_type()?; let mut data_type = self.parse_data_type()?;
if let DataType::Custom(n, _) = &data_type { if let DataType::Custom(n, _) = &data_type {
// the first token is actually a name // the first token is actually a name
name = Some(n.0[0].clone()); match n.0[0].clone() {
ObjectNamePart::Identifier(ident) => name = Some(ident),
}
data_type = self.parse_data_type()?; data_type = self.parse_data_type()?;
} }
@ -9063,7 +9080,7 @@ impl<'a> Parser<'a> {
} }
} }
} }
Ok(ObjectName(idents)) Ok(ObjectName::from(idents))
} }
/// Parse a possibly qualified, possibly quoted identifier, e.g. /// Parse a possibly qualified, possibly quoted identifier, e.g.
@ -9079,20 +9096,26 @@ impl<'a> Parser<'a> {
// BigQuery accepts any number of quoted identifiers of a table name. // BigQuery accepts any number of quoted identifiers of a table name.
// https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_identifiers // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_identifiers
if dialect_of!(self is BigQueryDialect) if dialect_of!(self is BigQueryDialect)
&& idents.iter().any(|ident| ident.value.contains('.')) && idents.iter().any(|part| {
part.as_ident()
.is_some_and(|ident| ident.value.contains('.'))
})
{ {
idents = idents idents = idents
.into_iter() .into_iter()
.flat_map(|ident| { .flat_map(|part| match part.as_ident() {
ident Some(ident) => ident
.value .value
.split('.') .split('.')
.map(|value| Ident { .map(|value| {
value: value.into(), ObjectNamePart::Identifier(Ident {
quote_style: ident.quote_style, value: value.into(),
span: ident.span, quote_style: ident.quote_style,
span: ident.span,
})
}) })
.collect::<Vec<_>>() .collect::<Vec<_>>(),
None => vec![part],
}) })
.collect() .collect()
} }
@ -10427,14 +10450,14 @@ impl<'a> Parser<'a> {
} }
let variables = if self.parse_keywords(&[Keyword::TIME, Keyword::ZONE]) { let variables = if self.parse_keywords(&[Keyword::TIME, Keyword::ZONE]) {
OneOrManyWithParens::One(ObjectName(vec!["TIMEZONE".into()])) OneOrManyWithParens::One(ObjectName::from(vec!["TIMEZONE".into()]))
} else if self.dialect.supports_parenthesized_set_variables() } else if self.dialect.supports_parenthesized_set_variables()
&& self.consume_token(&Token::LParen) && self.consume_token(&Token::LParen)
{ {
let variables = OneOrManyWithParens::Many( let variables = OneOrManyWithParens::Many(
self.parse_comma_separated(|parser: &mut Parser<'a>| parser.parse_identifier())? self.parse_comma_separated(|parser: &mut Parser<'a>| parser.parse_identifier())?
.into_iter() .into_iter()
.map(|ident| ObjectName(vec![ident])) .map(|ident| ObjectName::from(vec![ident]))
.collect(), .collect(),
); );
self.expect_token(&Token::RParen)?; self.expect_token(&Token::RParen)?;
@ -11770,7 +11793,7 @@ impl<'a> Parser<'a> {
Token::Word(w) => Ok(w.value), Token::Word(w) => Ok(w.value),
_ => self.expected("a function identifier", self.peek_token()), _ => self.expected("a function identifier", self.peek_token()),
}?; }?;
let expr = self.parse_function(ObjectName(vec![Ident::new(function_name)]))?; let expr = self.parse_function(ObjectName::from(vec![Ident::new(function_name)]))?;
let alias = if self.parse_keyword(Keyword::AS) { let alias = if self.parse_keyword(Keyword::AS) {
Some(self.parse_identifier()?) Some(self.parse_identifier()?)
} else { } else {
@ -11819,7 +11842,7 @@ impl<'a> Parser<'a> {
self.expect_token(&Token::LParen)?; self.expect_token(&Token::LParen)?;
let aggregate_functions = self.parse_comma_separated(Self::parse_aliased_function_call)?; let aggregate_functions = self.parse_comma_separated(Self::parse_aliased_function_call)?;
self.expect_keyword_is(Keyword::FOR)?; self.expect_keyword_is(Keyword::FOR)?;
let value_column = self.parse_object_name(false)?.0; let value_column = self.parse_period_separated(|p| p.parse_identifier())?;
self.expect_keyword_is(Keyword::IN)?; self.expect_keyword_is(Keyword::IN)?;
self.expect_token(&Token::LParen)?; self.expect_token(&Token::LParen)?;
@ -11955,10 +11978,9 @@ impl<'a> Parser<'a> {
// https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html // https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html
let ident = self.parse_identifier()?; let ident = self.parse_identifier()?;
if let GranteeName::ObjectName(namespace) = name { if let GranteeName::ObjectName(namespace) = name {
name = GranteeName::ObjectName(ObjectName(vec![Ident::new(format!( name = GranteeName::ObjectName(ObjectName::from(vec![Ident::new(
"{}:{}", format!("{}:{}", namespace, ident),
namespace, ident )]));
))]));
}; };
} }
Grantee { Grantee {
@ -12267,9 +12289,10 @@ impl<'a> Parser<'a> {
let mut name = self.parse_object_name(false)?; let mut name = self.parse_object_name(false)?;
if self.dialect.supports_user_host_grantee() if self.dialect.supports_user_host_grantee()
&& name.0.len() == 1 && name.0.len() == 1
&& name.0[0].as_ident().is_some()
&& self.consume_token(&Token::AtSign) && self.consume_token(&Token::AtSign)
{ {
let user = name.0.pop().unwrap(); let user = name.0.pop().unwrap().as_ident().unwrap().clone();
let host = self.parse_identifier()?; let host = self.parse_identifier()?;
Ok(GranteeName::UserHost { user, host }) Ok(GranteeName::UserHost { user, host })
} else { } else {
@ -13781,7 +13804,7 @@ impl<'a> Parser<'a> {
// [ OWNED BY { table_name.column_name | NONE } ] // [ OWNED BY { table_name.column_name | NONE } ]
let owned_by = if self.parse_keywords(&[Keyword::OWNED, Keyword::BY]) { let owned_by = if self.parse_keywords(&[Keyword::OWNED, Keyword::BY]) {
if self.parse_keywords(&[Keyword::NONE]) { if self.parse_keywords(&[Keyword::NONE]) {
Some(ObjectName(vec![Ident::new("NONE")])) Some(ObjectName::from(vec![Ident::new("NONE")]))
} else { } else {
Some(self.parse_object_name(false)?) Some(self.parse_object_name(false)?)
} }
@ -14072,7 +14095,9 @@ impl<'a> Parser<'a> {
.parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]) .parse_one_of_keywords(&[Keyword::FROM, Keyword::IN])
.is_some() .is_some()
{ {
parent_name.0.insert(0, self.parse_identifier()?); parent_name
.0
.insert(0, ObjectNamePart::Identifier(self.parse_identifier()?));
} }
(None, Some(parent_name)) (None, Some(parent_name))
} }
@ -14388,14 +14413,14 @@ mod tests {
test_parse_data_type!( test_parse_data_type!(
dialect, dialect,
"GEOMETRY", "GEOMETRY",
DataType::Custom(ObjectName(vec!["GEOMETRY".into()]), vec![]) DataType::Custom(ObjectName::from(vec!["GEOMETRY".into()]), vec![])
); );
test_parse_data_type!( test_parse_data_type!(
dialect, dialect,
"GEOMETRY(POINT)", "GEOMETRY(POINT)",
DataType::Custom( DataType::Custom(
ObjectName(vec!["GEOMETRY".into()]), ObjectName::from(vec!["GEOMETRY".into()]),
vec!["POINT".to_string()] vec!["POINT".to_string()]
) )
); );
@ -14404,7 +14429,7 @@ mod tests {
dialect, dialect,
"GEOMETRY(POINT, 4326)", "GEOMETRY(POINT, 4326)",
DataType::Custom( DataType::Custom(
ObjectName(vec!["GEOMETRY".into()]), ObjectName::from(vec!["GEOMETRY".into()]),
vec!["POINT".to_string(), "4326".to_string()] vec!["POINT".to_string(), "4326".to_string()]
) )
); );
@ -14540,7 +14565,7 @@ mod tests {
}}; }};
} }
let dummy_name = ObjectName(vec![Ident::new("dummy_name")]); let dummy_name = ObjectName::from(vec![Ident::new("dummy_name")]);
let dummy_authorization = Ident::new("dummy_authorization"); let dummy_authorization = Ident::new("dummy_authorization");
test_parse_schema_name!( test_parse_schema_name!(

6
src/test_utils.rs
View file

@ -353,7 +353,7 @@ pub fn table_alias(name: impl Into<String>) -> Option<TableAlias> {
pub fn table(name: impl Into<String>) -> TableFactor { pub fn table(name: impl Into<String>) -> TableFactor {
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new(name.into())]), name: ObjectName::from(vec![Ident::new(name.into())]),
alias: None, alias: None,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -381,7 +381,7 @@ pub fn table_from_name(name: ObjectName) -> TableFactor {
pub fn table_with_alias(name: impl Into<String>, alias: impl Into<String>) -> TableFactor { pub fn table_with_alias(name: impl Into<String>, alias: impl Into<String>) -> TableFactor {
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new(name)]), name: ObjectName::from(vec![Ident::new(name)]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new(alias), name: Ident::new(alias),
columns: vec![], columns: vec![],
@ -406,7 +406,7 @@ pub fn join(relation: TableFactor) -> Join {
pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr { pub fn call(function: &str, args: impl IntoIterator<Item = Expr>) -> Expr {
Expr::Function(Function { Expr::Function(Function {
name: ObjectName(vec![Ident::new(function)]), name: ObjectName::from(vec![Ident::new(function)]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {

31
tests/sqlparser_bigquery.rs
View file

@ -222,7 +222,7 @@ fn parse_delete_statement() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![Ident::with_quote('"', "table")])), table_from_name(ObjectName::from(vec![Ident::with_quote('"', "table")])),
from[0].relation from[0].relation
); );
} }
@ -249,7 +249,7 @@ fn parse_create_view_with_options() {
} => { } => {
assert_eq!( assert_eq!(
name, name,
ObjectName(vec![ ObjectName::from(vec![
"myproject".into(), "myproject".into(),
"mydataset".into(), "mydataset".into(),
"newview".into() "newview".into()
@ -356,7 +356,7 @@ fn parse_create_table_with_unquoted_hyphen() {
Statement::CreateTable(CreateTable { name, columns, .. }) => { Statement::CreateTable(CreateTable { name, columns, .. }) => {
assert_eq!( assert_eq!(
name, name,
ObjectName(vec![ ObjectName::from(vec![
"my-pro-ject".into(), "my-pro-ject".into(),
"mydataset".into(), "mydataset".into(),
"mytable".into() "mytable".into()
@ -397,7 +397,7 @@ fn parse_create_table_with_options() {
}) => { }) => {
assert_eq!( assert_eq!(
name, name,
ObjectName(vec!["mydataset".into(), "newtable".into()]) ObjectName::from(vec!["mydataset".into(), "newtable".into()])
); );
assert_eq!( assert_eq!(
vec![ vec![
@ -486,7 +486,7 @@ fn parse_nested_data_types() {
let sql = "CREATE TABLE table (x STRUCT<a ARRAY<INT64>, b BYTES(42)>, y ARRAY<STRUCT<INT64>>)"; let sql = "CREATE TABLE table (x STRUCT<a ARRAY<INT64>, b BYTES(42)>, y ARRAY<STRUCT<INT64>>)";
match bigquery_and_generic().one_statement_parses_to(sql, sql) { match bigquery_and_generic().one_statement_parses_to(sql, sql) {
Statement::CreateTable(CreateTable { name, columns, .. }) => { Statement::CreateTable(CreateTable { name, columns, .. }) => {
assert_eq!(name, ObjectName(vec!["table".into()])); assert_eq!(name, ObjectName::from(vec!["table".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
@ -1376,7 +1376,7 @@ fn parse_table_identifiers() {
assert_eq!( assert_eq!(
select.from, select.from,
vec![TableWithJoins { vec![TableWithJoins {
relation: table_from_name(ObjectName(expected)), relation: table_from_name(ObjectName::from(expected)),
joins: vec![] joins: vec![]
},] },]
); );
@ -1518,7 +1518,10 @@ fn parse_hyphenated_table_identifiers() {
) )
.from[0] .from[0]
.relation, .relation,
table_from_name(ObjectName(vec![Ident::new("foo-123"), Ident::new("bar")])), table_from_name(ObjectName::from(vec![
Ident::new("foo-123"),
Ident::new("bar")
])),
); );
assert_eq!( assert_eq!(
@ -1551,7 +1554,7 @@ fn parse_table_time_travel() {
select.from, select.from,
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t1")]), name: ObjectName::from(vec![Ident::new("t1")]),
alias: None, alias: None,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -1630,11 +1633,11 @@ fn parse_merge() {
let update_action = MergeAction::Update { let update_action = MergeAction::Update {
assignments: vec![ assignments: vec![
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new("a")])), target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new("a")])),
value: Expr::Value(number("1")), value: Expr::Value(number("1")),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new("b")])), target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new("b")])),
value: Expr::Value(number("2")), value: Expr::Value(number("2")),
}, },
], ],
@ -1650,7 +1653,7 @@ fn parse_merge() {
assert!(!into); assert!(!into);
assert_eq!( assert_eq!(
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new("inventory")]), name: ObjectName::from(vec![Ident::new("inventory")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("T"), name: Ident::new("T"),
columns: vec![], columns: vec![],
@ -1667,7 +1670,7 @@ fn parse_merge() {
); );
assert_eq!( assert_eq!(
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new("newArrivals")]), name: ObjectName::from(vec![Ident::new("newArrivals")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("S"), name: Ident::new("S"),
columns: vec![], columns: vec![],
@ -1985,7 +1988,7 @@ fn parse_map_access_expr() {
}), }),
AccessExpr::Subscript(Subscript::Index { AccessExpr::Subscript(Subscript::Index {
index: Expr::Function(Function { index: Expr::Function(Function {
name: ObjectName(vec![Ident::with_span( name: ObjectName::from(vec![Ident::with_span(
Span::new(Location::of(1, 11), Location::of(1, 22)), Span::new(Location::of(1, 11), Location::of(1, 22)),
"safe_offset", "safe_offset",
)]), )]),
@ -2037,7 +2040,7 @@ fn test_bigquery_create_function() {
or_replace: true, or_replace: true,
temporary: true, temporary: true,
if_not_exists: false, if_not_exists: false,
name: ObjectName(vec![ name: ObjectName::from(vec![
Ident::new("project1"), Ident::new("project1"),
Ident::new("mydataset"), Ident::new("mydataset"),
Ident::new("myfunction"), Ident::new("myfunction"),

39
tests/sqlparser_clickhouse.rs
View file

@ -62,7 +62,7 @@ fn parse_map_access_expr() {
})], })],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("foos")])), relation: table_from_name(ObjectName::from(vec![Ident::new("foos")])),
joins: vec![], joins: vec![],
}], }],
lateral_views: vec![], lateral_views: vec![],
@ -166,7 +166,10 @@ fn parse_delimited_identifiers() {
version, version,
.. ..
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -185,7 +188,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -302,7 +305,7 @@ fn parse_alter_table_add_projection() {
Statement::AlterTable { Statement::AlterTable {
name, operations, .. name, operations, ..
} => { } => {
assert_eq!(name, ObjectName(vec!["t0".into()])); assert_eq!(name, ObjectName::from(vec!["t0".into()]));
assert_eq!(1, operations.len()); assert_eq!(1, operations.len());
assert_eq!( assert_eq!(
operations[0], operations[0],
@ -372,7 +375,7 @@ fn parse_alter_table_drop_projection() {
Statement::AlterTable { Statement::AlterTable {
name, operations, .. name, operations, ..
} => { } => {
assert_eq!(name, ObjectName(vec!["t0".into()])); assert_eq!(name, ObjectName::from(vec!["t0".into()]));
assert_eq!(1, operations.len()); assert_eq!(1, operations.len());
assert_eq!( assert_eq!(
operations[0], operations[0],
@ -405,7 +408,7 @@ fn parse_alter_table_clear_and_materialize_projection() {
Statement::AlterTable { Statement::AlterTable {
name, operations, .. name, operations, ..
} => { } => {
assert_eq!(name, ObjectName(vec!["t0".into()])); assert_eq!(name, ObjectName::from(vec!["t0".into()]));
assert_eq!(1, operations.len()); assert_eq!(1, operations.len());
assert_eq!( assert_eq!(
operations[0], operations[0],
@ -549,7 +552,7 @@ fn parse_clickhouse_data_types() {
match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) { match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) {
Statement::CreateTable(CreateTable { name, columns, .. }) => { Statement::CreateTable(CreateTable { name, columns, .. }) => {
assert_eq!(name, ObjectName(vec!["table".into()])); assert_eq!(name, ObjectName::from(vec!["table".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
@ -590,7 +593,7 @@ fn parse_create_table_with_nullable() {
match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) { match clickhouse_and_generic().one_statement_parses_to(sql, &canonical_sql) {
Statement::CreateTable(CreateTable { name, columns, .. }) => { Statement::CreateTable(CreateTable { name, columns, .. }) => {
assert_eq!(name, ObjectName(vec!["table".into()])); assert_eq!(name, ObjectName::from(vec!["table".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
@ -639,7 +642,7 @@ fn parse_create_table_with_nested_data_types() {
match clickhouse().one_statement_parses_to(sql, "") { match clickhouse().one_statement_parses_to(sql, "") {
Statement::CreateTable(CreateTable { name, columns, .. }) => { Statement::CreateTable(CreateTable { name, columns, .. }) => {
assert_eq!(name, ObjectName(vec!["table".into()])); assert_eq!(name, ObjectName::from(vec!["table".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
@ -755,7 +758,7 @@ fn parse_create_table_with_primary_key() {
}) })
); );
fn assert_function(actual: &Function, name: &str, arg: &str) -> bool { fn assert_function(actual: &Function, name: &str, arg: &str) -> bool {
assert_eq!(actual.name, ObjectName(vec![Ident::new(name)])); assert_eq!(actual.name, ObjectName::from(vec![Ident::new(name)]));
assert_eq!( assert_eq!(
actual.args, actual.args,
FunctionArguments::List(FunctionArgumentList { FunctionArguments::List(FunctionArgumentList {
@ -814,7 +817,7 @@ fn parse_create_table_with_variant_default_expressions() {
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::Materialized(Expr::Function(Function { option: ColumnOption::Materialized(Expr::Function(Function {
name: ObjectName(vec![Ident::new("now")]), name: ObjectName::from(vec![Ident::new("now")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
args: vec![], args: vec![],
@ -836,7 +839,7 @@ fn parse_create_table_with_variant_default_expressions() {
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::Ephemeral(Some(Expr::Function(Function { option: ColumnOption::Ephemeral(Some(Expr::Function(Function {
name: ObjectName(vec![Ident::new("now")]), name: ObjectName::from(vec![Ident::new("now")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
args: vec![], args: vec![],
@ -867,7 +870,7 @@ fn parse_create_table_with_variant_default_expressions() {
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::Alias(Expr::Function(Function { option: ColumnOption::Alias(Expr::Function(Function {
name: ObjectName(vec![Ident::new("toString")]), name: ObjectName::from(vec![Ident::new("toString")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr( args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
@ -895,14 +898,14 @@ fn parse_create_table_with_variant_default_expressions() {
fn parse_create_view_with_fields_data_types() { fn parse_create_view_with_fields_data_types() {
match clickhouse().verified_stmt(r#"CREATE VIEW v (i "int", f "String") AS SELECT * FROM t"#) { match clickhouse().verified_stmt(r#"CREATE VIEW v (i "int", f "String") AS SELECT * FROM t"#) {
Statement::CreateView { name, columns, .. } => { Statement::CreateView { name, columns, .. } => {
assert_eq!(name, ObjectName(vec!["v".into()])); assert_eq!(name, ObjectName::from(vec!["v".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
ViewColumnDef { ViewColumnDef {
name: "i".into(), name: "i".into(),
data_type: Some(DataType::Custom( data_type: Some(DataType::Custom(
ObjectName(vec![Ident { ObjectName::from(vec![Ident {
value: "int".into(), value: "int".into(),
quote_style: Some('"'), quote_style: Some('"'),
span: Span::empty(), span: Span::empty(),
@ -914,7 +917,7 @@ fn parse_create_view_with_fields_data_types() {
ViewColumnDef { ViewColumnDef {
name: "f".into(), name: "f".into(),
data_type: Some(DataType::Custom( data_type: Some(DataType::Custom(
ObjectName(vec![Ident { ObjectName::from(vec![Ident {
value: "String".into(), value: "String".into(),
quote_style: Some('"'), quote_style: Some('"'),
span: Span::empty(), span: Span::empty(),
@ -1355,7 +1358,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
clickhouse().verified_stmt(&format!("USE {}", object_name)), clickhouse().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -1363,7 +1366,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
clickhouse().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)), clickhouse().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))

293
tests/sqlparser_common.rs
View file

@ -160,7 +160,7 @@ fn parse_insert_default_values() {
assert_eq!(source, None); assert_eq!(source, None);
assert_eq!( assert_eq!(
table_name, table_name,
TableObject::TableName(ObjectName(vec!["test_table".into()])) TableObject::TableName(ObjectName::from(vec!["test_table".into()]))
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -188,7 +188,7 @@ fn parse_insert_default_values() {
assert_eq!(source, None); assert_eq!(source, None);
assert_eq!( assert_eq!(
table_name, table_name,
TableObject::TableName(ObjectName(vec!["test_table".into()])) TableObject::TableName(ObjectName::from(vec!["test_table".into()]))
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -216,7 +216,7 @@ fn parse_insert_default_values() {
assert_eq!(source, None); assert_eq!(source, None);
assert_eq!( assert_eq!(
table_name, table_name,
TableObject::TableName(ObjectName(vec!["test_table".into()])) TableObject::TableName(ObjectName::from(vec!["test_table".into()]))
); );
} }
_ => unreachable!(), _ => unreachable!(),
@ -343,15 +343,15 @@ fn parse_update() {
assignments, assignments,
vec![ vec![
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["a".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(vec!["a".into()])),
value: Expr::Value(number("1")), value: Expr::Value(number("1")),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["b".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(vec!["b".into()])),
value: Expr::Value(number("2")), value: Expr::Value(number("2")),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["c".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(vec!["c".into()])),
value: Expr::Value(number("3")), value: Expr::Value(number("3")),
}, },
] ]
@ -396,11 +396,11 @@ fn parse_update_set_from() {
stmt, stmt,
Statement::Update { Statement::Update {
table: TableWithJoins { table: TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("t1")])), relation: table_from_name(ObjectName::from(vec![Ident::new("t1")])),
joins: vec![], joins: vec![],
}, },
assignments: vec![Assignment { assignments: vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new("name")])), target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new("name")])),
value: Expr::CompoundIdentifier(vec![Ident::new("t2"), Ident::new("name")]) value: Expr::CompoundIdentifier(vec![Ident::new("t2"), Ident::new("name")])
}], }],
from: Some(UpdateTableFromKind::AfterSet(TableWithJoins { from: Some(UpdateTableFromKind::AfterSet(TableWithJoins {
@ -419,7 +419,7 @@ fn parse_update_set_from() {
], ],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("t1")])), relation: table_from_name(ObjectName::from(vec![Ident::new("t1")])),
joins: vec![], joins: vec![],
}], }],
lateral_views: vec![], lateral_views: vec![],
@ -488,7 +488,7 @@ fn parse_update_with_table_alias() {
assert_eq!( assert_eq!(
TableWithJoins { TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("users")]), name: ObjectName::from(vec![Ident::new("users")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("u"), name: Ident::new("u"),
columns: vec![], columns: vec![],
@ -507,7 +507,7 @@ fn parse_update_with_table_alias() {
); );
assert_eq!( assert_eq!(
vec![Assignment { vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![ target: AssignmentTarget::ColumnName(ObjectName::from(vec![
Ident::new("u"), Ident::new("u"),
Ident::new("username") Ident::new("username")
])), ])),
@ -577,7 +577,7 @@ fn parse_select_with_table_alias() {
select.from, select.from,
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("lineitem")]), name: ObjectName::from(vec![Ident::new("lineitem")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("l"), name: Ident::new("l"),
columns: vec![ columns: vec![
@ -628,7 +628,7 @@ fn parse_delete_statement() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![Ident::with_quote('"', "table")])), table_from_name(ObjectName::from(vec![Ident::with_quote('"', "table")])),
from[0].relation from[0].relation
); );
} }
@ -659,22 +659,22 @@ fn parse_delete_statement_for_multi_tables() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
ObjectName(vec![Ident::new("schema1"), Ident::new("table1")]), ObjectName::from(vec![Ident::new("schema1"), Ident::new("table1")]),
tables[0] tables[0]
); );
assert_eq!( assert_eq!(
ObjectName(vec![Ident::new("schema2"), Ident::new("table2")]), ObjectName::from(vec![Ident::new("schema2"), Ident::new("table2")]),
tables[1] tables[1]
); );
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema1"), Ident::new("schema1"),
Ident::new("table1") Ident::new("table1")
])), ])),
from[0].relation from[0].relation
); );
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema2"), Ident::new("schema2"),
Ident::new("table2") Ident::new("table2")
])), ])),
@ -695,28 +695,28 @@ fn parse_delete_statement_for_multi_tables_with_using() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema1"), Ident::new("schema1"),
Ident::new("table1") Ident::new("table1")
])), ])),
from[0].relation from[0].relation
); );
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema2"), Ident::new("schema2"),
Ident::new("table2") Ident::new("table2")
])), ])),
from[1].relation from[1].relation
); );
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema1"), Ident::new("schema1"),
Ident::new("table1") Ident::new("table1")
])), ])),
using[0].relation using[0].relation
); );
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![ table_from_name(ObjectName::from(vec![
Ident::new("schema2"), Ident::new("schema2"),
Ident::new("table2") Ident::new("table2")
])), ])),
@ -742,7 +742,7 @@ fn parse_where_delete_statement() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
table_from_name(ObjectName(vec![Ident::new("foo")])), table_from_name(ObjectName::from(vec![Ident::new("foo")])),
from[0].relation, from[0].relation,
); );
@ -777,7 +777,7 @@ fn parse_where_delete_with_alias_statement() {
}) => { }) => {
assert_eq!( assert_eq!(
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new("basket")]), name: ObjectName::from(vec![Ident::new("basket")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("a"), name: Ident::new("a"),
columns: vec![], columns: vec![],
@ -795,7 +795,7 @@ fn parse_where_delete_with_alias_statement() {
assert_eq!( assert_eq!(
Some(vec![TableWithJoins { Some(vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("basket")]), name: ObjectName::from(vec![Ident::new("basket")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("b"), name: Ident::new("b"),
columns: vec![], columns: vec![],
@ -962,7 +962,7 @@ fn parse_select_into() {
temporary: false, temporary: false,
unlogged: false, unlogged: false,
table: false, table: false,
name: ObjectName(vec![Ident::new("table0")]), name: ObjectName::from(vec![Ident::new("table0")]),
}, },
only(&select.into) only(&select.into)
); );
@ -995,7 +995,7 @@ fn parse_select_wildcard() {
let select = verified_only_select(sql); let select = verified_only_select(sql);
assert_eq!( assert_eq!(
&SelectItem::QualifiedWildcard( &SelectItem::QualifiedWildcard(
ObjectName(vec![Ident::new("foo")]), ObjectName::from(vec![Ident::new("foo")]),
WildcardAdditionalOptions::default() WildcardAdditionalOptions::default()
), ),
only(&select.projection) only(&select.projection)
@ -1005,7 +1005,7 @@ fn parse_select_wildcard() {
let select = verified_only_select(sql); let select = verified_only_select(sql);
assert_eq!( assert_eq!(
&SelectItem::QualifiedWildcard( &SelectItem::QualifiedWildcard(
ObjectName(vec![Ident::new("myschema"), Ident::new("mytable"),]), ObjectName::from(vec![Ident::new("myschema"), Ident::new("mytable"),]),
WildcardAdditionalOptions::default(), WildcardAdditionalOptions::default(),
), ),
only(&select.projection) only(&select.projection)
@ -1082,7 +1082,7 @@ fn parse_select_count_wildcard() {
let select = verified_only_select(sql); let select = verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("COUNT")]), name: ObjectName::from(vec![Ident::new("COUNT")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -1105,7 +1105,7 @@ fn parse_select_count_distinct() {
let select = verified_only_select(sql); let select = verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("COUNT")]), name: ObjectName::from(vec![Ident::new("COUNT")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -2342,7 +2342,7 @@ fn parse_select_having() {
assert_eq!( assert_eq!(
Some(Expr::BinaryOp { Some(Expr::BinaryOp {
left: Box::new(Expr::Function(Function { left: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("COUNT")]), name: ObjectName::from(vec![Ident::new("COUNT")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -2373,7 +2373,7 @@ fn parse_select_qualify() {
assert_eq!( assert_eq!(
Some(Expr::BinaryOp { Some(Expr::BinaryOp {
left: Box::new(Expr::Function(Function { left: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("ROW_NUMBER")]), name: ObjectName::from(vec![Ident::new("ROW_NUMBER")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -2780,7 +2780,7 @@ fn parse_listagg() {
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("LISTAGG")]), name: ObjectName::from(vec![Ident::new("LISTAGG")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -2935,7 +2935,10 @@ fn parse_window_function_null_treatment_arg() {
let SelectItem::UnnamedExpr(Expr::Function(actual)) = &projection[i] else { let SelectItem::UnnamedExpr(Expr::Function(actual)) = &projection[i] else {
unreachable!() unreachable!()
}; };
assert_eq!(ObjectName(vec![Ident::new("FIRST_VALUE")]), actual.name); assert_eq!(
ObjectName::from(vec![Ident::new("FIRST_VALUE")]),
actual.name
);
let FunctionArguments::List(arg_list) = &actual.args else { let FunctionArguments::List(arg_list) = &actual.args else {
panic!("expected argument list") panic!("expected argument list")
}; };
@ -3231,7 +3234,7 @@ fn parse_create_table() {
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::ForeignKey { option: ColumnOption::ForeignKey {
foreign_table: ObjectName(vec!["othertable".into()]), foreign_table: ObjectName::from(vec!["othertable".into()]),
referred_columns: vec!["a".into(), "b".into()], referred_columns: vec!["a".into(), "b".into()],
on_delete: None, on_delete: None,
on_update: None, on_update: None,
@ -3246,7 +3249,7 @@ fn parse_create_table() {
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::ForeignKey { option: ColumnOption::ForeignKey {
foreign_table: ObjectName(vec!["othertable2".into()]), foreign_table: ObjectName::from(vec!["othertable2".into()]),
referred_columns: vec![], referred_columns: vec![],
on_delete: Some(ReferentialAction::Cascade), on_delete: Some(ReferentialAction::Cascade),
on_update: Some(ReferentialAction::NoAction), on_update: Some(ReferentialAction::NoAction),
@ -3262,7 +3265,7 @@ fn parse_create_table() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: Some("fkey".into()), name: Some("fkey".into()),
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable3".into()]), foreign_table: ObjectName::from(vec!["othertable3".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Restrict), on_delete: Some(ReferentialAction::Restrict),
on_update: None, on_update: None,
@ -3271,7 +3274,7 @@ fn parse_create_table() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: Some("fkey2".into()), name: Some("fkey2".into()),
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::NoAction), on_delete: Some(ReferentialAction::NoAction),
on_update: Some(ReferentialAction::Restrict), on_update: Some(ReferentialAction::Restrict),
@ -3280,7 +3283,7 @@ fn parse_create_table() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: None, name: None,
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Cascade), on_delete: Some(ReferentialAction::Cascade),
on_update: Some(ReferentialAction::SetDefault), on_update: Some(ReferentialAction::SetDefault),
@ -3289,7 +3292,7 @@ fn parse_create_table() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: None, name: None,
columns: vec!["lng".into()], columns: vec!["lng".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["longitude".into()], referred_columns: vec!["longitude".into()],
on_delete: None, on_delete: None,
on_update: Some(ReferentialAction::SetNull), on_update: Some(ReferentialAction::SetNull),
@ -3388,7 +3391,7 @@ fn parse_create_table_with_constraint_characteristics() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: Some("fkey".into()), name: Some("fkey".into()),
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable3".into()]), foreign_table: ObjectName::from(vec!["othertable3".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Restrict), on_delete: Some(ReferentialAction::Restrict),
on_update: None, on_update: None,
@ -3401,7 +3404,7 @@ fn parse_create_table_with_constraint_characteristics() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: Some("fkey2".into()), name: Some("fkey2".into()),
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::NoAction), on_delete: Some(ReferentialAction::NoAction),
on_update: Some(ReferentialAction::Restrict), on_update: Some(ReferentialAction::Restrict),
@ -3414,7 +3417,7 @@ fn parse_create_table_with_constraint_characteristics() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: None, name: None,
columns: vec!["lat".into()], columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()], referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Cascade), on_delete: Some(ReferentialAction::Cascade),
on_update: Some(ReferentialAction::SetDefault), on_update: Some(ReferentialAction::SetDefault),
@ -3427,7 +3430,7 @@ fn parse_create_table_with_constraint_characteristics() {
TableConstraint::ForeignKey { TableConstraint::ForeignKey {
name: None, name: None,
columns: vec!["lng".into()], columns: vec!["lng".into()],
foreign_table: ObjectName(vec!["othertable4".into()]), foreign_table: ObjectName::from(vec!["othertable4".into()]),
referred_columns: vec!["longitude".into()], referred_columns: vec!["longitude".into()],
on_delete: None, on_delete: None,
on_update: Some(ReferentialAction::SetNull), on_update: Some(ReferentialAction::SetNull),
@ -3620,7 +3623,7 @@ fn parse_create_table_hive_array() {
.. ..
}) => { }) => {
assert!(if_not_exists); assert!(if_not_exists);
assert_eq!(name, ObjectName(vec!["something".into()])); assert_eq!(name, ObjectName::from(vec!["something".into()]));
assert_eq!( assert_eq!(
columns, columns,
vec![ vec![
@ -3817,7 +3820,7 @@ fn parse_create_table_as_table() {
match verified_stmt(sql1) { match verified_stmt(sql1) {
Statement::CreateTable(CreateTable { query, name, .. }) => { Statement::CreateTable(CreateTable { query, name, .. }) => {
assert_eq!(name, ObjectName(vec![Ident::new("new_table")])); assert_eq!(name, ObjectName::from(vec![Ident::new("new_table")]));
assert_eq!(query.unwrap(), expected_query1); assert_eq!(query.unwrap(), expected_query1);
} }
_ => unreachable!(), _ => unreachable!(),
@ -3844,7 +3847,7 @@ fn parse_create_table_as_table() {
match verified_stmt(sql2) { match verified_stmt(sql2) {
Statement::CreateTable(CreateTable { query, name, .. }) => { Statement::CreateTable(CreateTable { query, name, .. }) => {
assert_eq!(name, ObjectName(vec![Ident::new("new_table")])); assert_eq!(name, ObjectName::from(vec![Ident::new("new_table")]));
assert_eq!(query.unwrap(), expected_query2); assert_eq!(query.unwrap(), expected_query2);
} }
_ => unreachable!(), _ => unreachable!(),
@ -3947,8 +3950,8 @@ fn parse_create_table_clone() {
let sql = "CREATE OR REPLACE TABLE a CLONE a_tmp"; let sql = "CREATE OR REPLACE TABLE a CLONE a_tmp";
match verified_stmt(sql) { match verified_stmt(sql) {
Statement::CreateTable(CreateTable { name, clone, .. }) => { Statement::CreateTable(CreateTable { name, clone, .. }) => {
assert_eq!(ObjectName(vec![Ident::new("a")]), name); assert_eq!(ObjectName::from(vec![Ident::new("a")]), name);
assert_eq!(Some(ObjectName(vec![(Ident::new("a_tmp"))])), clone) assert_eq!(Some(ObjectName::from(vec![(Ident::new("a_tmp"))])), clone)
} }
_ => unreachable!(), _ => unreachable!(),
} }
@ -4176,11 +4179,11 @@ fn parse_rename_table() {
Statement::RenameTable(rename_tables) => { Statement::RenameTable(rename_tables) => {
assert_eq!( assert_eq!(
vec![RenameTable { vec![RenameTable {
old_name: ObjectName(vec![ old_name: ObjectName::from(vec![
Ident::new("test".to_string()), Ident::new("test".to_string()),
Ident::new("test1".to_string()), Ident::new("test1".to_string()),
]), ]),
new_name: ObjectName(vec![ new_name: ObjectName::from(vec![
Ident::new("test_db".to_string()), Ident::new("test_db".to_string()),
Ident::new("test2".to_string()), Ident::new("test2".to_string()),
]), ]),
@ -4198,16 +4201,16 @@ fn parse_rename_table() {
assert_eq!( assert_eq!(
vec![ vec![
RenameTable { RenameTable {
old_name: ObjectName(vec![Ident::new("old_table1".to_string())]), old_name: ObjectName::from(vec![Ident::new("old_table1".to_string())]),
new_name: ObjectName(vec![Ident::new("new_table1".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table1".to_string())]),
}, },
RenameTable { RenameTable {
old_name: ObjectName(vec![Ident::new("old_table2".to_string())]), old_name: ObjectName::from(vec![Ident::new("old_table2".to_string())]),
new_name: ObjectName(vec![Ident::new("new_table2".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table2".to_string())]),
}, },
RenameTable { RenameTable {
old_name: ObjectName(vec![Ident::new("old_table3".to_string())]), old_name: ObjectName::from(vec![Ident::new("old_table3".to_string())]),
new_name: ObjectName(vec![Ident::new("new_table3".to_string())]), new_name: ObjectName::from(vec![Ident::new("new_table3".to_string())]),
} }
], ],
rename_tables rename_tables
@ -4802,7 +4805,7 @@ fn parse_named_argument_function() {
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("FUN")]), name: ObjectName::from(vec![Ident::new("FUN")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -4842,7 +4845,7 @@ fn parse_named_argument_function_with_eq_operator() {
.verified_only_select(sql); .verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("FUN")]), name: ObjectName::from(vec![Ident::new("FUN")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -4917,7 +4920,7 @@ fn parse_window_functions() {
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("row_number")]), name: ObjectName::from(vec![Ident::new("row_number")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -5044,7 +5047,7 @@ fn test_parse_named_window() {
projection: vec![ projection: vec![
SelectItem::ExprWithAlias { SelectItem::ExprWithAlias {
expr: Expr::Function(Function { expr: Expr::Function(Function {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "MIN".to_string(), value: "MIN".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -5079,7 +5082,7 @@ fn test_parse_named_window() {
}, },
SelectItem::ExprWithAlias { SelectItem::ExprWithAlias {
expr: Expr::Function(Function { expr: Expr::Function(Function {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "MAX".to_string(), value: "MAX".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -5115,7 +5118,7 @@ fn test_parse_named_window() {
], ],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "aggregate_test_100".to_string(), value: "aggregate_test_100".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -5729,7 +5732,7 @@ fn parse_interval_and_or_xor() {
}))], }))],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "test".to_string(), value: "test".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -6341,11 +6344,11 @@ fn parse_implicit_join() {
assert_eq!( assert_eq!(
vec![ vec![
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec!["t1".into()])), relation: table_from_name(ObjectName::from(vec!["t1".into()])),
joins: vec![], joins: vec![],
}, },
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec!["t2".into()])), relation: table_from_name(ObjectName::from(vec!["t2".into()])),
joins: vec![], joins: vec![],
}, },
], ],
@ -6357,17 +6360,17 @@ fn parse_implicit_join() {
assert_eq!( assert_eq!(
vec![ vec![
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec!["t1a".into()])), relation: table_from_name(ObjectName::from(vec!["t1a".into()])),
joins: vec![Join { joins: vec![Join {
relation: table_from_name(ObjectName(vec!["t1b".into()])), relation: table_from_name(ObjectName::from(vec!["t1b".into()])),
global: false, global: false,
join_operator: JoinOperator::Inner(JoinConstraint::Natural), join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}], }],
}, },
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec!["t2a".into()])), relation: table_from_name(ObjectName::from(vec!["t2a".into()])),
joins: vec![Join { joins: vec![Join {
relation: table_from_name(ObjectName(vec!["t2b".into()])), relation: table_from_name(ObjectName::from(vec!["t2b".into()])),
global: false, global: false,
join_operator: JoinOperator::Inner(JoinConstraint::Natural), join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}], }],
@ -6383,7 +6386,7 @@ fn parse_cross_join() {
let select = verified_only_select(sql); let select = verified_only_select(sql);
assert_eq!( assert_eq!(
Join { Join {
relation: table_from_name(ObjectName(vec![Ident::new("t2")])), relation: table_from_name(ObjectName::from(vec![Ident::new("t2")])),
global: false, global: false,
join_operator: JoinOperator::CrossJoin, join_operator: JoinOperator::CrossJoin,
}, },
@ -6401,7 +6404,7 @@ fn parse_joins_on() {
) -> Join { ) -> Join {
Join { Join {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new(relation.into())]), name: ObjectName::from(vec![Ident::new(relation.into())]),
alias, alias,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -6530,7 +6533,7 @@ fn parse_joins_using() {
) -> Join { ) -> Join {
Join { Join {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new(relation.into())]), name: ObjectName::from(vec![Ident::new(relation.into())]),
alias, alias,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -6541,7 +6544,9 @@ fn parse_joins_using() {
sample: None, sample: None,
}, },
global: false, global: false,
join_operator: f(JoinConstraint::Using(vec![ObjectName(vec!["c1".into()])])), join_operator: f(JoinConstraint::Using(vec![ObjectName::from(vec![
"c1".into()
])])),
} }
} }
// Test parsing of aliases // Test parsing of aliases
@ -6606,7 +6611,7 @@ fn parse_natural_join() {
fn natural_join(f: impl Fn(JoinConstraint) -> JoinOperator, alias: Option<TableAlias>) -> Join { fn natural_join(f: impl Fn(JoinConstraint) -> JoinOperator, alias: Option<TableAlias>) -> Join {
Join { Join {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t2")]), name: ObjectName::from(vec![Ident::new("t2")]),
alias, alias,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -6878,7 +6883,7 @@ fn parse_derived_tables() {
}), }),
}, },
joins: vec![Join { joins: vec![Join {
relation: table_from_name(ObjectName(vec!["t2".into()])), relation: table_from_name(ObjectName::from(vec!["t2".into()])),
global: false, global: false,
join_operator: JoinOperator::Inner(JoinConstraint::Natural), join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}], }],
@ -7826,7 +7831,7 @@ fn lateral_function() {
top_before_distinct: false, top_before_distinct: false,
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "customer".to_string(), value: "customer".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -7834,7 +7839,7 @@ fn lateral_function() {
joins: vec![Join { joins: vec![Join {
relation: TableFactor::Function { relation: TableFactor::Function {
lateral: true, lateral: true,
name: ObjectName(vec!["generate_series".into()]), name: ObjectName::from(vec!["generate_series".into()]),
args: vec![ args: vec![
FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(number("1")))), FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(number("1")))),
FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier( FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::CompoundIdentifier(
@ -7995,7 +8000,7 @@ fn parse_set_variable() {
assert!(!hivevar); assert!(!hivevar);
assert_eq!( assert_eq!(
variables, variables,
OneOrManyWithParens::One(ObjectName(vec!["SOMETHING".into()])) OneOrManyWithParens::One(ObjectName::from(vec!["SOMETHING".into()]))
); );
assert_eq!( assert_eq!(
value, value,
@ -8019,9 +8024,9 @@ fn parse_set_variable() {
assert_eq!( assert_eq!(
variables, variables,
OneOrManyWithParens::Many(vec![ OneOrManyWithParens::Many(vec![
ObjectName(vec!["a".into()]), ObjectName::from(vec!["a".into()]),
ObjectName(vec!["b".into()]), ObjectName::from(vec!["b".into()]),
ObjectName(vec!["c".into()]), ObjectName::from(vec!["c".into()]),
]) ])
); );
assert_eq!( assert_eq!(
@ -8095,7 +8100,7 @@ fn parse_set_role_as_variable() {
assert!(!hivevar); assert!(!hivevar);
assert_eq!( assert_eq!(
variables, variables,
OneOrManyWithParens::One(ObjectName(vec!["role".into()])) OneOrManyWithParens::One(ObjectName::from(vec!["role".into()]))
); );
assert_eq!( assert_eq!(
value, value,
@ -8142,7 +8147,7 @@ fn parse_set_time_zone() {
assert!(!hivevar); assert!(!hivevar);
assert_eq!( assert_eq!(
variable, variable,
OneOrManyWithParens::One(ObjectName(vec!["TIMEZONE".into()])) OneOrManyWithParens::One(ObjectName::from(vec!["TIMEZONE".into()]))
); );
assert_eq!( assert_eq!(
value, value,
@ -8698,7 +8703,7 @@ fn parse_merge() {
assert_eq!( assert_eq!(
table, table,
TableFactor::Table { TableFactor::Table {
name: ObjectName(vec![Ident::new("s"), Ident::new("bar")]), name: ObjectName::from(vec![Ident::new("s"), Ident::new("bar")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("dest"), name: Ident::new("dest"),
columns: vec![], columns: vec![],
@ -8730,7 +8735,7 @@ fn parse_merge() {
)], )],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![ relation: table_from_name(ObjectName::from(vec![
Ident::new("s"), Ident::new("s"),
Ident::new("foo") Ident::new("foo")
])), ])),
@ -8844,7 +8849,7 @@ fn parse_merge() {
action: MergeAction::Update { action: MergeAction::Update {
assignments: vec![ assignments: vec![
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![ target: AssignmentTarget::ColumnName(ObjectName::from(vec![
Ident::new("dest"), Ident::new("dest"),
Ident::new("F") Ident::new("F")
])), ])),
@ -8854,7 +8859,7 @@ fn parse_merge() {
]), ]),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![ target: AssignmentTarget::ColumnName(ObjectName::from(vec![
Ident::new("dest"), Ident::new("dest"),
Ident::new("G") Ident::new("G")
])), ])),
@ -8961,12 +8966,12 @@ fn test_lock_table() {
let lock = ast.locks.pop().unwrap(); let lock = ast.locks.pop().unwrap();
assert_eq!(lock.lock_type, LockType::Update); assert_eq!(lock.lock_type, LockType::Update);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "school".to_string(), value: "school".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert!(lock.nonblock.is_none()); assert!(lock.nonblock.is_none());
@ -8976,12 +8981,12 @@ fn test_lock_table() {
let lock = ast.locks.pop().unwrap(); let lock = ast.locks.pop().unwrap();
assert_eq!(lock.lock_type, LockType::Share); assert_eq!(lock.lock_type, LockType::Share);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "school".to_string(), value: "school".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert!(lock.nonblock.is_none()); assert!(lock.nonblock.is_none());
@ -8991,23 +8996,23 @@ fn test_lock_table() {
let lock = ast.locks.remove(0); let lock = ast.locks.remove(0);
assert_eq!(lock.lock_type, LockType::Share); assert_eq!(lock.lock_type, LockType::Share);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "school".to_string(), value: "school".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert!(lock.nonblock.is_none()); assert!(lock.nonblock.is_none());
let lock = ast.locks.remove(0); let lock = ast.locks.remove(0);
assert_eq!(lock.lock_type, LockType::Update); assert_eq!(lock.lock_type, LockType::Update);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "student".to_string(), value: "student".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert!(lock.nonblock.is_none()); assert!(lock.nonblock.is_none());
} }
@ -9020,12 +9025,12 @@ fn test_lock_nonblock() {
let lock = ast.locks.pop().unwrap(); let lock = ast.locks.pop().unwrap();
assert_eq!(lock.lock_type, LockType::Update); assert_eq!(lock.lock_type, LockType::Update);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "school".to_string(), value: "school".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert_eq!(lock.nonblock.unwrap(), NonBlock::SkipLocked); assert_eq!(lock.nonblock.unwrap(), NonBlock::SkipLocked);
@ -9035,12 +9040,12 @@ fn test_lock_nonblock() {
let lock = ast.locks.pop().unwrap(); let lock = ast.locks.pop().unwrap();
assert_eq!(lock.lock_type, LockType::Share); assert_eq!(lock.lock_type, LockType::Share);
assert_eq!( assert_eq!(
lock.of.unwrap().0, lock.of.unwrap(),
vec![Ident { ObjectName::from(vec![Ident {
value: "school".to_string(), value: "school".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}] }])
); );
assert_eq!(lock.nonblock.unwrap(), NonBlock::Nowait); assert_eq!(lock.nonblock.unwrap(), NonBlock::Nowait);
} }
@ -9222,7 +9227,7 @@ fn parse_time_functions() {
let sql = format!("SELECT {}()", func_name); let sql = format!("SELECT {}()", func_name);
let select = verified_only_select(&sql); let select = verified_only_select(&sql);
let select_localtime_func_call_ast = Function { let select_localtime_func_call_ast = Function {
name: ObjectName(vec![Ident::new(func_name)]), name: ObjectName::from(vec![Ident::new(func_name)]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -9495,7 +9500,7 @@ fn parse_cache_table() {
verified_stmt(format!("CACHE TABLE '{cache_table_name}'").as_str()), verified_stmt(format!("CACHE TABLE '{cache_table_name}'").as_str()),
Statement::Cache { Statement::Cache {
table_flag: None, table_flag: None,
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: false, has_as: false,
options: vec![], options: vec![],
query: None, query: None,
@ -9505,8 +9510,8 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}'").as_str()), verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}'").as_str()),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: false, has_as: false,
options: vec![], options: vec![],
query: None, query: None,
@ -9521,8 +9526,8 @@ fn parse_cache_table() {
.as_str() .as_str()
), ),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: false, has_as: false,
options: vec![ options: vec![
SqlOption::KeyValue { SqlOption::KeyValue {
@ -9546,8 +9551,8 @@ fn parse_cache_table() {
.as_str() .as_str()
), ),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: false, has_as: false,
options: vec![ options: vec![
SqlOption::KeyValue { SqlOption::KeyValue {
@ -9571,8 +9576,8 @@ fn parse_cache_table() {
.as_str() .as_str()
), ),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: true, has_as: true,
options: vec![ options: vec![
SqlOption::KeyValue { SqlOption::KeyValue {
@ -9591,8 +9596,8 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' {sql}").as_str()), verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' {sql}").as_str()),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: false, has_as: false,
options: vec![], options: vec![],
query: Some(query.clone().into()), query: Some(query.clone().into()),
@ -9602,8 +9607,8 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' AS {sql}").as_str()), verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' AS {sql}").as_str()),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName::from(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName::from(vec![Ident::with_quote('\'', cache_table_name)]),
has_as: true, has_as: true,
options: vec![], options: vec![],
query: Some(query.into()), query: Some(query.into()),
@ -9666,7 +9671,7 @@ fn parse_uncache_table() {
assert_eq!( assert_eq!(
verified_stmt("UNCACHE TABLE 'table_name'"), verified_stmt("UNCACHE TABLE 'table_name'"),
Statement::UNCache { Statement::UNCache {
table_name: ObjectName(vec![Ident::with_quote('\'', "table_name")]), table_name: ObjectName::from(vec![Ident::with_quote('\'', "table_name")]),
if_exists: false, if_exists: false,
} }
); );
@ -9674,7 +9679,7 @@ fn parse_uncache_table() {
assert_eq!( assert_eq!(
verified_stmt("UNCACHE TABLE IF EXISTS 'table_name'"), verified_stmt("UNCACHE TABLE IF EXISTS 'table_name'"),
Statement::UNCache { Statement::UNCache {
table_name: ObjectName(vec![Ident::with_quote('\'', "table_name")]), table_name: ObjectName::from(vec![Ident::with_quote('\'', "table_name")]),
if_exists: true, if_exists: true,
} }
); );
@ -9881,7 +9886,7 @@ fn parse_pivot_table() {
verified_only_select(sql).from[0].relation, verified_only_select(sql).from[0].relation,
Pivot { Pivot {
table: Box::new(TableFactor::Table { table: Box::new(TableFactor::Table {
name: ObjectName(vec![Ident::new("monthly_sales")]), name: ObjectName::from(vec![Ident::new("monthly_sales")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("a"), name: Ident::new("a"),
columns: vec![] columns: vec![]
@ -9957,7 +9962,7 @@ fn parse_unpivot_table() {
verified_only_select(sql).from[0].relation, verified_only_select(sql).from[0].relation,
Unpivot { Unpivot {
table: Box::new(TableFactor::Table { table: Box::new(TableFactor::Table {
name: ObjectName(vec![Ident::new("sales")]), name: ObjectName::from(vec![Ident::new("sales")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("s"), name: Ident::new("s"),
columns: vec![] columns: vec![]
@ -10028,7 +10033,7 @@ fn parse_pivot_unpivot_table() {
Pivot { Pivot {
table: Box::new(Unpivot { table: Box::new(Unpivot {
table: Box::new(TableFactor::Table { table: Box::new(TableFactor::Table {
name: ObjectName(vec![Ident::new("census")]), name: ObjectName::from(vec![Ident::new("census")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("c"), name: Ident::new("c"),
columns: vec![] columns: vec![]
@ -10231,7 +10236,7 @@ fn parse_create_type() {
verified_stmt("CREATE TYPE db.type_name AS (foo INT, bar TEXT COLLATE \"de_DE\")"); verified_stmt("CREATE TYPE db.type_name AS (foo INT, bar TEXT COLLATE \"de_DE\")");
assert_eq!( assert_eq!(
Statement::CreateType { Statement::CreateType {
name: ObjectName(vec![Ident::new("db"), Ident::new("type_name")]), name: ObjectName::from(vec![Ident::new("db"), Ident::new("type_name")]),
representation: UserDefinedTypeRepresentation::Composite { representation: UserDefinedTypeRepresentation::Composite {
attributes: vec![ attributes: vec![
UserDefinedTypeCompositeAttributeDef { UserDefinedTypeCompositeAttributeDef {
@ -10242,7 +10247,7 @@ fn parse_create_type() {
UserDefinedTypeCompositeAttributeDef { UserDefinedTypeCompositeAttributeDef {
name: Ident::new("bar"), name: Ident::new("bar"),
data_type: DataType::Text, data_type: DataType::Text,
collation: Some(ObjectName(vec![Ident::with_quote('\"', "de_DE")])), collation: Some(ObjectName::from(vec![Ident::with_quote('\"', "de_DE")])),
} }
] ]
} }
@ -10323,7 +10328,7 @@ fn parse_call() {
)))], )))],
clauses: vec![], clauses: vec![],
}), }),
name: ObjectName(vec![Ident::new("my_procedure")]), name: ObjectName::from(vec![Ident::new("my_procedure")]),
filter: None, filter: None,
null_treatment: None, null_treatment: None,
over: None, over: None,
@ -10335,7 +10340,7 @@ fn parse_call() {
#[test] #[test]
fn parse_execute_stored_procedure() { fn parse_execute_stored_procedure() {
let expected = Statement::Execute { let expected = Statement::Execute {
name: ObjectName(vec![ name: ObjectName::from(vec![
Ident { Ident {
value: "my_schema".to_string(), value: "my_schema".to_string(),
quote_style: None, quote_style: None,
@ -10447,7 +10452,7 @@ fn parse_unload() {
projection: vec![UnnamedExpr(Expr::Identifier(Ident::new("cola"))),], projection: vec![UnnamedExpr(Expr::Identifier(Ident::new("cola"))),],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("tab")])), relation: table_from_name(ObjectName::from(vec![Ident::new("tab")])),
joins: vec![], joins: vec![],
}], }],
lateral_views: vec![], lateral_views: vec![],
@ -10600,7 +10605,7 @@ fn parse_map_access_expr() {
}), }),
AccessExpr::Subscript(Subscript::Index { AccessExpr::Subscript(Subscript::Index {
index: Expr::Function(Function { index: Expr::Function(Function {
name: ObjectName(vec![Ident::with_span( name: ObjectName::from(vec![Ident::with_span(
Span::new(Location::of(1, 11), Location::of(1, 22)), Span::new(Location::of(1, 11), Location::of(1, 22)),
"safe_offset", "safe_offset",
)]), )]),
@ -10641,7 +10646,7 @@ fn parse_connect_by() {
SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))),
], ],
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("employees")])), relation: table_from_name(ObjectName::from(vec![Ident::new("employees")])),
joins: vec![], joins: vec![],
}], }],
into: None, into: None,
@ -10721,7 +10726,7 @@ fn parse_connect_by() {
SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))), SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("title"))),
], ],
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("employees")])), relation: table_from_name(ObjectName::from(vec![Ident::new("employees")])),
joins: vec![], joins: vec![],
}], }],
into: None, into: None,
@ -10797,7 +10802,7 @@ fn test_selective_aggregation() {
.projection, .projection,
vec![ vec![
SelectItem::UnnamedExpr(Expr::Function(Function { SelectItem::UnnamedExpr(Expr::Function(Function {
name: ObjectName(vec![Ident::new("ARRAY_AGG")]), name: ObjectName::from(vec![Ident::new("ARRAY_AGG")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -10816,7 +10821,7 @@ fn test_selective_aggregation() {
})), })),
SelectItem::ExprWithAlias { SelectItem::ExprWithAlias {
expr: Expr::Function(Function { expr: Expr::Function(Function {
name: ObjectName(vec![Ident::new("ARRAY_AGG")]), name: ObjectName::from(vec![Ident::new("ARRAY_AGG")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -10876,7 +10881,7 @@ fn test_match_recognize() {
use MatchRecognizeSymbol::*; use MatchRecognizeSymbol::*;
use RepetitionQuantifier::*; use RepetitionQuantifier::*;
let table = table_from_name(ObjectName(vec![Ident::new("my_table")])); let table = table_from_name(ObjectName::from(vec![Ident::new("my_table")]));
fn check(options: &str, expect: TableFactor) { fn check(options: &str, expect: TableFactor) {
let select = all_dialects_where(|d| d.supports_match_recognize()).verified_only_select( let select = all_dialects_where(|d| d.supports_match_recognize()).verified_only_select(
@ -11260,7 +11265,7 @@ fn parse_odbc_scalar_function() {
else { else {
unreachable!("expected function") unreachable!("expected function")
}; };
assert_eq!(name, &ObjectName(vec![Ident::new("my_func")])); assert_eq!(name, &ObjectName::from(vec![Ident::new("my_func")]));
assert!(uses_odbc_syntax); assert!(uses_odbc_syntax);
matches!(args, FunctionArguments::List(l) if l.args.len() == 2); matches!(args, FunctionArguments::List(l) if l.args.len() == 2);
@ -12327,7 +12332,7 @@ fn parse_load_data() {
assert_eq!("/local/path/to/data.txt", inpath); assert_eq!("/local/path/to/data.txt", inpath);
assert_eq!(false, overwrite); assert_eq!(false, overwrite);
assert_eq!( assert_eq!(
ObjectName(vec![Ident::new("test"), Ident::new("my_table")]), ObjectName::from(vec![Ident::new("test"), Ident::new("my_table")]),
table_name table_name
); );
assert_eq!(None, partitioned); assert_eq!(None, partitioned);
@ -12350,7 +12355,7 @@ fn parse_load_data() {
assert_eq!(false, local); assert_eq!(false, local);
assert_eq!("/local/path/to/data.txt", inpath); assert_eq!("/local/path/to/data.txt", inpath);
assert_eq!(true, overwrite); assert_eq!(true, overwrite);
assert_eq!(ObjectName(vec![Ident::new("my_table")]), table_name); assert_eq!(ObjectName::from(vec![Ident::new("my_table")]), table_name);
assert_eq!(None, partitioned); assert_eq!(None, partitioned);
assert_eq!(None, table_format); assert_eq!(None, table_format);
} }
@ -12387,7 +12392,7 @@ fn parse_load_data() {
assert_eq!("/local/path/to/data.txt", inpath); assert_eq!("/local/path/to/data.txt", inpath);
assert_eq!(false, overwrite); assert_eq!(false, overwrite);
assert_eq!( assert_eq!(
ObjectName(vec![Ident::new("test"), Ident::new("my_table")]), ObjectName::from(vec![Ident::new("test"), Ident::new("my_table")]),
table_name table_name
); );
assert_eq!(None, partitioned); assert_eq!(None, partitioned);
@ -12425,7 +12430,7 @@ fn parse_load_data() {
assert_eq!(true, local); assert_eq!(true, local);
assert_eq!("/local/path/to/data.txt", inpath); assert_eq!("/local/path/to/data.txt", inpath);
assert_eq!(false, overwrite); assert_eq!(false, overwrite);
assert_eq!(ObjectName(vec![Ident::new("my_table")]), table_name); assert_eq!(ObjectName::from(vec![Ident::new("my_table")]), table_name);
assert_eq!( assert_eq!(
Some(vec![ Some(vec![
Expr::BinaryOp { Expr::BinaryOp {
@ -12461,7 +12466,7 @@ fn parse_load_data() {
assert_eq!("/local/path/to/data.txt", inpath); assert_eq!("/local/path/to/data.txt", inpath);
assert_eq!(true, overwrite); assert_eq!(true, overwrite);
assert_eq!( assert_eq!(
ObjectName(vec![Ident::new("good"), Ident::new("my_table")]), ObjectName::from(vec![Ident::new("good"), Ident::new("my_table")]),
table_name table_name
); );
assert_eq!( assert_eq!(
@ -12815,7 +12820,7 @@ fn parse_composite_access_expr() {
verified_expr("f(a).b"), verified_expr("f(a).b"),
Expr::CompoundFieldAccess { Expr::CompoundFieldAccess {
root: Box::new(Expr::Function(Function { root: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("f")]), name: ObjectName::from(vec![Ident::new("f")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -12839,7 +12844,7 @@ fn parse_composite_access_expr() {
verified_expr("f(a).b.c"), verified_expr("f(a).b.c"),
Expr::CompoundFieldAccess { Expr::CompoundFieldAccess {
root: Box::new(Expr::Function(Function { root: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("f")]), name: ObjectName::from(vec![Ident::new("f")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -12865,7 +12870,7 @@ fn parse_composite_access_expr() {
let stmt = verified_only_select("SELECT f(a).b FROM t WHERE f(a).b IS NOT NULL"); let stmt = verified_only_select("SELECT f(a).b FROM t WHERE f(a).b IS NOT NULL");
let expr = Expr::CompoundFieldAccess { let expr = Expr::CompoundFieldAccess {
root: Box::new(Expr::Function(Function { root: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("f")]), name: ObjectName::from(vec![Ident::new("f")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {

24
tests/sqlparser_databricks.rs
View file

@ -185,7 +185,9 @@ fn test_values_clause() {
"SELECT * FROM values", "SELECT * FROM values",
)); ));
assert_eq!( assert_eq!(
Some(&table_from_name(ObjectName(vec![Ident::new("values")]))), Some(&table_from_name(ObjectName::from(vec![Ident::new(
"values"
)]))),
query query
.body .body
.as_select() .as_select()
@ -205,7 +207,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
databricks().verified_stmt(&format!("USE {}", object_name)), databricks().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -213,7 +215,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
databricks().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)), databricks().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))
@ -225,21 +227,21 @@ fn parse_use() {
// Test single identifier with keyword and different type of quotes // Test single identifier with keyword and different type of quotes
assert_eq!( assert_eq!(
databricks().verified_stmt(&format!("USE CATALOG {0}my_catalog{0}", quote)), databricks().verified_stmt(&format!("USE CATALOG {0}my_catalog{0}", quote)),
Statement::Use(Use::Catalog(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Catalog(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_catalog".to_string(), "my_catalog".to_string(),
)]))) )])))
); );
assert_eq!( assert_eq!(
databricks().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)), databricks().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)),
Statement::Use(Use::Database(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Database(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_database".to_string(), "my_database".to_string(),
)]))) )])))
); );
assert_eq!( assert_eq!(
databricks().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)), databricks().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)),
Statement::Use(Use::Schema(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Schema(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_schema".to_string(), "my_schema".to_string(),
)]))) )])))
@ -249,15 +251,19 @@ fn parse_use() {
// Test single identifier with keyword and no quotes // Test single identifier with keyword and no quotes
assert_eq!( assert_eq!(
databricks().verified_stmt("USE CATALOG my_catalog"), databricks().verified_stmt("USE CATALOG my_catalog"),
Statement::Use(Use::Catalog(ObjectName(vec![Ident::new("my_catalog")]))) Statement::Use(Use::Catalog(ObjectName::from(vec![Ident::new(
"my_catalog"
)])))
); );
assert_eq!( assert_eq!(
databricks().verified_stmt("USE DATABASE my_schema"), databricks().verified_stmt("USE DATABASE my_schema"),
Statement::Use(Use::Database(ObjectName(vec![Ident::new("my_schema")]))) Statement::Use(Use::Database(ObjectName::from(vec![Ident::new(
"my_schema"
)])))
); );
assert_eq!( assert_eq!(
databricks().verified_stmt("USE SCHEMA my_schema"), databricks().verified_stmt("USE SCHEMA my_schema"),
Statement::Use(Use::Schema(ObjectName(vec![Ident::new("my_schema")]))) Statement::Use(Use::Schema(ObjectName::from(vec![Ident::new("my_schema")])))
); );
// Test invalid syntax - missing identifier // Test invalid syntax - missing identifier

24
tests/sqlparser_duckdb.rs
View file

@ -160,7 +160,7 @@ fn test_select_wildcard_with_exclude() {
let select = let select =
duckdb().verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table"); duckdb().verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table");
let expected = SelectItem::QualifiedWildcard( let expected = SelectItem::QualifiedWildcard(
ObjectName(vec![Ident::new("name")]), ObjectName::from(vec![Ident::new("name")]),
WildcardAdditionalOptions { WildcardAdditionalOptions {
opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))), opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))),
..Default::default() ..Default::default()
@ -191,7 +191,7 @@ fn test_create_macro() {
let expected = Statement::CreateMacro { let expected = Statement::CreateMacro {
or_replace: false, or_replace: false,
temporary: false, temporary: false,
name: ObjectName(vec![Ident::new("schema"), Ident::new("add")]), name: ObjectName::from(vec![Ident::new("schema"), Ident::new("add")]),
args: Some(vec![MacroArg::new("a"), MacroArg::new("b")]), args: Some(vec![MacroArg::new("a"), MacroArg::new("b")]),
definition: MacroDefinition::Expr(Expr::BinaryOp { definition: MacroDefinition::Expr(Expr::BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("a"))), left: Box::new(Expr::Identifier(Ident::new("a"))),
@ -208,7 +208,7 @@ fn test_create_macro_default_args() {
let expected = Statement::CreateMacro { let expected = Statement::CreateMacro {
or_replace: false, or_replace: false,
temporary: false, temporary: false,
name: ObjectName(vec![Ident::new("add_default")]), name: ObjectName::from(vec![Ident::new("add_default")]),
args: Some(vec![ args: Some(vec![
MacroArg::new("a"), MacroArg::new("a"),
MacroArg { MacroArg {
@ -236,7 +236,7 @@ fn test_create_table_macro() {
let expected = Statement::CreateMacro { let expected = Statement::CreateMacro {
or_replace: true, or_replace: true,
temporary: true, temporary: true,
name: ObjectName(vec![Ident::new("dynamic_table")]), name: ObjectName::from(vec![Ident::new("dynamic_table")]),
args: Some(vec![ args: Some(vec![
MacroArg::new("col1_value"), MacroArg::new("col1_value"),
MacroArg::new("col2_value"), MacroArg::new("col2_value"),
@ -268,7 +268,7 @@ fn test_select_union_by_name() {
top_before_distinct: false, top_before_distinct: false,
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "capitals".to_string(), value: "capitals".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -297,7 +297,7 @@ fn test_select_union_by_name() {
top_before_distinct: false, top_before_distinct: false,
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "weather".to_string(), value: "weather".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -587,7 +587,7 @@ fn test_duckdb_named_argument_function_with_assignment_operator() {
let select = duckdb_and_generic().verified_only_select(sql); let select = duckdb_and_generic().verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("FUN")]), name: ObjectName::from(vec![Ident::new("FUN")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -661,7 +661,7 @@ fn test_duckdb_union_datatype() {
transient: Default::default(), transient: Default::default(),
volatile: Default::default(), volatile: Default::default(),
iceberg: Default::default(), iceberg: Default::default(),
name: ObjectName(vec!["tbl1".into()]), name: ObjectName::from(vec!["tbl1".into()]),
columns: vec![ columns: vec![
ColumnDef { ColumnDef {
name: "one".into(), name: "one".into(),
@ -765,7 +765,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
duckdb().verified_stmt(&format!("USE {}", object_name)), duckdb().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -773,7 +773,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
duckdb().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)), duckdb().verified_stmt(&format!("USE {0}{1}{0}", quote, object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))
@ -785,7 +785,7 @@ fn parse_use() {
// Test double identifier with different type of quotes // Test double identifier with different type of quotes
assert_eq!( assert_eq!(
duckdb().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)), duckdb().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)),
Statement::Use(Use::Object(ObjectName(vec![ Statement::Use(Use::Object(ObjectName::from(vec![
Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "CATALOG"),
Ident::with_quote(quote, "my_schema") Ident::with_quote(quote, "my_schema")
]))) ])))
@ -794,7 +794,7 @@ fn parse_use() {
// Test double identifier without quotes // Test double identifier without quotes
assert_eq!( assert_eq!(
duckdb().verified_stmt("USE mydb.my_schema"), duckdb().verified_stmt("USE mydb.my_schema"),
Statement::Use(Use::Object(ObjectName(vec![ Statement::Use(Use::Object(ObjectName::from(vec![
Ident::new("mydb"), Ident::new("mydb"),
Ident::new("my_schema") Ident::new("my_schema")
]))) ])))

13
tests/sqlparser_hive.rs
View file

@ -368,7 +368,7 @@ fn set_statement_with_minus() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![ variables: OneOrManyWithParens::One(ObjectName::from(vec![
Ident::new("hive"), Ident::new("hive"),
Ident::new("tez"), Ident::new("tez"),
Ident::new("java"), Ident::new("java"),
@ -461,7 +461,10 @@ fn parse_delimited_identifiers() {
json_path: _, json_path: _,
sample: _, sample: _,
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -480,7 +483,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -516,7 +519,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
hive().verified_stmt(&format!("USE {}", object_name)), hive().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -524,7 +527,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
hive().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)), hive().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))

44
tests/sqlparser_mssql.rs
View file

@ -63,7 +63,7 @@ fn parse_table_time_travel() {
select.from, select.from,
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t1")]), name: ObjectName::from(vec![Ident::new("t1")]),
alias: None, alias: None,
args: None, args: None,
with_hints: vec![], with_hints: vec![],
@ -159,7 +159,7 @@ fn parse_create_procedure() {
})) }))
} }
]), ]),
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test".into(), value: "test".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -211,7 +211,7 @@ fn parse_mssql_openjson() {
assert_eq!( assert_eq!(
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t_test_table")]), name: ObjectName::from(vec![Ident::new("t_test_table")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("A"), name: Ident::new("A"),
columns: vec![] columns: vec![]
@ -270,7 +270,7 @@ fn parse_mssql_openjson() {
assert_eq!( assert_eq!(
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t_test_table"),]), name: ObjectName::from(vec![Ident::new("t_test_table"),]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("A"), name: Ident::new("A"),
columns: vec![] columns: vec![]
@ -329,8 +329,7 @@ fn parse_mssql_openjson() {
assert_eq!( assert_eq!(
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t_test_table")]), name: ObjectName::from(vec![Ident::new("t_test_table")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("A"), name: Ident::new("A"),
columns: vec![] columns: vec![]
@ -389,7 +388,7 @@ fn parse_mssql_openjson() {
assert_eq!( assert_eq!(
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t_test_table")]), name: ObjectName::from(vec![Ident::new("t_test_table")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("A"), name: Ident::new("A"),
columns: vec![] columns: vec![]
@ -428,7 +427,7 @@ fn parse_mssql_openjson() {
assert_eq!( assert_eq!(
vec![TableWithJoins { vec![TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t_test_table")]), name: ObjectName::from(vec![Ident::new("t_test_table")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("A"), name: Ident::new("A"),
columns: vec![] columns: vec![]
@ -532,7 +531,7 @@ fn parse_mssql_create_role() {
assert_eq_vec(&["mssql"], &names); assert_eq_vec(&["mssql"], &names);
assert_eq!( assert_eq!(
authorization_owner, authorization_owner,
Some(ObjectName(vec![Ident { Some(ObjectName::from(vec![Ident {
value: "helena".into(), value: "helena".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -619,7 +618,10 @@ fn parse_delimited_identifiers() {
version, version,
.. ..
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -638,7 +640,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -671,11 +673,11 @@ fn parse_table_name_in_square_brackets() {
let select = ms().verified_only_select(r#"SELECT [a column] FROM [a schema].[a table]"#); let select = ms().verified_only_select(r#"SELECT [a column] FROM [a schema].[a table]"#);
if let TableFactor::Table { name, .. } = only(select.from).relation { if let TableFactor::Table { name, .. } = only(select.from).relation {
assert_eq!( assert_eq!(
vec![ ObjectName::from(vec![
Ident::with_quote('[', "a schema"), Ident::with_quote('[', "a schema"),
Ident::with_quote('[', "a table") Ident::with_quote('[', "a table")
], ]),
name.0 name
); );
} else { } else {
panic!("Expecting TableFactor::Table"); panic!("Expecting TableFactor::Table");
@ -1086,7 +1088,7 @@ fn parse_substring_in_select() {
})], })],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "test".to_string(), value: "test".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -1204,7 +1206,7 @@ fn parse_mssql_declare() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("@bar")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("@bar")])),
value: vec![Expr::Value(Value::Number("2".parse().unwrap(), false))], value: vec![Expr::Value(Value::Number("2".parse().unwrap(), false))],
}, },
Statement::Query(Box::new(Query { Statement::Query(Box::new(Query {
@ -1298,7 +1300,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
ms().verified_stmt(&format!("USE {}", object_name)), ms().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -1306,7 +1308,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
ms().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)), ms().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))
@ -1408,7 +1410,7 @@ fn parse_create_table_with_valid_options() {
}, },
value: Expr::Function( value: Expr::Function(
Function { Function {
name: ObjectName( name: ObjectName::from(
vec![ vec![
Ident { Ident {
value: "HASH".to_string(), value: "HASH".to_string(),
@ -1472,7 +1474,7 @@ fn parse_create_table_with_valid_options() {
if_not_exists: false, if_not_exists: false,
transient: false, transient: false,
volatile: false, volatile: false,
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "mytable".to_string(), value: "mytable".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -1648,7 +1650,7 @@ fn parse_create_table_with_identity_column() {
transient: false, transient: false,
volatile: false, volatile: false,
iceberg: false, iceberg: false,
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "mytable".to_string(), value: "mytable".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),

103
tests/sqlparser_mysql.rs
View file

@ -149,7 +149,7 @@ fn parse_flush() {
read_lock: false, read_lock: false,
export: false, export: false,
tables: vec![ tables: vec![
ObjectName(vec![ ObjectName::from(vec![
Ident { Ident {
value: "mek".to_string(), value: "mek".to_string(),
quote_style: Some('`'), quote_style: Some('`'),
@ -161,7 +161,7 @@ fn parse_flush() {
span: Span::empty(), span: Span::empty(),
} }
]), ]),
ObjectName(vec![Ident { ObjectName::from(vec![Ident {
value: "table2".to_string(), value: "table2".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -189,7 +189,7 @@ fn parse_flush() {
read_lock: true, read_lock: true,
export: false, export: false,
tables: vec![ tables: vec![
ObjectName(vec![ ObjectName::from(vec![
Ident { Ident {
value: "mek".to_string(), value: "mek".to_string(),
quote_style: Some('`'), quote_style: Some('`'),
@ -201,7 +201,7 @@ fn parse_flush() {
span: Span::empty(), span: Span::empty(),
} }
]), ]),
ObjectName(vec![Ident { ObjectName::from(vec![Ident {
value: "table2".to_string(), value: "table2".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -218,7 +218,7 @@ fn parse_flush() {
read_lock: false, read_lock: false,
export: true, export: true,
tables: vec![ tables: vec![
ObjectName(vec![ ObjectName::from(vec![
Ident { Ident {
value: "mek".to_string(), value: "mek".to_string(),
quote_style: Some('`'), quote_style: Some('`'),
@ -230,7 +230,7 @@ fn parse_flush() {
span: Span::empty(), span: Span::empty(),
} }
]), ]),
ObjectName(vec![Ident { ObjectName::from(vec![Ident {
value: "table2".to_string(), value: "table2".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -251,7 +251,7 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])),
}), }),
filter_position: None, filter_position: None,
limit_from: None, limit_from: None,
@ -269,7 +269,10 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mydb"), Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![
Ident::new("mydb"),
Ident::new("mytable")
])),
}), }),
filter_position: None, filter_position: None,
limit_from: None, limit_from: None,
@ -287,7 +290,7 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])),
}), }),
filter_position: None, filter_position: None,
limit_from: None, limit_from: None,
@ -305,7 +308,7 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])),
}), }),
filter_position: None, filter_position: None,
limit_from: None, limit_from: None,
@ -323,7 +326,7 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])),
}), }),
filter_position: Some(ShowStatementFilterPosition::Suffix( filter_position: Some(ShowStatementFilterPosition::Suffix(
ShowStatementFilter::Like("pattern".into()) ShowStatementFilter::Like("pattern".into())
@ -343,7 +346,7 @@ fn parse_show_columns() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mytable")])), parent_name: Some(ObjectName::from(vec![Ident::new("mytable")])),
}), }),
filter_position: Some(ShowStatementFilterPosition::Suffix( filter_position: Some(ShowStatementFilterPosition::Suffix(
ShowStatementFilter::Where(mysql_and_generic().verified_expr("1 = 2")) ShowStatementFilter::Where(mysql_and_generic().verified_expr("1 = 2"))
@ -430,7 +433,7 @@ fn parse_show_tables() {
show_in: Some(ShowStatementIn { show_in: Some(ShowStatementIn {
clause: ShowStatementInClause::FROM, clause: ShowStatementInClause::FROM,
parent_type: None, parent_type: None,
parent_name: Some(ObjectName(vec![Ident::new("mydb")])), parent_name: Some(ObjectName::from(vec![Ident::new("mydb")])),
}), }),
filter_position: None filter_position: None
} }
@ -534,7 +537,7 @@ fn parse_show_extended_full() {
#[test] #[test]
fn parse_show_create() { fn parse_show_create() {
let obj_name = ObjectName(vec![Ident::new("myident")]); let obj_name = ObjectName::from(vec![Ident::new("myident")]);
for obj_type in &[ for obj_type in &[
ShowCreateObject::Table, ShowCreateObject::Table,
@ -591,7 +594,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
mysql_and_generic().verified_stmt(&format!("USE {}", object_name)), mysql_and_generic().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -600,7 +603,7 @@ fn parse_use() {
assert_eq!( assert_eq!(
mysql_and_generic() mysql_and_generic()
.verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)), .verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))
@ -617,7 +620,7 @@ fn parse_set_variables() {
Statement::SetVariable { Statement::SetVariable {
local: true, local: true,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec!["autocommit".into()])), variables: OneOrManyWithParens::One(ObjectName::from(vec!["autocommit".into()])),
value: vec![Expr::Value(number("1"))], value: vec![Expr::Value(number("1"))],
} }
); );
@ -1017,7 +1020,7 @@ fn parse_create_table_comment_character_set() {
options: vec![ options: vec![
ColumnOptionDef { ColumnOptionDef {
name: None, name: None,
option: ColumnOption::CharacterSet(ObjectName(vec![Ident::new( option: ColumnOption::CharacterSet(ObjectName::from(vec![Ident::new(
"utf8mb4" "utf8mb4"
)])) )]))
}, },
@ -1413,7 +1416,7 @@ fn parse_simple_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tasks")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns); assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
@ -1471,7 +1474,7 @@ fn parse_ignore_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tasks")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns); assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
@ -1518,7 +1521,7 @@ fn parse_priority_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tasks")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns); assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
@ -1562,7 +1565,7 @@ fn parse_priority_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tasks")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns); assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
@ -1607,14 +1610,14 @@ fn parse_insert_as() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::with_quote('`', "table")])), TableObject::TableName(ObjectName::from(vec![Ident::with_quote('`', "table")])),
table_name table_name
); );
assert_eq!(vec![Ident::with_quote('`', "date")], columns); assert_eq!(vec![Ident::with_quote('`', "date")], columns);
let insert_alias = insert_alias.unwrap(); let insert_alias = insert_alias.unwrap();
assert_eq!( assert_eq!(
ObjectName(vec![Ident::with_quote('`', "alias")]), ObjectName::from(vec![Ident::with_quote('`', "alias")]),
insert_alias.row_alias insert_alias.row_alias
); );
assert_eq!(Some(vec![]), insert_alias.col_aliases); assert_eq!(Some(vec![]), insert_alias.col_aliases);
@ -1659,7 +1662,7 @@ fn parse_insert_as() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::with_quote('`', "table")])), TableObject::TableName(ObjectName::from(vec![Ident::with_quote('`', "table")])),
table_name table_name
); );
assert_eq!( assert_eq!(
@ -1668,7 +1671,7 @@ fn parse_insert_as() {
); );
let insert_alias = insert_alias.unwrap(); let insert_alias = insert_alias.unwrap();
assert_eq!( assert_eq!(
ObjectName(vec![Ident::with_quote('`', "alias")]), ObjectName::from(vec![Ident::with_quote('`', "alias")]),
insert_alias.row_alias insert_alias.row_alias
); );
assert_eq!( assert_eq!(
@ -1719,7 +1722,7 @@ fn parse_replace_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tasks")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tasks")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns); assert_eq!(vec![Ident::new("title"), Ident::new("priority")], columns);
@ -1766,7 +1769,7 @@ fn parse_empty_row_insert() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("tb")])), TableObject::TableName(ObjectName::from(vec![Ident::new("tb")])),
table_name table_name
); );
assert!(columns.is_empty()); assert!(columns.is_empty());
@ -1808,7 +1811,7 @@ fn parse_insert_with_on_duplicate_update() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("permission_groups")])), TableObject::TableName(ObjectName::from(vec![Ident::new("permission_groups")])),
table_name table_name
); );
assert_eq!( assert_eq!(
@ -1855,31 +1858,31 @@ fn parse_insert_with_on_duplicate_update() {
assert_eq!( assert_eq!(
Some(OnInsert::DuplicateKeyUpdate(vec![ Some(OnInsert::DuplicateKeyUpdate(vec![
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new( target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new(
"description".to_string() "description".to_string()
)])), )])),
value: call("VALUES", [Expr::Identifier(Ident::new("description"))]), value: call("VALUES", [Expr::Identifier(Ident::new("description"))]),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new( target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new(
"perm_create".to_string() "perm_create".to_string()
)])), )])),
value: call("VALUES", [Expr::Identifier(Ident::new("perm_create"))]), value: call("VALUES", [Expr::Identifier(Ident::new("perm_create"))]),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new( target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new(
"perm_read".to_string() "perm_read".to_string()
)])), )])),
value: call("VALUES", [Expr::Identifier(Ident::new("perm_read"))]), value: call("VALUES", [Expr::Identifier(Ident::new("perm_read"))]),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new( target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new(
"perm_update".to_string() "perm_update".to_string()
)])), )])),
value: call("VALUES", [Expr::Identifier(Ident::new("perm_update"))]), value: call("VALUES", [Expr::Identifier(Ident::new("perm_update"))]),
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![Ident::new( target: AssignmentTarget::ColumnName(ObjectName::from(vec![Ident::new(
"perm_delete".to_string() "perm_delete".to_string()
)])), )])),
value: call("VALUES", [Expr::Identifier(Ident::new("perm_delete"))]), value: call("VALUES", [Expr::Identifier(Ident::new("perm_delete"))]),
@ -1910,7 +1913,7 @@ fn parse_select_with_numeric_prefix_column_name() {
)))], )))],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::with_quote( relation: table_from_name(ObjectName::from(vec![Ident::with_quote(
'"', "table" '"', "table"
)])), )])),
joins: vec![] joins: vec![]
@ -1962,7 +1965,7 @@ fn parse_select_with_concatenation_of_exp_number_and_numeric_prefix_column() {
], ],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::with_quote( relation: table_from_name(ObjectName::from(vec![Ident::with_quote(
'"', "table" '"', "table"
)])), )])),
joins: vec![] joins: vec![]
@ -1997,7 +2000,7 @@ fn parse_insert_with_numeric_prefix_column_name() {
.. ..
}) => { }) => {
assert_eq!( assert_eq!(
TableObject::TableName(ObjectName(vec![Ident::new("s1"), Ident::new("t1")])), TableObject::TableName(ObjectName::from(vec![Ident::new("s1"), Ident::new("t1")])),
table_name table_name
); );
assert_eq!(vec![Ident::new("123col_$@length123")], columns); assert_eq!(vec![Ident::new("123col_$@length123")], columns);
@ -2021,7 +2024,7 @@ fn parse_update_with_joins() {
assert_eq!( assert_eq!(
TableWithJoins { TableWithJoins {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("orders")]), name: ObjectName::from(vec![Ident::new("orders")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("o"), name: Ident::new("o"),
columns: vec![] columns: vec![]
@ -2036,7 +2039,7 @@ fn parse_update_with_joins() {
}, },
joins: vec![Join { joins: vec![Join {
relation: TableFactor::Table { relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("customers")]), name: ObjectName::from(vec![Ident::new("customers")]),
alias: Some(TableAlias { alias: Some(TableAlias {
name: Ident::new("c"), name: Ident::new("c"),
columns: vec![] columns: vec![]
@ -2067,7 +2070,7 @@ fn parse_update_with_joins() {
); );
assert_eq!( assert_eq!(
vec![Assignment { vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec![ target: AssignmentTarget::ColumnName(ObjectName::from(vec![
Ident::new("o"), Ident::new("o"),
Ident::new("completed") Ident::new("completed")
])), ])),
@ -2255,7 +2258,7 @@ fn parse_alter_table_drop_primary_key() {
#[test] #[test]
fn parse_alter_table_change_column() { fn parse_alter_table_change_column() {
let expected_name = ObjectName(vec![Ident::new("orders")]); let expected_name = ObjectName::from(vec![Ident::new("orders")]);
let expected_operation = AlterTableOperation::ChangeColumn { let expected_operation = AlterTableOperation::ChangeColumn {
old_name: Ident::new("description"), old_name: Ident::new("description"),
new_name: Ident::new("desc"), new_name: Ident::new("desc"),
@ -2307,7 +2310,7 @@ fn parse_alter_table_change_column() {
#[test] #[test]
fn parse_alter_table_change_column_with_column_position() { fn parse_alter_table_change_column_with_column_position() {
let expected_name = ObjectName(vec![Ident::new("orders")]); let expected_name = ObjectName::from(vec![Ident::new("orders")]);
let expected_operation_first = AlterTableOperation::ChangeColumn { let expected_operation_first = AlterTableOperation::ChangeColumn {
old_name: Ident::new("description"), old_name: Ident::new("description"),
new_name: Ident::new("desc"), new_name: Ident::new("desc"),
@ -2355,7 +2358,7 @@ fn parse_alter_table_change_column_with_column_position() {
#[test] #[test]
fn parse_alter_table_modify_column() { fn parse_alter_table_modify_column() {
let expected_name = ObjectName(vec![Ident::new("orders")]); let expected_name = ObjectName::from(vec![Ident::new("orders")]);
let expected_operation = AlterTableOperation::ModifyColumn { let expected_operation = AlterTableOperation::ModifyColumn {
col_name: Ident::new("description"), col_name: Ident::new("description"),
data_type: DataType::Text, data_type: DataType::Text,
@ -2404,7 +2407,7 @@ fn parse_alter_table_modify_column() {
#[test] #[test]
fn parse_alter_table_modify_column_with_column_position() { fn parse_alter_table_modify_column_with_column_position() {
let expected_name = ObjectName(vec![Ident::new("orders")]); let expected_name = ObjectName::from(vec![Ident::new("orders")]);
let expected_operation_first = AlterTableOperation::ModifyColumn { let expected_operation_first = AlterTableOperation::ModifyColumn {
col_name: Ident::new("description"), col_name: Ident::new("description"),
data_type: DataType::Text, data_type: DataType::Text,
@ -2478,7 +2481,7 @@ fn parse_substring_in_select() {
})], })],
into: None, into: None,
from: vec![TableWithJoins { from: vec![TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident { relation: table_from_name(ObjectName::from(vec![Ident {
value: "test".to_string(), value: "test".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -2873,10 +2876,12 @@ fn parse_create_table_with_column_collate() {
vec![ColumnDef { vec![ColumnDef {
name: Ident::new("id"), name: Ident::new("id"),
data_type: DataType::Text, data_type: DataType::Text,
collation: Some(ObjectName(vec![Ident::new("utf8mb4_0900_ai_ci")])), collation: Some(ObjectName::from(vec![Ident::new("utf8mb4_0900_ai_ci")])),
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::CharacterSet(ObjectName(vec![Ident::new("utf8mb4")])) option: ColumnOption::CharacterSet(ObjectName::from(vec![Ident::new(
"utf8mb4"
)]))
}], }],
},], },],
columns columns
@ -3039,7 +3044,7 @@ fn parse_grant() {
); );
assert_eq!( assert_eq!(
objects, objects,
GrantObjects::Tables(vec![ObjectName(vec!["*".into(), "*".into()])]) GrantObjects::Tables(vec![ObjectName::from(vec!["*".into(), "*".into()])])
); );
assert!(!with_grant_option); assert!(!with_grant_option);
assert!(granted_by.is_none()); assert!(granted_by.is_none());
@ -3080,7 +3085,7 @@ fn parse_revoke() {
); );
assert_eq!( assert_eq!(
objects, objects,
GrantObjects::Tables(vec![ObjectName(vec!["db1".into(), "*".into()])]) GrantObjects::Tables(vec![ObjectName::from(vec!["db1".into(), "*".into()])])
); );
if let [Grantee { if let [Grantee {
grantee_type: GranteesType::None, grantee_type: GranteesType::None,

199
tests/sqlparser_postgres.rs
View file

@ -402,7 +402,7 @@ fn parse_create_table_with_defaults() {
unit: None unit: None
} }
)), )),
collation: Some(ObjectName(vec![Ident::with_quote('"', "es_ES")])), collation: Some(ObjectName::from(vec![Ident::with_quote('"', "es_ES")])),
options: vec![ColumnOptionDef { options: vec![ColumnOptionDef {
name: None, name: None,
option: ColumnOption::NotNull, option: ColumnOption::NotNull,
@ -1040,7 +1040,7 @@ fn test_copy_from() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: false, to: false,
@ -1058,7 +1058,7 @@ fn test_copy_from() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: false, to: false,
@ -1076,7 +1076,7 @@ fn test_copy_from() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: false, to: false,
@ -1100,7 +1100,7 @@ fn test_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1118,7 +1118,7 @@ fn test_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1136,7 +1136,7 @@ fn test_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1177,7 +1177,7 @@ fn parse_copy_from() {
pg_and_generic().one_statement_parses_to(sql, ""), pg_and_generic().one_statement_parses_to(sql, ""),
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["table".into()]), table_name: ObjectName::from(vec!["table".into()]),
columns: vec!["a".into(), "b".into()], columns: vec!["a".into(), "b".into()],
}, },
to: false, to: false,
@ -1223,7 +1223,7 @@ fn parse_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1241,7 +1241,7 @@ fn parse_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["country".into()]), table_name: ObjectName::from(vec!["country".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1258,7 +1258,7 @@ fn parse_copy_to() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["country".into()]), table_name: ObjectName::from(vec!["country".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1344,7 +1344,7 @@ fn parse_copy_from_before_v9_0() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: false, to: false,
@ -1373,7 +1373,7 @@ fn parse_copy_from_before_v9_0() {
pg_and_generic().one_statement_parses_to(sql, ""), pg_and_generic().one_statement_parses_to(sql, ""),
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: false, to: false,
@ -1401,7 +1401,7 @@ fn parse_copy_to_before_v9_0() {
stmt, stmt,
Statement::Copy { Statement::Copy {
source: CopySource::Table { source: CopySource::Table {
table_name: ObjectName(vec!["users".into()]), table_name: ObjectName::from(vec!["users".into()]),
columns: vec![], columns: vec![],
}, },
to: true, to: true,
@ -1433,7 +1433,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
value: vec![Expr::Identifier(Ident { value: vec![Expr::Identifier(Ident {
value: "b".into(), value: "b".into(),
quote_style: None, quote_style: None,
@ -1448,7 +1448,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
value: vec![Expr::Value(Value::SingleQuotedString("b".into()))], value: vec![Expr::Value(Value::SingleQuotedString("b".into()))],
} }
); );
@ -1459,7 +1459,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
value: vec![Expr::Value(number("0"))], value: vec![Expr::Value(number("0"))],
} }
); );
@ -1470,7 +1470,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
value: vec![Expr::Identifier(Ident::new("DEFAULT"))], value: vec![Expr::Identifier(Ident::new("DEFAULT"))],
} }
); );
@ -1481,7 +1481,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: true, local: true,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![Ident::new("a")])), variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
value: vec![Expr::Identifier("b".into())], value: vec![Expr::Identifier("b".into())],
} }
); );
@ -1492,7 +1492,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![ variables: OneOrManyWithParens::One(ObjectName::from(vec![
Ident::new("a"), Ident::new("a"),
Ident::new("b"), Ident::new("b"),
Ident::new("c") Ident::new("c")
@ -1514,7 +1514,7 @@ fn parse_set() {
Statement::SetVariable { Statement::SetVariable {
local: false, local: false,
hivevar: false, hivevar: false,
variables: OneOrManyWithParens::One(ObjectName(vec![ variables: OneOrManyWithParens::One(ObjectName::from(vec![
Ident::new("hive"), Ident::new("hive"),
Ident::new("tez"), Ident::new("tez"),
Ident::new("auto"), Ident::new("auto"),
@ -1658,7 +1658,7 @@ fn parse_execute() {
assert_eq!( assert_eq!(
stmt, stmt,
Statement::Execute { Statement::Execute {
name: ObjectName(vec!["a".into()]), name: ObjectName::from(vec!["a".into()]),
parameters: vec![], parameters: vec![],
has_parentheses: false, has_parentheses: false,
using: vec![] using: vec![]
@ -1669,7 +1669,7 @@ fn parse_execute() {
assert_eq!( assert_eq!(
stmt, stmt,
Statement::Execute { Statement::Execute {
name: ObjectName(vec!["a".into()]), name: ObjectName::from(vec!["a".into()]),
parameters: vec![ parameters: vec![
Expr::Value(number("1")), Expr::Value(number("1")),
Expr::Value(Value::SingleQuotedString("t".to_string())) Expr::Value(Value::SingleQuotedString("t".to_string()))
@ -1684,7 +1684,7 @@ fn parse_execute() {
assert_eq!( assert_eq!(
stmt, stmt,
Statement::Execute { Statement::Execute {
name: ObjectName(vec!["a".into()]), name: ObjectName::from(vec!["a".into()]),
parameters: vec![], parameters: vec![],
has_parentheses: false, has_parentheses: false,
using: vec![ using: vec![
@ -1793,7 +1793,9 @@ fn parse_pg_on_conflict() {
assert_eq!( assert_eq!(
OnConflictAction::DoUpdate(DoUpdate { OnConflictAction::DoUpdate(DoUpdate {
assignments: vec![Assignment { assignments: vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["dname".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(
vec!["dname".into()]
)),
value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "dname".into()]) value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "dname".into()])
},], },],
selection: None selection: None
@ -1824,14 +1826,18 @@ fn parse_pg_on_conflict() {
OnConflictAction::DoUpdate(DoUpdate { OnConflictAction::DoUpdate(DoUpdate {
assignments: vec![ assignments: vec![
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["dname".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(vec![
"dname".into()
])),
value: Expr::CompoundIdentifier(vec![ value: Expr::CompoundIdentifier(vec![
"EXCLUDED".into(), "EXCLUDED".into(),
"dname".into() "dname".into()
]) ])
}, },
Assignment { Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["area".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(vec![
"area".into()
])),
value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "area".into()]) value: Expr::CompoundIdentifier(vec!["EXCLUDED".into(), "area".into()])
}, },
], ],
@ -1881,7 +1887,9 @@ fn parse_pg_on_conflict() {
assert_eq!( assert_eq!(
OnConflictAction::DoUpdate(DoUpdate { OnConflictAction::DoUpdate(DoUpdate {
assignments: vec![Assignment { assignments: vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["dname".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(
vec!["dname".into()]
)),
value: Expr::Value(Value::Placeholder("$1".to_string())) value: Expr::Value(Value::Placeholder("$1".to_string()))
},], },],
selection: Some(Expr::BinaryOp { selection: Some(Expr::BinaryOp {
@ -1915,11 +1923,16 @@ fn parse_pg_on_conflict() {
})), })),
.. ..
}) => { }) => {
assert_eq!(vec![Ident::from("distributors_did_pkey")], cname.0); assert_eq!(
ObjectName::from(vec![Ident::from("distributors_did_pkey")]),
cname
);
assert_eq!( assert_eq!(
OnConflictAction::DoUpdate(DoUpdate { OnConflictAction::DoUpdate(DoUpdate {
assignments: vec![Assignment { assignments: vec![Assignment {
target: AssignmentTarget::ColumnName(ObjectName(vec!["dname".into()])), target: AssignmentTarget::ColumnName(ObjectName::from(
vec!["dname".into()]
)),
value: Expr::Value(Value::Placeholder("$1".to_string())) value: Expr::Value(Value::Placeholder("$1".to_string()))
},], },],
selection: Some(Expr::BinaryOp { selection: Some(Expr::BinaryOp {
@ -2624,7 +2637,7 @@ fn parse_array_subquery_expr() {
let select = pg().verified_only_select(sql); let select = pg().verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("ARRAY")]), name: ObjectName::from(vec![Ident::new("ARRAY")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::Subquery(Box::new(Query { args: FunctionArguments::Subquery(Box::new(Query {
@ -2963,7 +2976,10 @@ fn parse_json_table_is_not_reserved() {
TableFactor::Table { TableFactor::Table {
name: ObjectName(name), name: ObjectName(name),
.. ..
} => assert_eq!("JSON_TABLE", name[0].value), } => assert_eq!(
ObjectNamePart::Identifier(Ident::new("JSON_TABLE")),
name[0]
),
other => panic!("Expected: JSON_TABLE to be parsed as a table name, but got {other:?}"), other => panic!("Expected: JSON_TABLE to be parsed as a table name, but got {other:?}"),
} }
} }
@ -3004,7 +3020,7 @@ fn test_composite_value() {
SelectItem::UnnamedExpr(Expr::CompositeAccess { SelectItem::UnnamedExpr(Expr::CompositeAccess {
key: Ident::new("n"), key: Ident::new("n"),
expr: Box::new(Expr::Nested(Box::new(Expr::Function(Function { expr: Box::new(Expr::Nested(Box::new(Expr::Function(Function {
name: ObjectName(vec![ name: ObjectName::from(vec![
Ident::new("information_schema"), Ident::new("information_schema"),
Ident::new("_pg_expandarray") Ident::new("_pg_expandarray")
]), ]),
@ -3185,7 +3201,7 @@ fn parse_current_functions() {
let select = pg_and_generic().verified_only_select(sql); let select = pg_and_generic().verified_only_select(sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("CURRENT_CATALOG")]), name: ObjectName::from(vec![Ident::new("CURRENT_CATALOG")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::None, args: FunctionArguments::None,
@ -3198,7 +3214,7 @@ fn parse_current_functions() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("CURRENT_USER")]), name: ObjectName::from(vec![Ident::new("CURRENT_USER")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::None, args: FunctionArguments::None,
@ -3211,7 +3227,7 @@ fn parse_current_functions() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("SESSION_USER")]), name: ObjectName::from(vec![Ident::new("SESSION_USER")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::None, args: FunctionArguments::None,
@ -3224,7 +3240,7 @@ fn parse_current_functions() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::new("USER")]), name: ObjectName::from(vec![Ident::new("USER")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::None, args: FunctionArguments::None,
@ -3536,7 +3552,7 @@ fn parse_alter_role() {
span: Span::empty(), span: Span::empty(),
}, },
operation: AlterRoleOperation::Set { operation: AlterRoleOperation::Set {
config_name: ObjectName(vec![Ident { config_name: ObjectName::from(vec![Ident {
value: "maintenance_work_mem".into(), value: "maintenance_work_mem".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3557,13 +3573,13 @@ fn parse_alter_role() {
span: Span::empty(), span: Span::empty(),
}, },
operation: AlterRoleOperation::Set { operation: AlterRoleOperation::Set {
config_name: ObjectName(vec![Ident { config_name: ObjectName::from(vec![Ident {
value: "maintenance_work_mem".into(), value: "maintenance_work_mem".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}]), }]),
config_value: SetConfigValue::Value(Expr::Value(number("100000"))), config_value: SetConfigValue::Value(Expr::Value(number("100000"))),
in_database: Some(ObjectName(vec![Ident { in_database: Some(ObjectName::from(vec![Ident {
value: "database_name".into(), value: "database_name".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3582,13 +3598,13 @@ fn parse_alter_role() {
span: Span::empty(), span: Span::empty(),
}, },
operation: AlterRoleOperation::Set { operation: AlterRoleOperation::Set {
config_name: ObjectName(vec![Ident { config_name: ObjectName::from(vec![Ident {
value: "maintenance_work_mem".into(), value: "maintenance_work_mem".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}]), }]),
config_value: SetConfigValue::Value(Expr::Value(number("100000"))), config_value: SetConfigValue::Value(Expr::Value(number("100000"))),
in_database: Some(ObjectName(vec![Ident { in_database: Some(ObjectName::from(vec![Ident {
value: "database_name".into(), value: "database_name".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3607,13 +3623,13 @@ fn parse_alter_role() {
span: Span::empty(), span: Span::empty(),
}, },
operation: AlterRoleOperation::Set { operation: AlterRoleOperation::Set {
config_name: ObjectName(vec![Ident { config_name: ObjectName::from(vec![Ident {
value: "maintenance_work_mem".into(), value: "maintenance_work_mem".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}]), }]),
config_value: SetConfigValue::Default, config_value: SetConfigValue::Default,
in_database: Some(ObjectName(vec![Ident { in_database: Some(ObjectName::from(vec![Ident {
value: "database_name".into(), value: "database_name".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3648,12 +3664,12 @@ fn parse_alter_role() {
span: Span::empty(), span: Span::empty(),
}, },
operation: AlterRoleOperation::Reset { operation: AlterRoleOperation::Reset {
config_name: ResetConfig::ConfigName(ObjectName(vec![Ident { config_name: ResetConfig::ConfigName(ObjectName::from(vec![Ident {
value: "maintenance_work_mem".into(), value: "maintenance_work_mem".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
}])), }])),
in_database: Some(ObjectName(vec![Ident { in_database: Some(ObjectName::from(vec![Ident {
value: "database_name".into(), value: "database_name".into(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3679,7 +3695,10 @@ fn parse_delimited_identifiers() {
version, version,
.. ..
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -3698,7 +3717,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -3754,7 +3773,7 @@ fn parse_create_function() {
Statement::CreateFunction(CreateFunction { Statement::CreateFunction(CreateFunction {
or_replace: false, or_replace: false,
temporary: false, temporary: false,
name: ObjectName(vec![Ident::new("add")]), name: ObjectName::from(vec![Ident::new("add")]),
args: Some(vec![ args: Some(vec![
OperateFunctionArg::unnamed(DataType::Integer(None)), OperateFunctionArg::unnamed(DataType::Integer(None)),
OperateFunctionArg::unnamed(DataType::Integer(None)), OperateFunctionArg::unnamed(DataType::Integer(None)),
@ -3798,7 +3817,7 @@ fn parse_drop_function() {
Statement::DropFunction { Statement::DropFunction {
if_exists: true, if_exists: true,
func_desc: vec![FunctionDesc { func_desc: vec![FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_func".to_string(), value: "test_func".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3815,7 +3834,7 @@ fn parse_drop_function() {
Statement::DropFunction { Statement::DropFunction {
if_exists: true, if_exists: true,
func_desc: vec![FunctionDesc { func_desc: vec![FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_func".to_string(), value: "test_func".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3841,7 +3860,7 @@ fn parse_drop_function() {
if_exists: true, if_exists: true,
func_desc: vec![ func_desc: vec![
FunctionDesc { FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_func1".to_string(), value: "test_func1".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3860,7 +3879,7 @@ fn parse_drop_function() {
]), ]),
}, },
FunctionDesc { FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_func2".to_string(), value: "test_func2".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3892,7 +3911,7 @@ fn parse_drop_procedure() {
Statement::DropProcedure { Statement::DropProcedure {
if_exists: true, if_exists: true,
proc_desc: vec![FunctionDesc { proc_desc: vec![FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_proc".to_string(), value: "test_proc".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3909,7 +3928,7 @@ fn parse_drop_procedure() {
Statement::DropProcedure { Statement::DropProcedure {
if_exists: true, if_exists: true,
proc_desc: vec![FunctionDesc { proc_desc: vec![FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_proc".to_string(), value: "test_proc".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3935,7 +3954,7 @@ fn parse_drop_procedure() {
if_exists: true, if_exists: true,
proc_desc: vec![ proc_desc: vec![
FunctionDesc { FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_proc1".to_string(), value: "test_proc1".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -3954,7 +3973,7 @@ fn parse_drop_procedure() {
]), ]),
}, },
FunctionDesc { FunctionDesc {
name: ObjectName(vec![Ident { name: ObjectName::from(vec![Ident {
value: "test_proc2".to_string(), value: "test_proc2".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -4136,7 +4155,7 @@ fn parse_select_group_by_cube() {
#[test] #[test]
fn parse_truncate() { fn parse_truncate() {
let truncate = pg_and_generic().verified_stmt("TRUNCATE db.table_name"); let truncate = pg_and_generic().verified_stmt("TRUNCATE db.table_name");
let table_name = ObjectName(vec![Ident::new("db"), Ident::new("table_name")]); let table_name = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]);
let table_names = vec![TruncateTableTarget { let table_names = vec![TruncateTableTarget {
name: table_name.clone(), name: table_name.clone(),
}]; }];
@ -4159,7 +4178,7 @@ fn parse_truncate_with_options() {
let truncate = pg_and_generic() let truncate = pg_and_generic()
.verified_stmt("TRUNCATE TABLE ONLY db.table_name RESTART IDENTITY CASCADE"); .verified_stmt("TRUNCATE TABLE ONLY db.table_name RESTART IDENTITY CASCADE");
let table_name = ObjectName(vec![Ident::new("db"), Ident::new("table_name")]); let table_name = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]);
let table_names = vec![TruncateTableTarget { let table_names = vec![TruncateTableTarget {
name: table_name.clone(), name: table_name.clone(),
}]; }];
@ -4184,8 +4203,8 @@ fn parse_truncate_with_table_list() {
"TRUNCATE TABLE db.table_name, db.other_table_name RESTART IDENTITY CASCADE", "TRUNCATE TABLE db.table_name, db.other_table_name RESTART IDENTITY CASCADE",
); );
let table_name_a = ObjectName(vec![Ident::new("db"), Ident::new("table_name")]); let table_name_a = ObjectName::from(vec![Ident::new("db"), Ident::new("table_name")]);
let table_name_b = ObjectName(vec![Ident::new("db"), Ident::new("other_table_name")]); let table_name_b = ObjectName::from(vec![Ident::new("db"), Ident::new("other_table_name")]);
let table_names = vec![ let table_names = vec![
TruncateTableTarget { TruncateTableTarget {
@ -4381,7 +4400,7 @@ fn test_simple_postgres_insert_with_alias() {
or: None, or: None,
ignore: false, ignore: false,
into: true, into: true,
table: TableObject::TableName(ObjectName(vec![Ident { table: TableObject::TableName(ObjectName::from(vec![Ident {
value: "test_tables".to_string(), value: "test_tables".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -4451,7 +4470,7 @@ fn test_simple_postgres_insert_with_alias() {
or: None, or: None,
ignore: false, ignore: false,
into: true, into: true,
table: TableObject::TableName(ObjectName(vec![Ident { table: TableObject::TableName(ObjectName::from(vec![Ident {
value: "test_tables".to_string(), value: "test_tables".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -4523,7 +4542,7 @@ fn test_simple_insert_with_quoted_alias() {
or: None, or: None,
ignore: false, ignore: false,
into: true, into: true,
table: TableObject::TableName(ObjectName(vec![Ident { table: TableObject::TableName(ObjectName::from(vec![Ident {
value: "test_tables".to_string(), value: "test_tables".to_string(),
quote_style: None, quote_style: None,
span: Span::empty(), span: Span::empty(),
@ -4720,10 +4739,10 @@ fn parse_create_simple_before_insert_trigger() {
let expected = Statement::CreateTrigger { let expected = Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: false, is_constraint: false,
name: ObjectName(vec![Ident::new("check_insert")]), name: ObjectName::from(vec![Ident::new("check_insert")]),
period: TriggerPeriod::Before, period: TriggerPeriod::Before,
events: vec![TriggerEvent::Insert], events: vec![TriggerEvent::Insert],
table_name: ObjectName(vec![Ident::new("accounts")]), table_name: ObjectName::from(vec![Ident::new("accounts")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![], referencing: vec![],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -4732,7 +4751,7 @@ fn parse_create_simple_before_insert_trigger() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("check_account_insert")]), name: ObjectName::from(vec![Ident::new("check_account_insert")]),
args: None, args: None,
}, },
}, },
@ -4748,10 +4767,10 @@ fn parse_create_after_update_trigger_with_condition() {
let expected = Statement::CreateTrigger { let expected = Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: false, is_constraint: false,
name: ObjectName(vec![Ident::new("check_update")]), name: ObjectName::from(vec![Ident::new("check_update")]),
period: TriggerPeriod::After, period: TriggerPeriod::After,
events: vec![TriggerEvent::Update(vec![])], events: vec![TriggerEvent::Update(vec![])],
table_name: ObjectName(vec![Ident::new("accounts")]), table_name: ObjectName::from(vec![Ident::new("accounts")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![], referencing: vec![],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -4767,7 +4786,7 @@ fn parse_create_after_update_trigger_with_condition() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("check_account_update")]), name: ObjectName::from(vec![Ident::new("check_account_update")]),
args: None, args: None,
}, },
}, },
@ -4783,10 +4802,10 @@ fn parse_create_instead_of_delete_trigger() {
let expected = Statement::CreateTrigger { let expected = Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: false, is_constraint: false,
name: ObjectName(vec![Ident::new("check_delete")]), name: ObjectName::from(vec![Ident::new("check_delete")]),
period: TriggerPeriod::InsteadOf, period: TriggerPeriod::InsteadOf,
events: vec![TriggerEvent::Delete], events: vec![TriggerEvent::Delete],
table_name: ObjectName(vec![Ident::new("accounts")]), table_name: ObjectName::from(vec![Ident::new("accounts")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![], referencing: vec![],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -4795,7 +4814,7 @@ fn parse_create_instead_of_delete_trigger() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("check_account_deletes")]), name: ObjectName::from(vec![Ident::new("check_account_deletes")]),
args: None, args: None,
}, },
}, },
@ -4811,14 +4830,14 @@ fn parse_create_trigger_with_multiple_events_and_deferrable() {
let expected = Statement::CreateTrigger { let expected = Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: true, is_constraint: true,
name: ObjectName(vec![Ident::new("check_multiple_events")]), name: ObjectName::from(vec![Ident::new("check_multiple_events")]),
period: TriggerPeriod::Before, period: TriggerPeriod::Before,
events: vec![ events: vec![
TriggerEvent::Insert, TriggerEvent::Insert,
TriggerEvent::Update(vec![]), TriggerEvent::Update(vec![]),
TriggerEvent::Delete, TriggerEvent::Delete,
], ],
table_name: ObjectName(vec![Ident::new("accounts")]), table_name: ObjectName::from(vec![Ident::new("accounts")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![], referencing: vec![],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -4827,7 +4846,7 @@ fn parse_create_trigger_with_multiple_events_and_deferrable() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("check_account_changes")]), name: ObjectName::from(vec![Ident::new("check_account_changes")]),
args: None, args: None,
}, },
}, },
@ -4847,21 +4866,21 @@ fn parse_create_trigger_with_referencing() {
let expected = Statement::CreateTrigger { let expected = Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: false, is_constraint: false,
name: ObjectName(vec![Ident::new("check_referencing")]), name: ObjectName::from(vec![Ident::new("check_referencing")]),
period: TriggerPeriod::Before, period: TriggerPeriod::Before,
events: vec![TriggerEvent::Insert], events: vec![TriggerEvent::Insert],
table_name: ObjectName(vec![Ident::new("accounts")]), table_name: ObjectName::from(vec![Ident::new("accounts")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![ referencing: vec![
TriggerReferencing { TriggerReferencing {
refer_type: TriggerReferencingType::NewTable, refer_type: TriggerReferencingType::NewTable,
is_as: true, is_as: true,
transition_relation_name: ObjectName(vec![Ident::new("new_accounts")]), transition_relation_name: ObjectName::from(vec![Ident::new("new_accounts")]),
}, },
TriggerReferencing { TriggerReferencing {
refer_type: TriggerReferencingType::OldTable, refer_type: TriggerReferencingType::OldTable,
is_as: true, is_as: true,
transition_relation_name: ObjectName(vec![Ident::new("old_accounts")]), transition_relation_name: ObjectName::from(vec![Ident::new("old_accounts")]),
}, },
], ],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -4870,7 +4889,7 @@ fn parse_create_trigger_with_referencing() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("check_account_referencing")]), name: ObjectName::from(vec![Ident::new("check_account_referencing")]),
args: None, args: None,
}, },
}, },
@ -4929,8 +4948,8 @@ fn parse_drop_trigger() {
pg().verified_stmt(sql), pg().verified_stmt(sql),
Statement::DropTrigger { Statement::DropTrigger {
if_exists, if_exists,
trigger_name: ObjectName(vec![Ident::new("check_update")]), trigger_name: ObjectName::from(vec![Ident::new("check_update")]),
table_name: ObjectName(vec![Ident::new("table_name")]), table_name: ObjectName::from(vec![Ident::new("table_name")]),
option option
} }
); );
@ -5044,7 +5063,7 @@ fn parse_trigger_related_functions() {
transient: false, transient: false,
volatile: false, volatile: false,
iceberg: false, iceberg: false,
name: ObjectName(vec![Ident::new("emp")]), name: ObjectName::from(vec![Ident::new("emp")]),
columns: vec![ columns: vec![
ColumnDef { ColumnDef {
name: "empname".into(), name: "empname".into(),
@ -5126,7 +5145,7 @@ fn parse_trigger_related_functions() {
or_replace: false, or_replace: false,
temporary: false, temporary: false,
if_not_exists: false, if_not_exists: false,
name: ObjectName(vec![Ident::new("emp_stamp")]), name: ObjectName::from(vec![Ident::new("emp_stamp")]),
args: None, args: None,
return_type: Some(DataType::Trigger), return_type: Some(DataType::Trigger),
function_body: Some( function_body: Some(
@ -5161,10 +5180,10 @@ fn parse_trigger_related_functions() {
Statement::CreateTrigger { Statement::CreateTrigger {
or_replace: false, or_replace: false,
is_constraint: false, is_constraint: false,
name: ObjectName(vec![Ident::new("emp_stamp")]), name: ObjectName::from(vec![Ident::new("emp_stamp")]),
period: TriggerPeriod::Before, period: TriggerPeriod::Before,
events: vec![TriggerEvent::Insert, TriggerEvent::Update(vec![])], events: vec![TriggerEvent::Insert, TriggerEvent::Update(vec![])],
table_name: ObjectName(vec![Ident::new("emp")]), table_name: ObjectName::from(vec![Ident::new("emp")]),
referenced_table_name: None, referenced_table_name: None,
referencing: vec![], referencing: vec![],
trigger_object: TriggerObject::Row, trigger_object: TriggerObject::Row,
@ -5173,7 +5192,7 @@ fn parse_trigger_related_functions() {
exec_body: TriggerExecBody { exec_body: TriggerExecBody {
exec_type: TriggerExecBodyType::Function, exec_type: TriggerExecBodyType::Function,
func_desc: FunctionDesc { func_desc: FunctionDesc {
name: ObjectName(vec![Ident::new("emp_stamp")]), name: ObjectName::from(vec![Ident::new("emp_stamp")]),
args: None, args: None,
} }
}, },
@ -5186,8 +5205,8 @@ fn parse_trigger_related_functions() {
drop_trigger, drop_trigger,
Statement::DropTrigger { Statement::DropTrigger {
if_exists: false, if_exists: false,
trigger_name: ObjectName(vec![Ident::new("emp_stamp")]), trigger_name: ObjectName::from(vec![Ident::new("emp_stamp")]),
table_name: ObjectName(vec![Ident::new("emp")]), table_name: ObjectName::from(vec![Ident::new("emp")]),
option: None option: None
} }
); );

17
tests/sqlparser_redshift.rs
View file

@ -39,7 +39,7 @@ fn test_square_brackets_over_db_schema_table_name() {
assert_eq!( assert_eq!(
select.from[0], select.from[0],
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec![ relation: table_from_name(ObjectName::from(vec![
Ident { Ident {
value: "test_schema".to_string(), value: "test_schema".to_string(),
quote_style: Some('['), quote_style: Some('['),
@ -81,7 +81,7 @@ fn test_double_quotes_over_db_schema_table_name() {
assert_eq!( assert_eq!(
select.from[0], select.from[0],
TableWithJoins { TableWithJoins {
relation: table_from_name(ObjectName(vec![ relation: table_from_name(ObjectName::from(vec![
Ident { Ident {
value: "test_schema".to_string(), value: "test_schema".to_string(),
quote_style: Some('"'), quote_style: Some('"'),
@ -114,7 +114,10 @@ fn parse_delimited_identifiers() {
version, version,
.. ..
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -133,7 +136,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -297,7 +300,7 @@ fn test_parse_json_path_from() {
TableFactor::Table { TableFactor::Table {
name, json_path, .. name, json_path, ..
} => { } => {
assert_eq!(name, &ObjectName(vec![Ident::new("src")])); assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
assert_eq!( assert_eq!(
json_path, json_path,
&Some(JsonPath { &Some(JsonPath {
@ -321,7 +324,7 @@ fn test_parse_json_path_from() {
TableFactor::Table { TableFactor::Table {
name, json_path, .. name, json_path, ..
} => { } => {
assert_eq!(name, &ObjectName(vec![Ident::new("src")])); assert_eq!(name, &ObjectName::from(vec![Ident::new("src")]));
assert_eq!( assert_eq!(
json_path, json_path,
&Some(JsonPath { &Some(JsonPath {
@ -354,7 +357,7 @@ fn test_parse_json_path_from() {
} => { } => {
assert_eq!( assert_eq!(
name, name,
&ObjectName(vec![Ident::new("src"), Ident::new("a"), Ident::new("b")]) &ObjectName::from(vec![Ident::new("src"), Ident::new("a"), Ident::new("b")])
); );
assert_eq!(json_path, &None); assert_eq!(json_path, &None);
} }

70
tests/sqlparser_snowflake.rs
View file

@ -634,7 +634,7 @@ fn test_snowflake_create_table_with_collated_column() {
vec![ColumnDef { vec![ColumnDef {
name: "a".into(), name: "a".into(),
data_type: DataType::Text, data_type: DataType::Text,
collation: Some(ObjectName(vec![Ident::with_quote('\'', "de_DE")])), collation: Some(ObjectName::from(vec![Ident::with_quote('\'', "de_DE")])),
options: vec![] options: vec![]
},] },]
); );
@ -818,7 +818,7 @@ fn test_snowflake_create_table_with_several_column_options() {
ColumnDef { ColumnDef {
name: "b".into(), name: "b".into(),
data_type: DataType::Text, data_type: DataType::Text,
collation: Some(ObjectName(vec![Ident::with_quote('\'', "de_DE")])), collation: Some(ObjectName::from(vec![Ident::with_quote('\'', "de_DE")])),
options: vec![ options: vec![
ColumnOptionDef { ColumnOptionDef {
name: None, name: None,
@ -1274,7 +1274,10 @@ fn parse_delimited_identifiers() {
version, version,
.. ..
} => { } => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0); assert_eq!(
ObjectName::from(vec![Ident::with_quote('"', "a table")]),
name
);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name); assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_none()); assert!(args.is_none());
assert!(with_hints.is_empty()); assert!(with_hints.is_empty());
@ -1293,7 +1296,7 @@ fn parse_delimited_identifiers() {
); );
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]), name: ObjectName::from(vec![Ident::with_quote('"', "myfun")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -1365,7 +1368,7 @@ fn test_select_wildcard_with_exclude() {
let select = snowflake_and_generic() let select = snowflake_and_generic()
.verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table"); .verified_only_select("SELECT name.* EXCLUDE department_id FROM employee_table");
let expected = SelectItem::QualifiedWildcard( let expected = SelectItem::QualifiedWildcard(
ObjectName(vec![Ident::new("name")]), ObjectName::from(vec![Ident::new("name")]),
WildcardAdditionalOptions { WildcardAdditionalOptions {
opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))), opt_exclude: Some(ExcludeSelectItem::Single(Ident::new("department_id"))),
..Default::default() ..Default::default()
@ -1402,7 +1405,7 @@ fn test_select_wildcard_with_rename() {
"SELECT name.* RENAME (department_id AS new_dep, employee_id AS new_emp) FROM employee_table", "SELECT name.* RENAME (department_id AS new_dep, employee_id AS new_emp) FROM employee_table",
); );
let expected = SelectItem::QualifiedWildcard( let expected = SelectItem::QualifiedWildcard(
ObjectName(vec![Ident::new("name")]), ObjectName::from(vec![Ident::new("name")]),
WildcardAdditionalOptions { WildcardAdditionalOptions {
opt_rename: Some(RenameSelectItem::Multiple(vec![ opt_rename: Some(RenameSelectItem::Multiple(vec![
IdentWithAlias { IdentWithAlias {
@ -1505,7 +1508,7 @@ fn test_alter_table_clustering() {
Expr::Identifier(Ident::new("c1")), Expr::Identifier(Ident::new("c1")),
Expr::Identifier(Ident::with_quote('"', "c2")), Expr::Identifier(Ident::with_quote('"', "c2")),
Expr::Function(Function { Expr::Function(Function {
name: ObjectName(vec![Ident::new("TO_DATE")]), name: ObjectName::from(vec![Ident::new("TO_DATE")]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -2034,11 +2037,11 @@ fn test_copy_into() {
} => { } => {
assert_eq!( assert_eq!(
into, into,
ObjectName(vec![Ident::new("my_company"), Ident::new("emp_basic")]) ObjectName::from(vec![Ident::new("my_company"), Ident::new("emp_basic")])
); );
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::with_quote('\'', "gcs://mybucket/./../a.csv")]) ObjectName::from(vec![Ident::with_quote('\'', "gcs://mybucket/./../a.csv")])
); );
assert!(files.is_none()); assert!(files.is_none());
assert!(pattern.is_none()); assert!(pattern.is_none());
@ -2069,7 +2072,7 @@ fn test_copy_into_with_stage_params() {
//assert_eq!("s3://load/files/", stage_params.url.unwrap()); //assert_eq!("s3://load/files/", stage_params.url.unwrap());
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::with_quote('\'', "s3://load/files/")]) ObjectName::from(vec![Ident::with_quote('\'', "s3://load/files/")])
); );
assert_eq!("myint", stage_params.storage_integration.unwrap()); assert_eq!("myint", stage_params.storage_integration.unwrap());
assert_eq!( assert_eq!(
@ -2128,7 +2131,7 @@ fn test_copy_into_with_stage_params() {
} => { } => {
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::with_quote('\'', "s3://load/files/")]) ObjectName::from(vec![Ident::with_quote('\'', "s3://load/files/")])
); );
assert_eq!("myint", stage_params.storage_integration.unwrap()); assert_eq!("myint", stage_params.storage_integration.unwrap());
} }
@ -2182,7 +2185,7 @@ fn test_copy_into_with_transformations() {
} => { } => {
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::new("@schema"), Ident::new("general_finished")]) ObjectName::from(vec![Ident::new("@schema"), Ident::new("general_finished")])
); );
assert_eq!( assert_eq!(
from_transformations.as_ref().unwrap()[0], from_transformations.as_ref().unwrap()[0],
@ -2291,17 +2294,17 @@ fn test_snowflake_stage_object_names() {
"@~/path", "@~/path",
]; ];
let mut allowed_object_names = [ let mut allowed_object_names = [
ObjectName(vec![Ident::new("my_company"), Ident::new("emp_basic")]), ObjectName::from(vec![Ident::new("my_company"), Ident::new("emp_basic")]),
ObjectName(vec![Ident::new("@namespace"), Ident::new("%table_name")]), ObjectName::from(vec![Ident::new("@namespace"), Ident::new("%table_name")]),
ObjectName(vec![ ObjectName::from(vec![
Ident::new("@namespace"), Ident::new("@namespace"),
Ident::new("%table_name/path"), Ident::new("%table_name/path"),
]), ]),
ObjectName(vec![ ObjectName::from(vec![
Ident::new("@namespace"), Ident::new("@namespace"),
Ident::new("stage_name/path"), Ident::new("stage_name/path"),
]), ]),
ObjectName(vec![Ident::new("@~/path")]), ObjectName::from(vec![Ident::new("@~/path")]),
]; ];
for it in allowed_formatted_names for it in allowed_formatted_names
@ -2330,10 +2333,13 @@ fn test_snowflake_copy_into() {
Statement::CopyIntoSnowflake { Statement::CopyIntoSnowflake {
into, from_stage, .. into, from_stage, ..
} => { } => {
assert_eq!(into, ObjectName(vec![Ident::new("a"), Ident::new("b")])); assert_eq!(
into,
ObjectName::from(vec![Ident::new("a"), Ident::new("b")])
);
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::new("@namespace"), Ident::new("stage_name")]) ObjectName::from(vec![Ident::new("@namespace"), Ident::new("stage_name")])
) )
} }
_ => unreachable!(), _ => unreachable!(),
@ -2350,14 +2356,14 @@ fn test_snowflake_copy_into_stage_name_ends_with_parens() {
} => { } => {
assert_eq!( assert_eq!(
into, into,
ObjectName(vec![ ObjectName::from(vec![
Ident::new("SCHEMA"), Ident::new("SCHEMA"),
Ident::new("SOME_MONITORING_SYSTEM") Ident::new("SOME_MONITORING_SYSTEM")
]) ])
); );
assert_eq!( assert_eq!(
from_stage, from_stage,
ObjectName(vec![Ident::new("@schema"), Ident::new("general_finished")]) ObjectName::from(vec![Ident::new("@schema"), Ident::new("general_finished")])
) )
} }
_ => unreachable!(), _ => unreachable!(),
@ -2771,7 +2777,7 @@ fn parse_use() {
// Test single identifier without quotes // Test single identifier without quotes
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE {}", object_name)), snowflake().verified_stmt(&format!("USE {}", object_name)),
Statement::Use(Use::Object(ObjectName(vec![Ident::new( Statement::Use(Use::Object(ObjectName::from(vec![Ident::new(
object_name.to_string() object_name.to_string()
)]))) )])))
); );
@ -2779,7 +2785,7 @@ fn parse_use() {
// Test single identifier with different type of quotes // Test single identifier with different type of quotes
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)), snowflake().verified_stmt(&format!("USE {}{}{}", quote, object_name, quote)),
Statement::Use(Use::Object(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Object(ObjectName::from(vec![Ident::with_quote(
quote, quote,
object_name.to_string(), object_name.to_string(),
)]))) )])))
@ -2791,7 +2797,7 @@ fn parse_use() {
// Test double identifier with different type of quotes // Test double identifier with different type of quotes
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)), snowflake().verified_stmt(&format!("USE {0}CATALOG{0}.{0}my_schema{0}", quote)),
Statement::Use(Use::Object(ObjectName(vec![ Statement::Use(Use::Object(ObjectName::from(vec![
Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "CATALOG"),
Ident::with_quote(quote, "my_schema") Ident::with_quote(quote, "my_schema")
]))) ])))
@ -2800,7 +2806,7 @@ fn parse_use() {
// Test double identifier without quotes // Test double identifier without quotes
assert_eq!( assert_eq!(
snowflake().verified_stmt("USE mydb.my_schema"), snowflake().verified_stmt("USE mydb.my_schema"),
Statement::Use(Use::Object(ObjectName(vec![ Statement::Use(Use::Object(ObjectName::from(vec![
Ident::new("mydb"), Ident::new("mydb"),
Ident::new("my_schema") Ident::new("my_schema")
]))) ])))
@ -2810,35 +2816,35 @@ fn parse_use() {
// Test single and double identifier with keyword and different type of quotes // Test single and double identifier with keyword and different type of quotes
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)), snowflake().verified_stmt(&format!("USE DATABASE {0}my_database{0}", quote)),
Statement::Use(Use::Database(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Database(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_database".to_string(), "my_database".to_string(),
)]))) )])))
); );
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)), snowflake().verified_stmt(&format!("USE SCHEMA {0}my_schema{0}", quote)),
Statement::Use(Use::Schema(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Schema(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_schema".to_string(), "my_schema".to_string(),
)]))) )])))
); );
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE SCHEMA {0}CATALOG{0}.{0}my_schema{0}", quote)), snowflake().verified_stmt(&format!("USE SCHEMA {0}CATALOG{0}.{0}my_schema{0}", quote)),
Statement::Use(Use::Schema(ObjectName(vec![ Statement::Use(Use::Schema(ObjectName::from(vec![
Ident::with_quote(quote, "CATALOG"), Ident::with_quote(quote, "CATALOG"),
Ident::with_quote(quote, "my_schema") Ident::with_quote(quote, "my_schema")
]))) ])))
); );
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE ROLE {0}my_role{0}", quote)), snowflake().verified_stmt(&format!("USE ROLE {0}my_role{0}", quote)),
Statement::Use(Use::Role(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Role(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_role".to_string(), "my_role".to_string(),
)]))) )])))
); );
assert_eq!( assert_eq!(
snowflake().verified_stmt(&format!("USE WAREHOUSE {0}my_wh{0}", quote)), snowflake().verified_stmt(&format!("USE WAREHOUSE {0}my_wh{0}", quote)),
Statement::Use(Use::Warehouse(ObjectName(vec![Ident::with_quote( Statement::Use(Use::Warehouse(ObjectName::from(vec![Ident::with_quote(
quote, quote,
"my_wh".to_string(), "my_wh".to_string(),
)]))) )])))
@ -3076,7 +3082,7 @@ fn parse_ls_and_rm() {
.verified_stmt("LIST @SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/"); .verified_stmt("LIST @SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/");
match statement { match statement {
Statement::List(command) => { Statement::List(command) => {
assert_eq!(command.stage, ObjectName(vec!["@SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/".into()])); assert_eq!(command.stage, ObjectName::from(vec!["@SNOWFLAKE_KAFKA_CONNECTOR_externalDataLakeSnowflakeConnector_STAGE_call_tracker_stream/".into()]));
assert!(command.pattern.is_none()); assert!(command.pattern.is_none());
} }
_ => unreachable!(), _ => unreachable!(),
@ -3088,7 +3094,7 @@ fn parse_ls_and_rm() {
Statement::Remove(command) => { Statement::Remove(command) => {
assert_eq!( assert_eq!(
command.stage, command.stage,
ObjectName(vec!["@my_csv_stage/analysis/".into()]) ObjectName::from(vec!["@my_csv_stage/analysis/".into()])
); );
assert_eq!(command.pattern, Some(".*data_0.*".to_string())); assert_eq!(command.pattern, Some(".*data_0.*".to_string()));
} }

8
tests/sqlparser_sqlite.rs
View file

@ -418,7 +418,7 @@ fn parse_window_function_with_filter() {
assert_eq!( assert_eq!(
select.projection, select.projection,
vec![SelectItem::UnnamedExpr(Expr::Function(Function { vec![SelectItem::UnnamedExpr(Expr::Function(Function {
name: ObjectName(vec![Ident::new(func_name)]), name: ObjectName::from(vec![Ident::new(func_name)]),
uses_odbc_syntax: false, uses_odbc_syntax: false,
parameters: FunctionArguments::None, parameters: FunctionArguments::None,
args: FunctionArguments::List(FunctionArgumentList { args: FunctionArguments::List(FunctionArgumentList {
@ -469,8 +469,8 @@ fn parse_update_tuple_row_values() {
or: None, or: None,
assignments: vec![Assignment { assignments: vec![Assignment {
target: AssignmentTarget::Tuple(vec![ target: AssignmentTarget::Tuple(vec![
ObjectName(vec![Ident::new("a"),]), ObjectName::from(vec![Ident::new("a"),]),
ObjectName(vec![Ident::new("b"),]), ObjectName::from(vec![Ident::new("b"),]),
]), ]),
value: Expr::Tuple(vec![ value: Expr::Tuple(vec![
Expr::Value(Value::Number("1".parse().unwrap(), false)), Expr::Value(Value::Number("1".parse().unwrap(), false)),
@ -479,7 +479,7 @@ fn parse_update_tuple_row_values() {
}], }],
selection: None, selection: None,
table: TableWithJoins { table: TableWithJoins {
relation: table_from_name(ObjectName(vec![Ident::new("x")])), relation: table_from_name(ObjectName::from(vec![Ident::new("x")])),
joins: vec![], joins: vec![],
}, },
from: None, from: None,