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

chore: fix clippy error in ci (#803)

Browse source 
* chore: fix clippy error in ci

* chore: fix fmt
This commit is contained in:
Y Togami 2023-02-18 03:24:50 +09:00 • committed by GitHub
parent 4955863bdf
commit b31ede7733
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 371 additions and 444 deletions
Download patch file Download diff file Expand all files Collapse all files

8
examples/cli.rs
View file

@ -46,7 +46,7 @@ $ cargo run --feature json_example --example cli FILENAME.sql [--dialectname]
"--hive" => Box::new(HiveDialect {}), "--hive" => Box::new(HiveDialect {}),
"--redshift" => Box::new(RedshiftSqlDialect {}), "--redshift" => Box::new(RedshiftSqlDialect {}),
"--generic" | "" => Box::new(GenericDialect {}), "--generic" | "" => Box::new(GenericDialect {}),
s => panic!("Unexpected parameter: {}", s), s => panic!("Unexpected parameter: {s}"),
}; };
println!("Parsing from file '{}' using {:?}", &filename, dialect); println!("Parsing from file '{}' using {:?}", &filename, dialect);
@ -75,16 +75,16 @@ $ cargo run --feature json_example --example cli FILENAME.sql [--dialectname]
#[cfg(feature = "json_example")] #[cfg(feature = "json_example")]
{ {
let serialized = serde_json::to_string_pretty(&statements).unwrap(); let serialized = serde_json::to_string_pretty(&statements).unwrap();
println!("Serialized as JSON:\n{}", serialized); println!("Serialized as JSON:\n{serialized}");
} }
} else { } else {
println!("Parse results:\n{:#?}", statements); println!("Parse results:\n{statements:#?}");
} }
std::process::exit(0); std::process::exit(0);
} }
Err(e) => { Err(e) => {
println!("Error during parsing: {:?}", e); println!("Error during parsing: {e:?}");
std::process::exit(1); std::process::exit(1);
} }
} }

2
examples/parse_select.rs
View file

@ -25,5 +25,5 @@ fn main() {
let ast = Parser::parse_sql(&dialect, sql).unwrap(); let ast = Parser::parse_sql(&dialect, sql).unwrap();
println!("AST: {:?}", ast); println!("AST: {ast:?}");
} }

22
src/ast/data_type.rs
View file

