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

Support multiple-table DELETE syntax (#855)

Browse source
This commit is contained in:
AviRaboah 2023-04-27 18:41:20 +03:00 • committed by GitHub
parent 5ecf633e31
commit f72e2ec382
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 131 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

19
src/ast/mod.rs
View file

@ -1229,10 +1229,12 @@ pub enum Statement {
},
/// DELETE
Delete {
/// Multi tables delete are supported in mysql
tables: Vec<ObjectName>,
/// FROM
table_name: TableFactor,
/// USING (Snowflake, Postgres)
using: Option<TableFactor>,
from: Vec<TableWithJoins>,
/// USING (Snowflake, Postgres, MySQL)
using: Option<Vec<TableWithJoins>>,
/// WHERE
selection: Option<Expr>,
/// RETURNING
@ -1982,14 +1984,19 @@ impl fmt::Display for Statement {
Ok(())
}
Statement::Delete {
table_name,
tables,
from,
using,
selection,
returning,
} => {
write!(f, "DELETE FROM {table_name}")?;
write!(f, "DELETE ")?;
if !tables.is_empty() {
write!(f, "{} ", display_comma_separated(tables))?;
}
write!(f, "FROM {}", display_comma_separated(from))?;
if let Some(using) = using {
write!(f, " USING {using}")?;
write!(f, " USING {}", display_comma_separated(using))?;
}
if let Some(selection) = selection {
write!(f, " WHERE {selection}")?;

14
src/parser.rs
View file

@ -4813,10 +4813,17 @@ impl<'a> Parser<'a> {
}
pub fn parse_delete(&mut self) -> Result<Statement, ParserError> {
let tables = if !self.parse_keyword(Keyword::FROM) {
let tables = self.parse_comma_separated(Parser::parse_object_name)?;
self.expect_keyword(Keyword::FROM)?;
let table_name = self.parse_table_factor()?;
tables
} else {
vec![]
};
let from = self.parse_comma_separated(Parser::parse_table_and_joins)?;
let using = if self.parse_keyword(Keyword::USING) {
Some(self.parse_table_factor()?)
Some(self.parse_comma_separated(Parser::parse_table_and_joins)?)
} else {
None
};
@ -4833,7 +4840,8 @@ impl<'a> Parser<'a> {
};
Ok(Statement::Delete {
table_name,
tables,
from,
using,
selection,
returning,

108
tests/sqlparser_common.rs
View file

@ -385,7 +385,7 @@ fn parse_no_table_name() {
fn parse_delete_statement() {
let sql = "DELETE FROM \"table\"";
match verified_stmt(sql) {
Statement::Delete { table_name, .. } => {
Statement::Delete { from, .. } => {
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::with_quote('"', "table")]),
@ -393,7 +393,93 @@ fn parse_delete_statement() {
args: None,
with_hints: vec![],
},
table_name
from[0].relation
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_delete_statement_for_multi_tables() {
let sql = "DELETE schema1.table1, schema2.table2 FROM schema1.table1 JOIN schema2.table2 ON schema2.table2.col1 = schema1.table1.col1 WHERE schema2.table2.col2 = 1";
match verified_stmt(sql) {
Statement::Delete { tables, from, .. } => {
assert_eq!(
ObjectName(vec![Ident::new("schema1"), Ident::new("table1")]),
tables[0]
);
assert_eq!(
ObjectName(vec![Ident::new("schema2"), Ident::new("table2")]),
tables[1]
);
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema1"), Ident::new("table1")]),
alias: None,
args: None,
with_hints: vec![],
},
from[0].relation
);
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema2"), Ident::new("table2")]),
alias: None,
args: None,
with_hints: vec![],
},
from[0].joins[0].relation
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_delete_statement_for_multi_tables_with_using() {
let sql = "DELETE FROM schema1.table1, schema2.table2 USING schema1.table1 JOIN schema2.table2 ON schema2.table2.pk = schema1.table1.col1 WHERE schema2.table2.col2 = 1";
match verified_stmt(sql) {
Statement::Delete {
from,
using: Some(using),
..
} => {
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema1"), Ident::new("table1")]),
alias: None,
args: None,
with_hints: vec![],
},
from[0].relation
);
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema2"), Ident::new("table2")]),
alias: None,
args: None,
with_hints: vec![],
},
from[1].relation
);
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema1"), Ident::new("table1")]),
alias: None,
args: None,
with_hints: vec![],
},
using[0].relation
);
assert_eq!(
TableFactor::Table {
name: ObjectName(vec![Ident::new("schema2"), Ident::new("table2")]),
alias: None,
args: None,
with_hints: vec![],
},
using[0].joins[0].relation
);
}
_ => unreachable!(),
@ -407,7 +493,8 @@ fn parse_where_delete_statement() {
let sql = "DELETE FROM foo WHERE name = 5";
match verified_stmt(sql) {
Statement::Delete {
table_name,
tables: _,
from,
using,
selection,
returning,
@ -419,7 +506,7 @@ fn parse_where_delete_statement() {
args: None,
with_hints: vec![],
},
table_name,
from[0].relation,
);
assert_eq!(None, using);
@ -444,7 +531,8 @@ fn parse_where_delete_with_alias_statement() {
let sql = "DELETE FROM basket AS a USING basket AS b WHERE a.id < b.id";
match verified_stmt(sql) {
Statement::Delete {
table_name,
tables: _,
from,
using,
selection,
returning,
@ -459,11 +547,11 @@ fn parse_where_delete_with_alias_statement() {
args: None,
with_hints: vec![],
},
table_name,
from[0].relation,
);
assert_eq!(
Some(TableFactor::Table {
Some(vec![TableWithJoins {
relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("basket")]),
alias: Some(TableAlias {
name: Ident::new("b"),
@ -471,7 +559,9 @@ fn parse_where_delete_with_alias_statement() {
}),
args: None,
with_hints: vec![],
}),
},
joins: vec![],
}]),
using
);
assert_eq!(