@ -186,13 +186,13 @@ impl fmt::Display for DataType {
} }
DataType::Blob(size) => format_type_with_optional_length(f, "BLOB", size, false), DataType::Blob(size) => format_type_with_optional_length(f, "BLOB", size, false),
DataType::Numeric(info) => { DataType::Numeric(info) => {
write!(f, "NUMERIC{}", info) write!(f, "NUMERIC{info}")
} }
DataType::Decimal(info) => { DataType::Decimal(info) => {
write!(f, "DECIMAL{}", info) write!(f, "DECIMAL{info}")
} }
DataType::Dec(info) => { DataType::Dec(info) => {
write!(f, "DEC{}", info) write!(f, "DEC{info}")
} }
DataType::Float(size) => format_type_with_optional_length(f, "FLOAT", size, false), DataType::Float(size) => format_type_with_optional_length(f, "FLOAT", size, false),
DataType::TinyInt(zerofill) => { DataType::TinyInt(zerofill) => {
@ -250,14 +250,14 @@ impl fmt::Display for DataType {
DataType::Bytea => write!(f, "BYTEA"), DataType::Bytea => write!(f, "BYTEA"),
DataType::Array(ty) => { DataType::Array(ty) => {
if let Some(t) = &ty { if let Some(t) = &ty {
write!(f, "{}[]", t) write!(f, "{t}[]")
} else { } else {
write!(f, "ARRAY") write!(f, "ARRAY")
} }
} }
DataType::Custom(ty, modifiers) => { DataType::Custom(ty, modifiers) => {
if modifiers.is_empty() { if modifiers.is_empty() {
write!(f, "{}", ty) write!(f, "{ty}")
} else { } else {
write!(f, "{}({})", ty, modifiers.join(", ")) write!(f, "{}({})", ty, modifiers.join(", "))
} }
@ -292,9 +292,9 @@ fn format_type_with_optional_length(
len: &Option<u64>, len: &Option<u64>,
unsigned: bool, unsigned: bool,
) -> fmt::Result { ) -> fmt::Result {
write!(f, "{}", sql_type)?; write!(f, "{sql_type}")?;
if let Some(len) = len { if let Some(len) = len {
write!(f, "({})", len)?; write!(f, "({len})")?;
} }
if unsigned { if unsigned {
write!(f, " UNSIGNED")?; write!(f, " UNSIGNED")?;
@ -307,9 +307,9 @@ fn format_character_string_type(
sql_type: &str, sql_type: &str,
size: &Option<CharacterLength>, size: &Option<CharacterLength>,
) -> fmt::Result { ) -> fmt::Result {
write!(f, "{}", sql_type)?; write!(f, "{sql_type}")?;
if let Some(size) = size { if let Some(size) = size {
write!(f, "({})", size)?; write!(f, "({size})")?;
} }
Ok(()) Ok(())
} }
@ -320,7 +320,7 @@ fn format_datetime_precision_and_tz(
len: &Option<u64>, len: &Option<u64>,
time_zone: &TimezoneInfo, time_zone: &TimezoneInfo,
) -> fmt::Result { ) -> fmt::Result {
write!(f, "{}", sql_type)?; write!(f, "{sql_type}")?;
let len_fmt = len.as_ref().map(|l| format!("({l})")).unwrap_or_default(); let len_fmt = len.as_ref().map(|l| format!("({l})")).unwrap_or_default();
match time_zone { match time_zone {
@ -432,7 +432,7 @@ impl fmt::Display for CharacterLength {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.length)?; write!(f, "{}", self.length)?;
if let Some(unit) = &self.unit { if let Some(unit) = &self.unit {
write!(f, " {}", unit)?; write!(f, " {unit}")?;
} }
Ok(()) Ok(())
} }

54
src/ast/ddl.rs
View file

@ -117,7 +117,7 @@ impl fmt::Display for AlterTableOperation {
display_comma_separated(new_partitions), display_comma_separated(new_partitions),
ine = if *if_not_exists { " IF NOT EXISTS" } else { "" } ine = if *if_not_exists { " IF NOT EXISTS" } else { "" }
), ),
AlterTableOperation::AddConstraint(c) => write!(f, "ADD {}", c), AlterTableOperation::AddConstraint(c) => write!(f, "ADD {c}"),
AlterTableOperation::AddColumn { AlterTableOperation::AddColumn {
column_keyword, column_keyword,
if_not_exists, if_not_exists,
@ -135,7 +135,7 @@ impl fmt::Display for AlterTableOperation {
Ok(()) Ok(())
} }
AlterTableOperation::AlterColumn { column_name, op } => { AlterTableOperation::AlterColumn { column_name, op } => {
write!(f, "ALTER COLUMN {} {}", column_name, op) write!(f, "ALTER COLUMN {column_name} {op}")
} }
AlterTableOperation::DropPartitions { AlterTableOperation::DropPartitions {
partitions, partitions,
@ -183,13 +183,9 @@ impl fmt::Display for AlterTableOperation {
AlterTableOperation::RenameColumn { AlterTableOperation::RenameColumn {
old_column_name, old_column_name,
new_column_name, new_column_name,
} => write!( } => write!(f, "RENAME COLUMN {old_column_name} TO {new_column_name}"),
f,
"RENAME COLUMN {} TO {}",
old_column_name, new_column_name
),
AlterTableOperation::RenameTable { table_name } => { AlterTableOperation::RenameTable { table_name } => {
write!(f, "RENAME TO {}", table_name) write!(f, "RENAME TO {table_name}")
} }
AlterTableOperation::ChangeColumn { AlterTableOperation::ChangeColumn {
old_name, old_name,
@ -197,7 +193,7 @@ impl fmt::Display for AlterTableOperation {
data_type, data_type,
options, options,
} => { } => {
write!(f, "CHANGE COLUMN {} {} {}", old_name, new_name, data_type)?; write!(f, "CHANGE COLUMN {old_name} {new_name} {data_type}")?;
if options.is_empty() { if options.is_empty() {
Ok(()) Ok(())
} else { } else {
@ -205,7 +201,7 @@ impl fmt::Display for AlterTableOperation {
} }
} }
AlterTableOperation::RenameConstraint { old_name, new_name } => { AlterTableOperation::RenameConstraint { old_name, new_name } => {
write!(f, "RENAME CONSTRAINT {} TO {}", old_name, new_name) write!(f, "RENAME CONSTRAINT {old_name} TO {new_name}")
} }
} }
} }
@ -215,7 +211,7 @@ impl fmt::Display for AlterIndexOperation {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
AlterIndexOperation::RenameIndex { index_name } => { AlterIndexOperation::RenameIndex { index_name } => {
write!(f, "RENAME TO {}", index_name) write!(f, "RENAME TO {index_name}")
} }
} }
} }
@ -248,16 +244,16 @@ impl fmt::Display for AlterColumnOperation {
AlterColumnOperation::SetNotNull => write!(f, "SET NOT NULL",), AlterColumnOperation::SetNotNull => write!(f, "SET NOT NULL",),
AlterColumnOperation::DropNotNull => write!(f, "DROP NOT NULL",), AlterColumnOperation::DropNotNull => write!(f, "DROP NOT NULL",),
AlterColumnOperation::SetDefault { value } => { AlterColumnOperation::SetDefault { value } => {
write!(f, "SET DEFAULT {}", value) write!(f, "SET DEFAULT {value}")
} }
AlterColumnOperation::DropDefault {} => { AlterColumnOperation::DropDefault {} => {
write!(f, "DROP DEFAULT") write!(f, "DROP DEFAULT")
} }
AlterColumnOperation::SetDataType { data_type, using } => { AlterColumnOperation::SetDataType { data_type, using } => {
if let Some(expr) = using { if let Some(expr) = using {
write!(f, "SET DATA TYPE {} USING {}", data_type, expr) write!(f, "SET DATA TYPE {data_type} USING {expr}")
} else { } else {
write!(f, "SET DATA TYPE {}", data_type) write!(f, "SET DATA TYPE {data_type}")
} }
} }
} }
@ -369,10 +365,10 @@ impl fmt::Display for TableConstraint {
display_comma_separated(referred_columns), display_comma_separated(referred_columns),
)?; )?;
if let Some(action) = on_delete { if let Some(action) = on_delete {
write!(f, " ON DELETE {}", action)?; write!(f, " ON DELETE {action}")?;
} }
if let Some(action) = on_update { if let Some(action) = on_update {
write!(f, " ON UPDATE {}", action)?; write!(f, " ON UPDATE {action}")?;
} }
Ok(()) Ok(())
} }
@ -387,10 +383,10 @@ impl fmt::Display for TableConstraint {
} => { } => {
write!(f, "{}", if *display_as_key { "KEY" } else { "INDEX" })?; write!(f, "{}", if *display_as_key { "KEY" } else { "INDEX" })?;
if let Some(name) = name { if let Some(name) = name {
write!(f, " {}", name)?; write!(f, " {name}")?;
} }
if let Some(index_type) = index_type { if let Some(index_type) = index_type {
write!(f, " USING {}", index_type)?; write!(f, " USING {index_type}")?;
} }
write!(f, " ({})", display_comma_separated(columns))?; write!(f, " ({})", display_comma_separated(columns))?;
@ -409,11 +405,11 @@ impl fmt::Display for TableConstraint {
} }
if !matches!(index_type_display, KeyOrIndexDisplay::None) { if !matches!(index_type_display, KeyOrIndexDisplay::None) {
write!(f, " {}", index_type_display)?; write!(f, " {index_type_display}")?;
} }
if let Some(name) = opt_index_name { if let Some(name) = opt_index_name {
write!(f, " {}", name)?; write!(f, " {name}")?;
} }
write!(f, " ({})", display_comma_separated(columns))?; write!(f, " ({})", display_comma_separated(columns))?;
@ -500,7 +496,7 @@ impl fmt::Display for ColumnDef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{} {}", self.name, self.data_type)?; write!(f, "{} {}", self.name, self.data_type)?;
for option in &self.options { for option in &self.options {
write!(f, " {}", option)?; write!(f, " {option}")?;
} }
Ok(()) Ok(())
} }
@ -580,7 +576,7 @@ impl fmt::Display for ColumnOption {
match self { match self {
Null => write!(f, "NULL"), Null => write!(f, "NULL"),
NotNull => write!(f, "NOT NULL"), NotNull => write!(f, "NOT NULL"),
Default(expr) => write!(f, "DEFAULT {}", expr), Default(expr) => write!(f, "DEFAULT {expr}"),
Unique { is_primary } => { Unique { is_primary } => {
write!(f, "{}", if *is_primary { "PRIMARY KEY" } else { "UNIQUE" }) write!(f, "{}", if *is_primary { "PRIMARY KEY" } else { "UNIQUE" })
} }
@ -590,23 +586,23 @@ impl fmt::Display for ColumnOption {
on_delete, on_delete,
on_update, on_update,
} => { } => {
write!(f, "REFERENCES {}", foreign_table)?; write!(f, "REFERENCES {foreign_table}")?;
if !referred_columns.is_empty() { if !referred_columns.is_empty() {
write!(f, " ({})", display_comma_separated(referred_columns))?; write!(f, " ({})", display_comma_separated(referred_columns))?;
} }
if let Some(action) = on_delete { if let Some(action) = on_delete {
write!(f, " ON DELETE {}", action)?; write!(f, " ON DELETE {action}")?;
} }
if let Some(action) = on_update { if let Some(action) = on_update {
write!(f, " ON UPDATE {}", action)?; write!(f, " ON UPDATE {action}")?;
} }
Ok(()) Ok(())
} }
Check(expr) => write!(f, "CHECK ({})", expr), Check(expr) => write!(f, "CHECK ({expr})"),
DialectSpecific(val) => write!(f, "{}", display_separated(val, " ")), DialectSpecific(val) => write!(f, "{}", display_separated(val, " ")),
CharacterSet(n) => write!(f, "CHARACTER SET {}", n), CharacterSet(n) => write!(f, "CHARACTER SET {n}"),
Comment(v) => write!(f, "COMMENT '{}'", escape_single_quote_string(v)), Comment(v) => write!(f, "COMMENT '{}'", escape_single_quote_string(v)),
OnUpdate(expr) => write!(f, "ON UPDATE {}", expr), OnUpdate(expr) => write!(f, "ON UPDATE {expr}"),
} }
} }
} }
@ -616,7 +612,7 @@ fn display_constraint_name(name: &'_ Option<Ident>) -> impl fmt::Display + '_ {
impl<'a> fmt::Display for ConstraintName<'a> { impl<'a> fmt::Display for ConstraintName<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(name) = self.0 { if let Some(name) = self.0 {
write!(f, "CONSTRAINT {} ", name)?; write!(f, "CONSTRAINT {name} ")?;
} }
Ok(()) Ok(())
} }

413
src/ast/mod.rs
View file

File diff suppressed because it is too large Load diff

92
src/ast/query.rs
View file

@ -46,20 +46,20 @@ pub struct Query {
impl fmt::Display for Query { impl fmt::Display for Query {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(ref with) = self.with { if let Some(ref with) = self.with {
write!(f, "{} ", with)?; write!(f, "{with} ")?;
} }
write!(f, "{}", self.body)?; write!(f, "{}", self.body)?;
if !self.order_by.is_empty() { if !self.order_by.is_empty() {
write!(f, " ORDER BY {}", display_comma_separated(&self.order_by))?; write!(f, " ORDER BY {}", display_comma_separated(&self.order_by))?;
} }
if let Some(ref limit) = self.limit { if let Some(ref limit) = self.limit {
write!(f, " LIMIT {}", limit)?; write!(f, " LIMIT {limit}")?;
} }
if let Some(ref offset) = self.offset { if let Some(ref offset) = self.offset {
write!(f, " {}", offset)?; write!(f, " {offset}")?;
} }
if let Some(ref fetch) = self.fetch { if let Some(ref fetch) = self.fetch {
write!(f, " {}", fetch)?; write!(f, " {fetch}")?;
} }
if !self.locks.is_empty() { if !self.locks.is_empty() {
write!(f, " {}", display_separated(&self.locks, " "))?; write!(f, " {}", display_separated(&self.locks, " "))?;
@ -95,25 +95,23 @@ pub enum SetExpr {
impl fmt::Display for SetExpr { impl fmt::Display for SetExpr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
SetExpr::Select(s) => write!(f, "{}", s), SetExpr::Select(s) => write!(f, "{s}"),
SetExpr::Query(q) => write!(f, "({})", q), SetExpr::Query(q) => write!(f, "({q})"),
SetExpr::Values(v) => write!(f, "{}", v), SetExpr::Values(v) => write!(f, "{v}"),
SetExpr::Insert(v) => write!(f, "{}", v), SetExpr::Insert(v) => write!(f, "{v}"),
SetExpr::Table(t) => write!(f, "{}", t), SetExpr::Table(t) => write!(f, "{t}"),
SetExpr::SetOperation { SetExpr::SetOperation {
left, left,
right, right,
op, op,
set_quantifier, set_quantifier,
} => { } => {
write!(f, "{} {}", left, op)?; write!(f, "{left} {op}")?;
match set_quantifier { match set_quantifier {
SetQuantifier::All | SetQuantifier::Distinct => { SetQuantifier::All | SetQuantifier::Distinct => write!(f, " {set_quantifier}")?,
write!(f, " {}", set_quantifier)? SetQuantifier::None => write!(f, "{set_quantifier}")?,
}
SetQuantifier::None => write!(f, "{}", set_quantifier)?,
} }
write!(f, " {}", right)?; write!(f, " {right}")?;
Ok(()) Ok(())
} }
} }
@ -224,12 +222,12 @@ impl fmt::Display for Select {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "SELECT{}", if self.distinct { " DISTINCT" } else { "" })?; write!(f, "SELECT{}", if self.distinct { " DISTINCT" } else { "" })?;
if let Some(ref top) = self.top { if let Some(ref top) = self.top {
write!(f, " {}", top)?; write!(f, " {top}")?;
} }
write!(f, " {}", display_comma_separated(&self.projection))?; write!(f, " {}", display_comma_separated(&self.projection))?;
if let Some(ref into) = self.into { if let Some(ref into) = self.into {
write!(f, " {}", into)?; write!(f, " {into}")?;
} }
if !self.from.is_empty() { if !self.from.is_empty() {
@ -237,11 +235,11 @@ impl fmt::Display for Select {
} }
if !self.lateral_views.is_empty() { if !self.lateral_views.is_empty() {
for lv in &self.lateral_views { for lv in &self.lateral_views {
write!(f, "{}", lv)?; write!(f, "{lv}")?;
} }
} }
if let Some(ref selection) = self.selection { if let Some(ref selection) = self.selection {
write!(f, " WHERE {}", selection)?; write!(f, " WHERE {selection}")?;
} }
if !self.group_by.is_empty() { if !self.group_by.is_empty() {
write!(f, " GROUP BY {}", display_comma_separated(&self.group_by))?; write!(f, " GROUP BY {}", display_comma_separated(&self.group_by))?;
@ -264,10 +262,10 @@ impl fmt::Display for Select {
write!(f, " SORT BY {}", display_comma_separated(&self.sort_by))?; write!(f, " SORT BY {}", display_comma_separated(&self.sort_by))?;
} }
if let Some(ref having) = self.having { if let Some(ref having) = self.having {
write!(f, " HAVING {}", having)?; write!(f, " HAVING {having}")?;
} }
if let Some(ref qualify) = self.qualify { if let Some(ref qualify) = self.qualify {
write!(f, " QUALIFY {}", qualify)?; write!(f, " QUALIFY {qualify}")?;
} }
Ok(()) Ok(())
} }
@ -344,7 +342,7 @@ impl fmt::Display for Cte {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{} AS ({})", self.alias, self.query)?; write!(f, "{} AS ({})", self.alias, self.query)?;
if let Some(ref fr) = self.from { if let Some(ref fr) = self.from {
write!(f, " FROM {}", fr)?; write!(f, " FROM {fr}")?;
} }
Ok(()) Ok(())
} }
@ -531,10 +529,10 @@ impl fmt::Display for ExceptSelectItem {
impl fmt::Display for SelectItem { impl fmt::Display for SelectItem {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match &self { match &self {
SelectItem::UnnamedExpr(expr) => write!(f, "{}", expr), SelectItem::UnnamedExpr(expr) => write!(f, "{expr}"),
SelectItem::ExprWithAlias { expr, alias } => write!(f, "{} AS {}", expr, alias), SelectItem::ExprWithAlias { expr, alias } => write!(f, "{expr} AS {alias}"),
SelectItem::QualifiedWildcard(prefix, additional_options) => { SelectItem::QualifiedWildcard(prefix, additional_options) => {
write!(f, "{}.*", prefix)?; write!(f, "{prefix}.*")?;
write!(f, "{additional_options}")?; write!(f, "{additional_options}")?;
Ok(()) Ok(())
} }
@ -559,7 +557,7 @@ impl fmt::Display for TableWithJoins {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.relation)?; write!(f, "{}", self.relation)?;
for join in &self.joins { for join in &self.joins {
write!(f, "{}", join)?; write!(f, "{join}")?;
} }
Ok(()) Ok(())
} }
@ -632,12 +630,12 @@ impl fmt::Display for TableFactor {
args, args,
with_hints, with_hints,
} => { } => {
write!(f, "{}", name)?; write!(f, "{name}")?;
if let Some(args) = args { if let Some(args) = args {
write!(f, "({})", display_comma_separated(args))?; write!(f, "({})", display_comma_separated(args))?;
} }
if let Some(alias) = alias { if let Some(alias) = alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
if !with_hints.is_empty() { if !with_hints.is_empty() {
write!(f, " WITH ({})", display_comma_separated(with_hints))?; write!(f, " WITH ({})", display_comma_separated(with_hints))?;
@ -652,16 +650,16 @@ impl fmt::Display for TableFactor {
if *lateral { if *lateral {
write!(f, "LATERAL ")?; write!(f, "LATERAL ")?;
} }
write!(f, "({})", subquery)?; write!(f, "({subquery})")?;
if let Some(alias) = alias { if let Some(alias) = alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
Ok(()) Ok(())
} }
TableFactor::TableFunction { expr, alias } => { TableFactor::TableFunction { expr, alias } => {
write!(f, "TABLE({})", expr)?; write!(f, "TABLE({expr})")?;
if let Some(alias) = alias { if let Some(alias) = alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
Ok(()) Ok(())
} }
@ -671,15 +669,15 @@ impl fmt::Display for TableFactor {
with_offset, with_offset,
with_offset_alias, with_offset_alias,
} => { } => {
write!(f, "UNNEST({})", array_expr)?; write!(f, "UNNEST({array_expr})")?;
if let Some(alias) = alias { if let Some(alias) = alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
if *with_offset { if *with_offset {
write!(f, " WITH OFFSET")?; write!(f, " WITH OFFSET")?;
} }
if let Some(alias) = with_offset_alias { if let Some(alias) = with_offset_alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
Ok(()) Ok(())
} }
@ -687,9 +685,9 @@ impl fmt::Display for TableFactor {
table_with_joins, table_with_joins,
alias, alias,
} => { } => {
write!(f, "({})", table_with_joins)?; write!(f, "({table_with_joins})")?;
if let Some(alias) = alias { if let Some(alias) = alias {
write!(f, " AS {}", alias)?; write!(f, " AS {alias}")?;
} }
Ok(()) Ok(())
} }
@ -736,7 +734,7 @@ impl fmt::Display for Join {
impl<'a> fmt::Display for Suffix<'a> { impl<'a> fmt::Display for Suffix<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.0 { match self.0 {
JoinConstraint::On(expr) => write!(f, " ON {}", expr), JoinConstraint::On(expr) => write!(f, " ON {expr}"),
JoinConstraint::Using(attrs) => { JoinConstraint::Using(attrs) => {
write!(f, " USING({})", display_comma_separated(attrs)) write!(f, " USING({})", display_comma_separated(attrs))
} }
@ -921,9 +919,9 @@ impl fmt::Display for Fetch {
let extension = if self.with_ties { "WITH TIES" } else { "ONLY" }; let extension = if self.with_ties { "WITH TIES" } else { "ONLY" };
if let Some(ref quantity) = self.quantity { if let Some(ref quantity) = self.quantity {
let percent = if self.percent { " PERCENT" } else { "" }; let percent = if self.percent { " PERCENT" } else { "" };
write!(f, "FETCH FIRST {}{} ROWS {}", quantity, percent, extension) write!(f, "FETCH FIRST {quantity}{percent} ROWS {extension}")
} else { } else {
write!(f, "FETCH FIRST ROWS {}", extension) write!(f, "FETCH FIRST ROWS {extension}")
} }
} }
} }
@ -941,10 +939,10 @@ impl fmt::Display for LockClause {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "FOR {}", &self.lock_type)?; write!(f, "FOR {}", &self.lock_type)?;
if let Some(ref of) = self.of { if let Some(ref of) = self.of {
write!(f, " OF {}", of)?; write!(f, " OF {of}")?;
} }
if let Some(ref nb) = self.nonblock { if let Some(ref nb) = self.nonblock {
write!(f, " {}", nb)?; write!(f, " {nb}")?;
} }
Ok(()) Ok(())
} }
@ -964,7 +962,7 @@ impl fmt::Display for LockType {
LockType::Share => "SHARE", LockType::Share => "SHARE",
LockType::Update => "UPDATE", LockType::Update => "UPDATE",
}; };
write!(f, "{}", select_lock) write!(f, "{select_lock}")
} }
} }
@ -982,7 +980,7 @@ impl fmt::Display for NonBlock {
NonBlock::Nowait => "NOWAIT", NonBlock::Nowait => "NOWAIT",
NonBlock::SkipLocked => "SKIP LOCKED", NonBlock::SkipLocked => "SKIP LOCKED",
}; };
write!(f, "{}", nonblock) write!(f, "{nonblock}")
} }
} }
@ -1001,9 +999,9 @@ impl fmt::Display for Top {
let extension = if self.with_ties { " WITH TIES" } else { "" }; let extension = if self.with_ties { " WITH TIES" } else { "" };
if let Some(ref quantity) = self.quantity { if let Some(ref quantity) = self.quantity {
let percent = if self.percent { " PERCENT" } else { "" }; let percent = if self.percent { " PERCENT" } else { "" };
write!(f, "TOP ({}){}{}", quantity, percent, extension) write!(f, "TOP ({quantity}){percent}{extension}")
} else { } else {
write!(f, "TOP{}", extension) write!(f, "TOP{extension}")
} }
} }
} }
@ -1024,7 +1022,7 @@ impl fmt::Display for Values {
let prefix = if self.explicit_row { "ROW" } else { "" }; let prefix = if self.explicit_row { "ROW" } else { "" };
let mut delim = ""; let mut delim = "";
for row in &self.rows { for row in &self.rows {
write!(f, "{}", delim)?; write!(f, "{delim}")?;
delim = ", "; delim = ", ";
write!(f, "{prefix}({})", display_comma_separated(row))?; write!(f, "{prefix}({})", display_comma_separated(row))?;
} }

18
src/ast/value.rs
View file

@ -61,16 +61,16 @@ impl fmt::Display for Value {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
Value::Number(v, l) => write!(f, "{}{long}", v, long = if *l { "L" } else { "" }), Value::Number(v, l) => write!(f, "{}{long}", v, long = if *l { "L" } else { "" }),
Value::DoubleQuotedString(v) => write!(f, "\"{}\"", v), Value::DoubleQuotedString(v) => write!(f, "\"{v}\""),
Value::SingleQuotedString(v) => write!(f, "'{}'", escape_single_quote_string(v)), Value::SingleQuotedString(v) => write!(f, "'{}'", escape_single_quote_string(v)),
Value::DollarQuotedString(v) => write!(f, "{}", v), Value::DollarQuotedString(v) => write!(f, "{v}"),
Value::EscapedStringLiteral(v) => write!(f, "E'{}'", escape_escaped_string(v)), Value::EscapedStringLiteral(v) => write!(f, "E'{}'", escape_escaped_string(v)),
Value::NationalStringLiteral(v) => write!(f, "N'{}'", v), Value::NationalStringLiteral(v) => write!(f, "N'{v}'"),
Value::HexStringLiteral(v) => write!(f, "X'{}'", v), Value::HexStringLiteral(v) => write!(f, "X'{v}'"),
Value::Boolean(v) => write!(f, "{}", v), Value::Boolean(v) => write!(f, "{v}"),
Value::Null => write!(f, "NULL"), Value::Null => write!(f, "NULL"),
Value::Placeholder(v) => write!(f, "{}", v), Value::Placeholder(v) => write!(f, "{v}"),
Value::UnQuotedString(v) => write!(f, "{}", v), Value::UnQuotedString(v) => write!(f, "{v}"),
} }
} }
} }
@ -178,7 +178,7 @@ impl<'a> fmt::Display for EscapeQuotedString<'a> {
if c == self.quote { if c == self.quote {
write!(f, "{q}{q}", q = self.quote)?; write!(f, "{q}{q}", q = self.quote)?;
} else { } else {
write!(f, "{}", c)?; write!(f, "{c}")?;
} }
} }
Ok(()) Ok(())
@ -215,7 +215,7 @@ impl<'a> fmt::Display for EscapeEscapedStringLiteral<'a> {
write!(f, r#"\r"#)?; write!(f, r#"\r"#)?;
} }
_ => { _ => {
write!(f, "{}", c)?; write!(f, "{c}")?;
} }
} }
} }

12
src/ast/visitor.rs
View file

@ -600,32 +600,32 @@ mod tests {
type Break = (); type Break = ();
fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow<Self::Break> { fn pre_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow<Self::Break> {
self.visited.push(format!("PRE: RELATION: {}", relation)); self.visited.push(format!("PRE: RELATION: {relation}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
fn post_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow<Self::Break> { fn post_visit_relation(&mut self, relation: &ObjectName) -> ControlFlow<Self::Break> {
self.visited.push(format!("POST: RELATION: {}", relation)); self.visited.push(format!("POST: RELATION: {relation}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow<Self::Break> { fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow<Self::Break> {
self.visited.push(format!("PRE: EXPR: {}", expr)); self.visited.push(format!("PRE: EXPR: {expr}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
fn post_visit_expr(&mut self, expr: &Expr) -> ControlFlow<Self::Break> { fn post_visit_expr(&mut self, expr: &Expr) -> ControlFlow<Self::Break> {
self.visited.push(format!("POST: EXPR: {}", expr)); self.visited.push(format!("POST: EXPR: {expr}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
fn pre_visit_statement(&mut self, statement: &Statement) -> ControlFlow<Self::Break> { fn pre_visit_statement(&mut self, statement: &Statement) -> ControlFlow<Self::Break> {
self.visited.push(format!("PRE: STATEMENT: {}", statement)); self.visited.push(format!("PRE: STATEMENT: {statement}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
fn post_visit_statement(&mut self, statement: &Statement) -> ControlFlow<Self::Break> { fn post_visit_statement(&mut self, statement: &Statement) -> ControlFlow<Self::Break> {
self.visited.push(format!("POST: STATEMENT: {}", statement)); self.visited.push(format!("POST: STATEMENT: {statement}"));
ControlFlow::Continue(()) ControlFlow::Continue(())
} }
} }

26
src/parser.rs
View file

@ -805,7 +805,7 @@ impl<'a> Parser<'a> {
let tok = self.next_token(); let tok = self.next_token();
let key = match tok.token { let key = match tok.token {
Token::Word(word) => word.to_ident(), Token::Word(word) => word.to_ident(),
_ => return parser_err!(format!("Expected identifier, found: {}", tok)), _ => return parser_err!(format!("Expected identifier, found: {tok}")),
}; };
Ok(Expr::CompositeAccess { Ok(Expr::CompositeAccess {
expr: Box::new(expr), expr: Box::new(expr),
@ -2083,7 +2083,7 @@ impl<'a> Parser<'a> {
/// Report unexpected token /// Report unexpected token
pub fn expected<T>(&self, expected: &str, found: TokenWithLocation) -> Result<T, ParserError> { pub fn expected<T>(&self, expected: &str, found: TokenWithLocation) -> Result<T, ParserError> {
parser_err!(format!("Expected {}, found: {}", expected, found)) parser_err!(format!("Expected {expected}, found: {found}"))
} }
/// Look for an expected keyword and consume it if it exists /// Look for an expected keyword and consume it if it exists
@ -2135,7 +2135,7 @@ impl<'a> Parser<'a> {
if let Some(keyword) = self.parse_one_of_keywords(keywords) { if let Some(keyword) = self.parse_one_of_keywords(keywords) {
Ok(keyword) Ok(keyword)
} else { } else {
let keywords: Vec<String> = keywords.iter().map(|x| format!("{:?}", x)).collect(); let keywords: Vec<String> = keywords.iter().map(|x| format!("{x:?}")).collect();
self.expected( self.expected(
&format!("one of {}", keywords.join(" or ")), &format!("one of {}", keywords.join(" or ")),
self.peek_token(), self.peek_token(),
@ -2495,7 +2495,7 @@ impl<'a> Parser<'a> {
Keyword::ARCHIVE => Ok(Some(CreateFunctionUsing::Archive(uri))), Keyword::ARCHIVE => Ok(Some(CreateFunctionUsing::Archive(uri))),
_ => self.expected( _ => self.expected(
"JAR, FILE or ARCHIVE, got {:?}", "JAR, FILE or ARCHIVE, got {:?}",
TokenWithLocation::wrap(Token::make_keyword(format!("{:?}", keyword).as_str())), TokenWithLocation::wrap(Token::make_keyword(format!("{keyword:?}").as_str())),
), ),
} }
} }
@ -4028,7 +4028,7 @@ impl<'a> Parser<'a> {
fn parse_literal_char(&mut self) -> Result<char, ParserError> { fn parse_literal_char(&mut self) -> Result<char, ParserError> {
let s = self.parse_literal_string()?; let s = self.parse_literal_string()?;
if s.len() != 1 { if s.len() != 1 {
return parser_err!(format!("Expect a char, found {:?}", s)); return parser_err!(format!("Expect a char, found {s:?}"));
} }
Ok(s.chars().next().unwrap()) Ok(s.chars().next().unwrap())
} }
@ -4107,7 +4107,7 @@ impl<'a> Parser<'a> {
// (i.e., it returns the input string). // (i.e., it returns the input string).
Token::Number(ref n, l) => match n.parse() { Token::Number(ref n, l) => match n.parse() {
Ok(n) => Ok(Value::Number(n, l)), Ok(n) => Ok(Value::Number(n, l)),
Err(e) => parser_err!(format!("Could not parse '{}' as number: {}", n, e)), Err(e) => parser_err!(format!("Could not parse '{n}' as number: {e}")),
}, },
Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())), Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())),
Token::DoubleQuotedString(ref s) => Ok(Value::DoubleQuotedString(s.to_string())), Token::DoubleQuotedString(ref s) => Ok(Value::DoubleQuotedString(s.to_string())),
@ -4147,7 +4147,7 @@ impl<'a> Parser<'a> {
let next_token = self.next_token(); let next_token = self.next_token();
match next_token.token { match next_token.token {
Token::Number(s, _) => s.parse::<u64>().map_err(|e| { Token::Number(s, _) => s.parse::<u64>().map_err(|e| {
ParserError::ParserError(format!("Could not parse '{}' as u64: {}", s, e)) ParserError::ParserError(format!("Could not parse '{s}' as u64: {e}"))
}), }),
_ => self.expected("literal int", next_token), _ => self.expected("literal int", next_token),
} }
@ -5267,8 +5267,7 @@ impl<'a> Parser<'a> {
Keyword::EVENT => Ok(ShowCreateObject::Event), Keyword::EVENT => Ok(ShowCreateObject::Event),
Keyword::VIEW => Ok(ShowCreateObject::View), Keyword::VIEW => Ok(ShowCreateObject::View),
keyword => Err(ParserError::ParserError(format!( keyword => Err(ParserError::ParserError(format!(
"Unable to map keyword to ShowCreateObject: {:?}", "Unable to map keyword to ShowCreateObject: {keyword:?}"
keyword
))), ))),
}?; }?;
@ -5437,8 +5436,7 @@ impl<'a> Parser<'a> {
} }
_ => { _ => {
return Err(ParserError::ParserError(format!( return Err(ParserError::ParserError(format!(
"expected OUTER, SEMI, ANTI or JOIN after {:?}", "expected OUTER, SEMI, ANTI or JOIN after {kw:?}"
kw
))) )))
} }
} }
@ -5561,8 +5559,7 @@ impl<'a> Parser<'a> {
// but not `FROM (mytable AS alias1) AS alias2`. // but not `FROM (mytable AS alias1) AS alias2`.
if let Some(inner_alias) = alias { if let Some(inner_alias) = alias {
return Err(ParserError::ParserError(format!( return Err(ParserError::ParserError(format!(
"duplicate alias {}", "duplicate alias {inner_alias}"
inner_alias
))); )));
} }
// Act as if the alias was specified normally next // Act as if the alias was specified normally next
@ -5731,8 +5728,7 @@ impl<'a> Parser<'a> {
if !err.is_empty() { if !err.is_empty() {
let errors: Vec<Keyword> = err.into_iter().filter_map(|x| x.err()).collect(); let errors: Vec<Keyword> = err.into_iter().filter_map(|x| x.err()).collect();
return Err(ParserError::ParserError(format!( return Err(ParserError::ParserError(format!(
"INTERNAL ERROR: GRANT/REVOKE unexpected keyword(s) - {:?}", "INTERNAL ERROR: GRANT/REVOKE unexpected keyword(s) - {errors:?}"
errors
))); )));
} }
let act = actions.into_iter().filter_map(|x| x.ok()).collect(); let act = actions.into_iter().filter_map(|x| x.ok()).collect();

3
src/test_utils.rs
View file

@ -49,8 +49,7 @@ impl TestedDialects {
if let Some((prev_dialect, prev_parsed)) = s { if let Some((prev_dialect, prev_parsed)) = s {
assert_eq!( assert_eq!(
prev_parsed, parsed, prev_parsed, parsed,
"Parse results with {:?} are different from {:?}", "Parse results with {prev_dialect:?} are different from {dialect:?}"
prev_dialect, dialect
); );
} }
Some((dialect, parsed)) Some((dialect, parsed))

37
src/tokenizer.rs
View file

@ -180,17 +180,17 @@ impl fmt::Display for Token {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
Token::EOF => f.write_str("EOF"), Token::EOF => f.write_str("EOF"),
Token::Word(ref w) => write!(f, "{}", w), Token::Word(ref w) => write!(f, "{w}"),
Token::Number(ref n, l) => write!(f, "{}{long}", n, long = if *l { "L" } else { "" }), Token::Number(ref n, l) => write!(f, "{}{long}", n, long = if *l { "L" } else { "" }),
Token::Char(ref c) => write!(f, "{}", c), Token::Char(ref c) => write!(f, "{c}"),
Token::SingleQuotedString(ref s) => write!(f, "'{}'", s), Token::SingleQuotedString(ref s) => write!(f, "'{s}'"),
Token::DoubleQuotedString(ref s) => write!(f, "\"{}\"", s), Token::DoubleQuotedString(ref s) => write!(f, "\"{s}\""),
Token::DollarQuotedString(ref s) => write!(f, "{}", s), Token::DollarQuotedString(ref s) => write!(f, "{s}"),
Token::NationalStringLiteral(ref s) => write!(f, "N'{}'", s), Token::NationalStringLiteral(ref s) => write!(f, "N'{s}'"),
Token::EscapedStringLiteral(ref s) => write!(f, "E'{}'", s), Token::EscapedStringLiteral(ref s) => write!(f, "E'{s}'"),
Token::HexStringLiteral(ref s) => write!(f, "X'{}'", s), Token::HexStringLiteral(ref s) => write!(f, "X'{s}'"),
Token::Comma => f.write_str(","), Token::Comma => f.write_str(","),
Token::Whitespace(ws) => write!(f, "{}", ws), Token::Whitespace(ws) => write!(f, "{ws}"),
Token::DoubleEq => f.write_str("=="), Token::DoubleEq => f.write_str("=="),
Token::Spaceship => f.write_str("<=>"), Token::Spaceship => f.write_str("<=>"),
Token::Eq => f.write_str("="), Token::Eq => f.write_str("="),
@ -232,7 +232,7 @@ impl fmt::Display for Token {
Token::ShiftRight => f.write_str(">>"), Token::ShiftRight => f.write_str(">>"),
Token::PGSquareRoot => f.write_str("|/"), Token::PGSquareRoot => f.write_str("|/"),
Token::PGCubeRoot => f.write_str("||/"), Token::PGCubeRoot => f.write_str("||/"),
Token::Placeholder(ref s) => write!(f, "{}", s), Token::Placeholder(ref s) => write!(f, "{s}"),
Token::Arrow => write!(f, "->"), Token::Arrow => write!(f, "->"),
Token::LongArrow => write!(f, "->>"), Token::LongArrow => write!(f, "->>"),
Token::HashArrow => write!(f, "#>"), Token::HashArrow => write!(f, "#>"),
@ -323,8 +323,8 @@ impl fmt::Display for Whitespace {
Whitespace::Space => f.write_str(" "), Whitespace::Space => f.write_str(" "),
Whitespace::Newline => f.write_str("\n"), Whitespace::Newline => f.write_str("\n"),
Whitespace::Tab => f.write_str("\t"), Whitespace::Tab => f.write_str("\t"),
Whitespace::SingleLineComment { prefix, comment } => write!(f, "{}{}", prefix, comment), Whitespace::SingleLineComment { prefix, comment } => write!(f, "{prefix}{comment}"),
Whitespace::MultiLineComment(s) => write!(f, "/*{}*/", s), Whitespace::MultiLineComment(s) => write!(f, "/*{s}*/"),
} }
} }
} }
@ -595,13 +595,13 @@ impl<'a> Tokenizer<'a> {
} else { } else {
self.tokenizer_error( self.tokenizer_error(
error_loc, error_loc,
format!("Expected close delimiter '{}' before EOF.", quote_end), format!("Expected close delimiter '{quote_end}' before EOF."),
) )
} }
} }
// numbers and period // numbers and period
'0'..='9' | '.' => { '0'..='9' | '.' => {
let mut s = peeking_take_while(chars, |ch| matches!(ch, '0'..='9')); let mut s = peeking_take_while(chars, |ch| ch.is_ascii_digit());
// match binary literal that starts with 0x // match binary literal that starts with 0x
if s == "0" && chars.peek() == Some(&'x') { if s == "0" && chars.peek() == Some(&'x') {
@ -618,7 +618,7 @@ impl<'a> Tokenizer<'a> {
s.push('.'); s.push('.');
chars.next(); chars.next();
} }
s += &peeking_take_while(chars, |ch| matches!(ch, '0'..='9')); s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
// No number -> Token::Period // No number -> Token::Period
if s == "." { if s == "." {
@ -642,12 +642,12 @@ impl<'a> Tokenizer<'a> {
match char_clone.peek() { match char_clone.peek() {
// Definitely an exponent, get original iterator up to speed and use it // Definitely an exponent, get original iterator up to speed and use it
Some(&c) if matches!(c, '0'..='9') => { Some(&c) if c.is_ascii_digit() => {
for _ in 0..exponent_part.len() { for _ in 0..exponent_part.len() {
chars.next(); chars.next();
} }
exponent_part += exponent_part +=
&peeking_take_while(chars, |ch| matches!(ch, '0'..='9')); &peeking_take_while(chars, |ch| ch.is_ascii_digit());
s += exponent_part.as_str(); s += exponent_part.as_str();
} }
// Not an exponent, discard the work done // Not an exponent, discard the work done
@ -907,8 +907,7 @@ impl<'a> Tokenizer<'a> {
return self.tokenizer_error( return self.tokenizer_error(
chars.location(), chars.location(),
format!( format!(
"Unterminated dollar-quoted string at or near \"{}\"", "Unterminated dollar-quoted string at or near \"{value}\""
value
), ),
); );
} }

4
tests/sqlparser_bigquery.rs
View file

@ -35,7 +35,7 @@ fn parse_literal_string() {
#[test] #[test]
fn parse_table_identifiers() { fn parse_table_identifiers() {
fn test_table_ident(ident: &str, expected: Vec<Ident>) { fn test_table_ident(ident: &str, expected: Vec<Ident>) {
let sql = format!("SELECT 1 FROM {}", ident); let sql = format!("SELECT 1 FROM {ident}");
let select = bigquery().verified_only_select(&sql); let select = bigquery().verified_only_select(&sql);
assert_eq!( assert_eq!(
select.from, select.from,
@ -51,7 +51,7 @@ fn parse_table_identifiers() {
); );
} }
fn test_table_ident_err(ident: &str) { fn test_table_ident_err(ident: &str) {
let sql = format!("SELECT 1 FROM {}", ident); let sql = format!("SELECT 1 FROM {ident}");
assert!(bigquery().parse_sql_statements(&sql).is_err()); assert!(bigquery().parse_sql_statements(&sql).is_err());
} }

102
tests/sqlparser_common.rs
View file

@ -2435,7 +2435,7 @@ fn parse_create_or_replace_table() {
#[test] #[test]
fn parse_create_table_with_on_delete_on_update_2in_any_order() -> Result<(), ParserError> { fn parse_create_table_with_on_delete_on_update_2in_any_order() -> Result<(), ParserError> {
let sql = |options: &str| -> String { let sql = |options: &str| -> String {
format!("create table X (y_id int references Y (id) {})", options) format!("create table X (y_id int references Y (id) {options})")
}; };
parse_sql_statements(&sql("on update cascade on delete no action"))?; parse_sql_statements(&sql("on update cascade on delete no action"))?;
@ -2777,7 +2777,7 @@ fn parse_alter_table_constraints() {
check_one("CHECK (end_date > start_date OR end_date IS NULL)"); check_one("CHECK (end_date > start_date OR end_date IS NULL)");
fn check_one(constraint_text: &str) { fn check_one(constraint_text: &str) {
match verified_stmt(&format!("ALTER TABLE tab ADD {}", constraint_text)) { match verified_stmt(&format!("ALTER TABLE tab ADD {constraint_text}")) {
Statement::AlterTable { Statement::AlterTable {
name, name,
operation: AlterTableOperation::AddConstraint(constraint), operation: AlterTableOperation::AddConstraint(constraint),
@ -2787,7 +2787,7 @@ fn parse_alter_table_constraints() {
} }
_ => unreachable!(), _ => unreachable!(),
} }
verified_stmt(&format!("CREATE TABLE foo (id INT, {})", constraint_text)); verified_stmt(&format!("CREATE TABLE foo (id INT, {constraint_text})"));
} }
} }
@ -2804,7 +2804,7 @@ fn parse_alter_table_drop_column() {
); );
fn check_one(constraint_text: &str) { fn check_one(constraint_text: &str) {
match verified_stmt(&format!("ALTER TABLE tab {}", constraint_text)) { match verified_stmt(&format!("ALTER TABLE tab {constraint_text}")) {
Statement::AlterTable { Statement::AlterTable {
name, name,
operation: operation:
@ -2827,10 +2827,7 @@ fn parse_alter_table_drop_column() {
#[test] #[test]
fn parse_alter_table_alter_column() { fn parse_alter_table_alter_column() {
let alter_stmt = "ALTER TABLE tab"; let alter_stmt = "ALTER TABLE tab";
match verified_stmt(&format!( match verified_stmt(&format!("{alter_stmt} ALTER COLUMN is_active SET NOT NULL")) {
"{} ALTER COLUMN is_active SET NOT NULL",
alter_stmt
)) {
Statement::AlterTable { Statement::AlterTable {
name, name,
operation: AlterTableOperation::AlterColumn { column_name, op }, operation: AlterTableOperation::AlterColumn { column_name, op },
@ -2848,8 +2845,7 @@ fn parse_alter_table_alter_column() {
); );
match verified_stmt(&format!( match verified_stmt(&format!(
"{} ALTER COLUMN is_active SET DEFAULT false", "{alter_stmt} ALTER COLUMN is_active SET DEFAULT false"
alter_stmt
)) { )) {
Statement::AlterTable { Statement::AlterTable {
name, name,
@ -2867,10 +2863,7 @@ fn parse_alter_table_alter_column() {
_ => unreachable!(), _ => unreachable!(),
} }
match verified_stmt(&format!( match verified_stmt(&format!("{alter_stmt} ALTER COLUMN is_active DROP DEFAULT")) {
"{} ALTER COLUMN is_active DROP DEFAULT",
alter_stmt
)) {
Statement::AlterTable { Statement::AlterTable {
name, name,
operation: AlterTableOperation::AlterColumn { column_name, op }, operation: AlterTableOperation::AlterColumn { column_name, op },
@ -2906,7 +2899,7 @@ fn parse_alter_table_alter_column_type() {
let res = Parser::parse_sql( let res = Parser::parse_sql(
&GenericDialect {}, &GenericDialect {},
&format!("{} ALTER COLUMN is_active TYPE TEXT", alter_stmt), &format!("{alter_stmt} ALTER COLUMN is_active TYPE TEXT"),
); );
assert_eq!( assert_eq!(
ParserError::ParserError("Expected SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE after ALTER COLUMN, found: TYPE".to_string()), ParserError::ParserError("Expected SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE after ALTER COLUMN, found: TYPE".to_string()),
@ -2915,10 +2908,7 @@ fn parse_alter_table_alter_column_type() {
let res = Parser::parse_sql( let res = Parser::parse_sql(
&GenericDialect {}, &GenericDialect {},
&format!( &format!("{alter_stmt} ALTER COLUMN is_active SET DATA TYPE TEXT USING 'text'"),
"{} ALTER COLUMN is_active SET DATA TYPE TEXT USING 'text'",
alter_stmt
),
); );
assert_eq!( assert_eq!(
ParserError::ParserError("Expected end of statement, found: USING".to_string()), ParserError::ParserError("Expected end of statement, found: USING".to_string()),
@ -2966,7 +2956,7 @@ fn parse_alter_table_drop_constraint() {
let res = Parser::parse_sql( let res = Parser::parse_sql(
&GenericDialect {}, &GenericDialect {},
&format!("{} DROP CONSTRAINT is_active TEXT", alter_stmt), &format!("{alter_stmt} DROP CONSTRAINT is_active TEXT"),
); );
assert_eq!( assert_eq!(
ParserError::ParserError("Expected end of statement, found: TEXT".to_string()), ParserError::ParserError("Expected end of statement, found: TEXT".to_string()),
@ -2997,7 +2987,7 @@ fn parse_scalar_function_in_projection() {
for function_name in names { for function_name in names {
// like SELECT sqrt(id) FROM foo // like SELECT sqrt(id) FROM foo
let sql = dbg!(format!("SELECT {}(id) FROM foo", function_name)); let sql = dbg!(format!("SELECT {function_name}(id) FROM foo"));
let select = verified_only_select(&sql); let select = verified_only_select(&sql);
assert_eq!( assert_eq!(
&Expr::Function(Function { &Expr::Function(Function {
@ -4221,7 +4211,7 @@ fn parse_ctes() {
// Top-level CTE // Top-level CTE
assert_ctes_in_select(&cte_sqls, &verified_query(with)); assert_ctes_in_select(&cte_sqls, &verified_query(with));
// CTE in a subquery // CTE in a subquery
let sql = &format!("SELECT ({})", with); let sql = &format!("SELECT ({with})");
let select = verified_only_select(sql); let select = verified_only_select(sql);
match expr_from_projection(only(&select.projection)) { match expr_from_projection(only(&select.projection)) {
Expr::Subquery(ref subquery) => { Expr::Subquery(ref subquery) => {
@ -4230,7 +4220,7 @@ fn parse_ctes() {
_ => panic!("Expected subquery"), _ => panic!("Expected subquery"),
} }
// CTE in a derived table // CTE in a derived table
let sql = &format!("SELECT * FROM ({})", with); let sql = &format!("SELECT * FROM ({with})");
let select = verified_only_select(sql); let select = verified_only_select(sql);
match only(select.from).relation { match only(select.from).relation {
TableFactor::Derived { subquery, .. } => { TableFactor::Derived { subquery, .. } => {
@ -4239,13 +4229,13 @@ fn parse_ctes() {
_ => panic!("Expected derived table"), _ => panic!("Expected derived table"),
} }
// CTE in a view // CTE in a view
let sql = &format!("CREATE VIEW v AS {}", with); let sql = &format!("CREATE VIEW v AS {with}");
match verified_stmt(sql) { match verified_stmt(sql) {
Statement::CreateView { query, .. } => assert_ctes_in_select(&cte_sqls, &query), Statement::CreateView { query, .. } => assert_ctes_in_select(&cte_sqls, &query),
_ => panic!("Expected CREATE VIEW"), _ => panic!("Expected CREATE VIEW"),
} }
// CTE in a CTE... // CTE in a CTE...
let sql = &format!("WITH outer_cte AS ({}) SELECT * FROM outer_cte", with); let sql = &format!("WITH outer_cte AS ({with}) SELECT * FROM outer_cte");
let select = verified_query(sql); let select = verified_query(sql);
assert_ctes_in_select(&cte_sqls, &only(&select.with.unwrap().cte_tables).query); assert_ctes_in_select(&cte_sqls, &only(&select.with.unwrap().cte_tables).query);
} }
@ -4270,10 +4260,7 @@ fn parse_cte_renamed_columns() {
#[test] #[test]
fn parse_recursive_cte() { fn parse_recursive_cte() {
let cte_query = "SELECT 1 UNION ALL SELECT val + 1 FROM nums WHERE val < 10".to_owned(); let cte_query = "SELECT 1 UNION ALL SELECT val + 1 FROM nums WHERE val < 10".to_owned();
let sql = &format!( let sql = &format!("WITH RECURSIVE nums (val) AS ({cte_query}) SELECT * FROM nums");
"WITH RECURSIVE nums (val) AS ({}) SELECT * FROM nums",
cte_query
);
let cte_query = verified_query(&cte_query); let cte_query = verified_query(&cte_query);
let query = verified_query(sql); let query = verified_query(sql);
@ -5029,9 +5016,8 @@ fn lateral_derived() {
fn chk(lateral_in: bool) { fn chk(lateral_in: bool) {
let lateral_str = if lateral_in { "LATERAL " } else { "" }; let lateral_str = if lateral_in { "LATERAL " } else { "" };
let sql = format!( let sql = format!(
"SELECT * FROM customer LEFT JOIN {}\ "SELECT * FROM customer LEFT JOIN {lateral_str}\
(SELECT * FROM order WHERE order.customer = customer.id LIMIT 3) AS order ON true", (SELECT * FROM order WHERE order.customer = customer.id LIMIT 3) AS order ON true"
lateral_str
); );
let select = verified_only_select(&sql); let select = verified_only_select(&sql);
let from = only(select.from); let from = only(select.from);
@ -6286,9 +6272,7 @@ fn parse_cache_table() {
let query = all_dialects().verified_query(sql); let query = all_dialects().verified_query(sql);
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(format!("CACHE TABLE '{cache_table_name}'").as_str()),
format!("CACHE TABLE '{table_name}'", table_name = 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(vec![Ident::with_quote('\'', cache_table_name)]),
@ -6299,14 +6283,7 @@ fn parse_cache_table() {
); );
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}'").as_str()),
format!(
"CACHE {flag} TABLE '{table_name}'",
flag = table_flag,
table_name = cache_table_name
)
.as_str()
),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]),
@ -6319,9 +6296,7 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(
format!( format!(
"CACHE {flag} TABLE '{table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88)", "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88)",
flag = table_flag,
table_name = cache_table_name,
) )
.as_str() .as_str()
), ),
@ -6346,10 +6321,7 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(
format!( format!(
"CACHE {flag} TABLE '{table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) {sql}", "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) {sql}",
flag = table_flag,
table_name = cache_table_name,
sql = sql,
) )
.as_str() .as_str()
), ),
@ -6374,10 +6346,7 @@ fn parse_cache_table() {
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(
format!( format!(
"CACHE {flag} TABLE '{table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) AS {sql}", "CACHE {table_flag} TABLE '{cache_table_name}' OPTIONS('K1' = 'V1', 'K2' = 0.88) AS {sql}",
flag = table_flag,
table_name = cache_table_name,
sql = sql,
) )
.as_str() .as_str()
), ),
@ -6400,15 +6369,7 @@ fn parse_cache_table() {
); );
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' {sql}").as_str()),
format!(
"CACHE {flag} TABLE '{table_name}' {sql}",
flag = table_flag,
table_name = cache_table_name,
sql = sql
)
.as_str()
),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]),
@ -6419,14 +6380,7 @@ fn parse_cache_table() {
); );
assert_eq!( assert_eq!(
verified_stmt( verified_stmt(format!("CACHE {table_flag} TABLE '{cache_table_name}' AS {sql}").as_str()),
format!(
"CACHE {flag} TABLE '{table_name}' AS {sql}",
flag = table_flag,
table_name = cache_table_name
)
.as_str()
),
Statement::Cache { Statement::Cache {
table_flag: Some(ObjectName(vec![Ident::new(table_flag)])), table_flag: Some(ObjectName(vec![Ident::new(table_flag)])),
table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]), table_name: ObjectName(vec![Ident::with_quote('\'', cache_table_name)]),
@ -6574,7 +6528,7 @@ fn parse_with_recursion_limit() {
.expect("tokenize to work") .expect("tokenize to work")
.parse_statements(); .parse_statements();
assert!(matches!(res, Ok(_)), "{:?}", res); assert!(matches!(res, Ok(_)), "{res:?}");
// limit recursion to something smaller, expect parsing to fail // limit recursion to something smaller, expect parsing to fail
let res = Parser::new(&dialect) let res = Parser::new(&dialect)
@ -6592,7 +6546,7 @@ fn parse_with_recursion_limit() {
.with_recursion_limit(50) .with_recursion_limit(50)
.parse_statements(); .parse_statements();
assert!(matches!(res, Ok(_)), "{:?}", res); assert!(matches!(res, Ok(_)), "{res:?}");
} }
/// Makes a predicate that looks like ((user_id = $id) OR user_id = $2...) /// Makes a predicate that looks like ((user_id = $id) OR user_id = $2...)
@ -6604,7 +6558,7 @@ fn make_where_clause(num: usize) -> String {
if i > 0 { if i > 0 {
write!(&mut output, " OR ").unwrap(); write!(&mut output, " OR ").unwrap();
} }
write!(&mut output, "user_id = {}", i).unwrap(); write!(&mut output, "user_id = {i}").unwrap();
if i < num - 1 { if i < num - 1 {
write!(&mut output, ")").unwrap(); write!(&mut output, ")").unwrap();
} }

6
tests/sqlparser_custom_dialect.rs
View file

@ -47,7 +47,7 @@ fn custom_prefix_parser() -> Result<(), ParserError> {
let sql = "SELECT 1 + 2"; let sql = "SELECT 1 + 2";
let ast = Parser::parse_sql(&dialect, sql)?; let ast = Parser::parse_sql(&dialect, sql)?;
let query = &ast[0]; let query = &ast[0];
assert_eq!("SELECT NULL + 2", &format!("{}", query)); assert_eq!("SELECT NULL + 2", &format!("{query}"));
Ok(()) Ok(())
} }
@ -87,7 +87,7 @@ fn custom_infix_parser() -> Result<(), ParserError> {
let sql = "SELECT 1 + 2"; let sql = "SELECT 1 + 2";
let ast = Parser::parse_sql(&dialect, sql)?; let ast = Parser::parse_sql(&dialect, sql)?;
let query = &ast[0]; let query = &ast[0];
assert_eq!("SELECT 1 * 2", &format!("{}", query)); assert_eq!("SELECT 1 * 2", &format!("{query}"));
Ok(()) Ok(())
} }
@ -121,7 +121,7 @@ fn custom_statement_parser() -> Result<(), ParserError> {
let sql = "SELECT 1 + 2"; let sql = "SELECT 1 + 2";
let ast = Parser::parse_sql(&dialect, sql)?; let ast = Parser::parse_sql(&dialect, sql)?;
let query = &ast[0]; let query = &ast[0];
assert_eq!("COMMIT", &format!("{}", query)); assert_eq!("COMMIT", &format!("{query}"));
Ok(()) Ok(())
} }

2
tests/sqlparser_mysql.rs
View file

@ -209,7 +209,7 @@ fn parse_show_create() {
ShowCreateObject::View, ShowCreateObject::View,
] { ] {
assert_eq!( assert_eq!(
mysql_and_generic().verified_stmt(format!("SHOW CREATE {} myident", obj_type).as_str()), mysql_and_generic().verified_stmt(format!("SHOW CREATE {obj_type} myident").as_str()),
Statement::ShowCreate { Statement::ShowCreate {
obj_type: *obj_type, obj_type: *obj_type,
obj_name: obj_name.clone(), obj_name: obj_name.clone(),

14
tests/sqlparser_postgres.rs
View file

@ -485,7 +485,7 @@ PHP ₱ USD $
\N Some other value \N Some other value
\\."#; \\."#;
let ast = pg_and_generic().one_statement_parses_to(sql, ""); let ast = pg_and_generic().one_statement_parses_to(sql, "");
println!("{:#?}", ast); println!("{ast:#?}");
//assert_eq!(sql, ast.to_string()); //assert_eq!(sql, ast.to_string());
} }
@ -2069,7 +2069,7 @@ fn parse_create_role() {
assert_eq!(*login, Some(true)); assert_eq!(*login, Some(true));
assert_eq!(*password, Some(Password::NullPassword)); assert_eq!(*password, Some(Password::NullPassword));
} }
err => panic!("Failed to parse CREATE ROLE test case: {:?}", err), err => panic!("Failed to parse CREATE ROLE test case: {err:?}"),
} }
let sql = "CREATE ROLE abc WITH LOGIN PASSWORD NULL"; let sql = "CREATE ROLE abc WITH LOGIN PASSWORD NULL";
@ -2086,7 +2086,7 @@ fn parse_create_role() {
assert_eq!(*login, Some(true)); assert_eq!(*login, Some(true));
assert_eq!(*password, Some(Password::NullPassword)); assert_eq!(*password, Some(Password::NullPassword));
} }
err => panic!("Failed to parse CREATE ROLE test case: {:?}", err), err => panic!("Failed to parse CREATE ROLE test case: {err:?}"),
} }
let sql = "CREATE ROLE magician WITH SUPERUSER CREATEROLE NOCREATEDB BYPASSRLS INHERIT PASSWORD 'abcdef' LOGIN VALID UNTIL '2025-01-01' IN ROLE role1, role2 ROLE role3 ADMIN role4, role5 REPLICATION"; let sql = "CREATE ROLE magician WITH SUPERUSER CREATEROLE NOCREATEDB BYPASSRLS INHERIT PASSWORD 'abcdef' LOGIN VALID UNTIL '2025-01-01' IN ROLE role1, role2 ROLE role3 ADMIN role4, role5 REPLICATION";
@ -2141,7 +2141,7 @@ fn parse_create_role() {
assert_eq_vec(&["role4", "role5"], admin); assert_eq_vec(&["role4", "role5"], admin);
assert_eq!(*authorization_owner, None); assert_eq!(*authorization_owner, None);
} }
err => panic!("Failed to parse CREATE ROLE test case: {:?}", err), err => panic!("Failed to parse CREATE ROLE test case: {err:?}"),
} }
let sql = "CREATE ROLE abc WITH USER foo, bar ROLE baz "; let sql = "CREATE ROLE abc WITH USER foo, bar ROLE baz ";
@ -2155,7 +2155,7 @@ fn parse_create_role() {
assert_eq_vec(&["foo", "bar"], user); assert_eq_vec(&["foo", "bar"], user);
assert_eq_vec(&["baz"], role); assert_eq_vec(&["baz"], role);
} }
err => panic!("Failed to parse CREATE ROLE test case: {:?}", err), err => panic!("Failed to parse CREATE ROLE test case: {err:?}"),
} }
let negatables = vec![ let negatables = vec![
@ -2169,9 +2169,9 @@ fn parse_create_role() {
]; ];
for negatable_kw in negatables.iter() { for negatable_kw in negatables.iter() {
let sql = format!("CREATE ROLE abc {kw} NO{kw}", kw = negatable_kw); let sql = format!("CREATE ROLE abc {negatable_kw} NO{negatable_kw}");
if pg().parse_sql_statements(&sql).is_ok() { if pg().parse_sql_statements(&sql).is_ok() {
panic!("Should not be able to parse CREATE ROLE containing both negated and non-negated versions of the same keyword: {}", negatable_kw) panic!("Should not be able to parse CREATE ROLE containing both negated and non-negated versions of the same keyword: {negatable_kw}")
} }
} }
} }