@@ -290,7 +290,7 @@ impl Parser {
290
290
vec ! [ ]
291
291
} ;
292
292
let order_by = if self . parse_keywords ( vec ! [ "ORDER" , "BY" ] ) {
293
- self . parse_order_by_expr_list ( ) ?
293
+ self . parse_comma_separated ( Parser :: parse_order_by_expr ) ?
294
294
} else {
295
295
vec ! [ ]
296
296
} ;
@@ -829,6 +829,21 @@ impl Parser {
829
829
}
830
830
}
831
831
832
+ /// Parse a comma-separated list of 1+ items accepted by `F`
833
+ pub fn parse_comma_separated < T , F > ( & mut self , mut f : F ) -> Result < Vec < T > , ParserError >
834
+ where
835
+ F : FnMut ( & mut Parser ) -> Result < T , ParserError > ,
836
+ {
837
+ let mut values = vec ! [ ] ;
838
+ loop {
839
+ values. push ( f ( self ) ?) ;
840
+ if !self . consume_token ( & Token :: Comma ) {
841
+ break ;
842
+ }
843
+ }
844
+ Ok ( values)
845
+ }
846
+
832
847
/// Parse a SQL CREATE statement
833
848
pub fn parse_create ( & mut self ) -> Result < Statement , ParserError > {
834
849
if self . parse_keyword ( "TABLE" ) {
@@ -872,11 +887,7 @@ impl Parser {
872
887
// ANSI SQL and Postgres support RECURSIVE here, but we don't support it either.
873
888
let name = self . parse_object_name ( ) ?;
874
889
let columns = self . parse_parenthesized_column_list ( Optional ) ?;
875
- let with_options = if self . parse_keyword ( "WITH" ) {
876
- self . parse_with_options ( ) ?
877
- } else {
878
- vec ! [ ]
879
- } ;
890
+ let with_options = self . parse_with_options ( ) ?;
880
891
self . expect_keyword ( "AS" ) ?;
881
892
let query = Box :: new ( self . parse_query ( ) ?) ;
882
893
// Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here.
@@ -897,14 +908,10 @@ impl Parser {
897
908
} else {
898
909
return self . expected ( "TABLE or VIEW after DROP" , self . peek_token ( ) ) ;
899
910
} ;
911
+ // Many dialects support the non standard `IF EXISTS` clause and allow
912
+ // specifying multiple objects to delete in a single statement
900
913
let if_exists = self . parse_keywords ( vec ! [ "IF" , "EXISTS" ] ) ;
901
- let mut names = vec ! [ ] ;
902
- loop {
903
- names. push ( self . parse_object_name ( ) ?) ;
904
- if !self . consume_token ( & Token :: Comma ) {
905
- break ;
906
- }
907
- }
914
+ let names = self . parse_comma_separated ( Parser :: parse_object_name) ?;
908
915
let cascade = self . parse_keyword ( "CASCADE" ) ;
909
916
let restrict = self . parse_keyword ( "RESTRICT" ) ;
910
917
if cascade && restrict {
@@ -922,12 +929,7 @@ impl Parser {
922
929
let table_name = self . parse_object_name ( ) ?;
923
930
// parse optional column list (schema)
924
931
let ( columns, constraints) = self . parse_columns ( ) ?;
925
-
926
- let with_options = if self . parse_keyword ( "WITH" ) {
927
- self . parse_with_options ( ) ?
928
- } else {
929
- vec ! [ ]
930
- } ;
932
+ let with_options = self . parse_with_options ( ) ?;
931
933
932
934
Ok ( Statement :: CreateTable {
933
935
name : table_name,
@@ -1075,19 +1077,21 @@ impl Parser {
1075
1077
}
1076
1078
1077
1079
pub fn parse_with_options ( & mut self ) -> Result < Vec < SqlOption > , ParserError > {
1078
- self . expect_token ( & Token :: LParen ) ?;
1079
- let mut options = vec ! [ ] ;
1080
- loop {
1081
- let name = self . parse_identifier ( ) ?;
1082
- self . expect_token ( & Token :: Eq ) ?;
1083
- let value = self . parse_value ( ) ?;
1084
- options. push ( SqlOption { name, value } ) ;
1085
- if !self . consume_token ( & Token :: Comma ) {
1086
- break ;
1087
- }
1080
+ if self . parse_keyword ( "WITH" ) {
1081
+ self . expect_token ( & Token :: LParen ) ?;
1082
+ let options = self . parse_comma_separated ( Parser :: parse_sql_option) ?;
1083
+ self . expect_token ( & Token :: RParen ) ?;
1084
+ Ok ( options)
1085
+ } else {
1086
+ Ok ( vec ! [ ] )
1088
1087
}
1089
- self . expect_token ( & Token :: RParen ) ?;
1090
- Ok ( options)
1088
+ }
1089
+
1090
+ pub fn parse_sql_option ( & mut self ) -> Result < SqlOption , ParserError > {
1091
+ let name = self . parse_identifier ( ) ?;
1092
+ self . expect_token ( & Token :: Eq ) ?;
1093
+ let value = self . parse_value ( ) ?;
1094
+ Ok ( SqlOption { name, value } )
1091
1095
}
1092
1096
1093
1097
pub fn parse_alter ( & mut self ) -> Result < Statement , ParserError > {
@@ -1333,22 +1337,17 @@ impl Parser {
1333
1337
}
1334
1338
}
1335
1339
1336
- /// Parse one or more identifiers with the specified separator between them
1337
- pub fn parse_list_of_ids ( & mut self , separator : & Token ) -> Result < Vec < Ident > , ParserError > {
1340
+ /// Parse a possibly qualified, possibly quoted identifier, e.g.
1341
+ /// `foo` or `myschema."table"`
1342
+ pub fn parse_object_name ( & mut self ) -> Result < ObjectName , ParserError > {
1338
1343
let mut idents = vec ! [ ] ;
1339
1344
loop {
1340
1345
idents. push ( self . parse_identifier ( ) ?) ;
1341
- if !self . consume_token ( separator ) {
1346
+ if !self . consume_token ( & Token :: Period ) {
1342
1347
break ;
1343
1348
}
1344
1349
}
1345
- Ok ( idents)
1346
- }
1347
-
1348
- /// Parse a possibly qualified, possibly quoted identifier, e.g.
1349
- /// `foo` or `myschema."table"`
1350
- pub fn parse_object_name ( & mut self ) -> Result < ObjectName , ParserError > {
1351
- Ok ( ObjectName ( self . parse_list_of_ids ( & Token :: Period ) ?) )
1350
+ Ok ( ObjectName ( idents) )
1352
1351
}
1353
1352
1354
1353
/// Parse a simple one-word identifier (possibly quoted, possibly a keyword)
@@ -1365,7 +1364,7 @@ impl Parser {
1365
1364
optional : IsOptional ,
1366
1365
) -> Result < Vec < Ident > , ParserError > {
1367
1366
if self . consume_token ( & Token :: LParen ) {
1368
- let cols = self . parse_list_of_ids ( & Token :: Comma ) ?;
1367
+ let cols = self . parse_comma_separated ( Parser :: parse_identifier ) ?;
1369
1368
self . expect_token ( & Token :: RParen ) ?;
1370
1369
Ok ( cols)
1371
1370
} else if optional == Optional {
@@ -1424,15 +1423,15 @@ impl Parser {
1424
1423
pub fn parse_query ( & mut self ) -> Result < Query , ParserError > {
1425
1424
let ctes = if self . parse_keyword ( "WITH" ) {
1426
1425
// TODO: optional RECURSIVE
1427
- self . parse_cte_list ( ) ?
1426
+ self . parse_comma_separated ( Parser :: parse_cte ) ?
1428
1427
} else {
1429
1428
vec ! [ ]
1430
1429
} ;
1431
1430
1432
1431
let body = self . parse_query_body ( 0 ) ?;
1433
1432
1434
1433
let order_by = if self . parse_keywords ( vec ! [ "ORDER" , "BY" ] ) {
1435
- self . parse_order_by_expr_list ( ) ?
1434
+ self . parse_comma_separated ( Parser :: parse_order_by_expr ) ?
1436
1435
} else {
1437
1436
vec ! [ ]
1438
1437
} ;
@@ -1465,27 +1464,17 @@ impl Parser {
1465
1464
} )
1466
1465
}
1467
1466
1468
- /// Parse one or more (comma-separated) `alias AS (subquery)` CTEs,
1469
- /// assuming the initial `WITH` was already consumed.
1470
- fn parse_cte_list ( & mut self ) -> Result < Vec < Cte > , ParserError > {
1471
- let mut cte = vec ! [ ] ;
1472
- loop {
1473
- let alias = TableAlias {
1474
- name : self . parse_identifier ( ) ?,
1475
- columns : self . parse_parenthesized_column_list ( Optional ) ?,
1476
- } ;
1477
- self . expect_keyword ( "AS" ) ?;
1478
- self . expect_token ( & Token :: LParen ) ?;
1479
- cte. push ( Cte {
1480
- alias,
1481
- query : self . parse_query ( ) ?,
1482
- } ) ;
1483
- self . expect_token ( & Token :: RParen ) ?;
1484
- if !self . consume_token ( & Token :: Comma ) {
1485
- break ;
1486
- }
1487
- }
1488
- Ok ( cte)
1467
+ /// Parse a CTE (`alias [( col1, col2, ... )] AS (subquery)`)
1468
+ fn parse_cte ( & mut self ) -> Result < Cte , ParserError > {
1469
+ let alias = TableAlias {
1470
+ name : self . parse_identifier ( ) ?,
1471
+ columns : self . parse_parenthesized_column_list ( Optional ) ?,
1472
+ } ;
1473
+ self . expect_keyword ( "AS" ) ?;
1474
+ self . expect_token ( & Token :: LParen ) ?;
1475
+ let query = self . parse_query ( ) ?;
1476
+ self . expect_token ( & Token :: RParen ) ?;
1477
+ Ok ( Cte { alias, query } )
1489
1478
}
1490
1479
1491
1480
/// Parse a "query body", which is an expression with roughly the
@@ -1559,22 +1548,18 @@ impl Parser {
1559
1548
if all && distinct {
1560
1549
return parser_err ! ( "Cannot specify both ALL and DISTINCT in SELECT" ) ;
1561
1550
}
1562
- let projection = self . parse_select_list ( ) ?;
1551
+ let projection = self . parse_comma_separated ( Parser :: parse_select_item ) ?;
1563
1552
1564
1553
// Note that for keywords to be properly handled here, they need to be
1565
1554
// added to `RESERVED_FOR_COLUMN_ALIAS` / `RESERVED_FOR_TABLE_ALIAS`,
1566
1555
// otherwise they may be parsed as an alias as part of the `projection`
1567
1556
// or `from`.
1568
1557
1569
- let mut from = vec ! [ ] ;
1570
- if self . parse_keyword ( "FROM" ) {
1571
- loop {
1572
- from. push ( self . parse_table_and_joins ( ) ?) ;
1573
- if !self . consume_token ( & Token :: Comma ) {
1574
- break ;
1575
- }
1576
- }
1577
- }
1558
+ let from = if self . parse_keyword ( "FROM" ) {
1559
+ self . parse_comma_separated ( Parser :: parse_table_and_joins) ?
1560
+ } else {
1561
+ vec ! [ ]
1562
+ } ;
1578
1563
1579
1564
let selection = if self . parse_keyword ( "WHERE" ) {
1580
1565
Some ( self . parse_expr ( ) ?)
@@ -1812,16 +1797,7 @@ impl Parser {
1812
1797
pub fn parse_update ( & mut self ) -> Result < Statement , ParserError > {
1813
1798
let table_name = self . parse_object_name ( ) ?;
1814
1799
self . expect_keyword ( "SET" ) ?;
1815
- let mut assignments = vec ! [ ] ;
1816
- loop {
1817
- let id = self . parse_identifier ( ) ?;
1818
- self . expect_token ( & Token :: Eq ) ?;
1819
- let value = self . parse_expr ( ) ?;
1820
- assignments. push ( Assignment { id, value } ) ;
1821
- if !self . consume_token ( & Token :: Comma ) {
1822
- break ;
1823
- }
1824
- }
1800
+ let assignments = self . parse_comma_separated ( Parser :: parse_assignment) ?;
1825
1801
let selection = if self . parse_keyword ( "WHERE" ) {
1826
1802
Some ( self . parse_expr ( ) ?)
1827
1803
} else {
@@ -1834,16 +1810,17 @@ impl Parser {
1834
1810
} )
1835
1811
}
1836
1812
1813
+ /// Parse a `var = expr` assignment, used in an UPDATE statement
1814
+ pub fn parse_assignment ( & mut self ) -> Result < Assignment , ParserError > {
1815
+ let id = self . parse_identifier ( ) ?;
1816
+ self . expect_token ( & Token :: Eq ) ?;
1817
+ let value = self . parse_expr ( ) ?;
1818
+ Ok ( Assignment { id, value } )
1819
+ }
1820
+
1837
1821
/// Parse a comma-delimited list of SQL expressions
1838
1822
pub fn parse_expr_list ( & mut self ) -> Result < Vec < Expr > , ParserError > {
1839
- let mut expr_list: Vec < Expr > = vec ! [ ] ;
1840
- loop {
1841
- expr_list. push ( self . parse_expr ( ) ?) ;
1842
- if !self . consume_token ( & Token :: Comma ) {
1843
- break ;
1844
- }
1845
- }
1846
- Ok ( expr_list)
1823
+ Ok ( self . parse_comma_separated ( Parser :: parse_expr) ?)
1847
1824
}
1848
1825
1849
1826
pub fn parse_optional_args ( & mut self ) -> Result < Vec < Expr > , ParserError > {
@@ -1857,52 +1834,34 @@ impl Parser {
1857
1834
}
1858
1835
1859
1836
/// Parse a comma-delimited list of projections after SELECT
1860
- pub fn parse_select_list ( & mut self ) -> Result < Vec < SelectItem > , ParserError > {
1861
- let mut projections: Vec < SelectItem > = vec ! [ ] ;
1862
- loop {
1863
- let expr = self . parse_expr ( ) ?;
1864
- if let Expr :: Wildcard = expr {
1865
- projections. push ( SelectItem :: Wildcard ) ;
1866
- } else if let Expr :: QualifiedWildcard ( prefix) = expr {
1867
- projections. push ( SelectItem :: QualifiedWildcard ( ObjectName ( prefix) ) ) ;
1837
+ pub fn parse_select_item ( & mut self ) -> Result < SelectItem , ParserError > {
1838
+ let expr = self . parse_expr ( ) ?;
1839
+ if let Expr :: Wildcard = expr {
1840
+ Ok ( SelectItem :: Wildcard )
1841
+ } else if let Expr :: QualifiedWildcard ( prefix) = expr {
1842
+ Ok ( SelectItem :: QualifiedWildcard ( ObjectName ( prefix) ) )
1843
+ } else {
1844
+ // `expr` is a regular SQL expression and can be followed by an alias
1845
+ if let Some ( alias) = self . parse_optional_alias ( keywords:: RESERVED_FOR_COLUMN_ALIAS ) ? {
1846
+ Ok ( SelectItem :: ExprWithAlias { expr, alias } )
1868
1847
} else {
1869
- // `expr` is a regular SQL expression and can be followed by an alias
1870
- if let Some ( alias) =
1871
- self . parse_optional_alias ( keywords:: RESERVED_FOR_COLUMN_ALIAS ) ?
1872
- {
1873
- projections. push ( SelectItem :: ExprWithAlias { expr, alias } ) ;
1874
- } else {
1875
- projections. push ( SelectItem :: UnnamedExpr ( expr) ) ;
1876
- }
1877
- }
1878
-
1879
- if !self . consume_token ( & Token :: Comma ) {
1880
- break ;
1848
+ Ok ( SelectItem :: UnnamedExpr ( expr) )
1881
1849
}
1882
1850
}
1883
- Ok ( projections)
1884
1851
}
1885
1852
1886
- /// Parse a comma-delimited list of ORDER BY expressions
1887
- pub fn parse_order_by_expr_list ( & mut self ) -> Result < Vec < OrderByExpr > , ParserError > {
1888
- let mut expr_list: Vec < OrderByExpr > = vec ! [ ] ;
1889
- loop {
1890
- let expr = self . parse_expr ( ) ?;
1891
-
1892
- let asc = if self . parse_keyword ( "ASC" ) {
1893
- Some ( true )
1894
- } else if self . parse_keyword ( "DESC" ) {
1895
- Some ( false )
1896
- } else {
1897
- None
1898
- } ;
1853
+ /// Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)
1854
+ pub fn parse_order_by_expr ( & mut self ) -> Result < OrderByExpr , ParserError > {
1855
+ let expr = self . parse_expr ( ) ?;
1899
1856
1900
- expr_list. push ( OrderByExpr { expr, asc } ) ;
1901
- if !self . consume_token ( & Token :: Comma ) {
1902
- break ;
1903
- }
1904
- }
1905
- Ok ( expr_list)
1857
+ let asc = if self . parse_keyword ( "ASC" ) {
1858
+ Some ( true )
1859
+ } else if self . parse_keyword ( "DESC" ) {
1860
+ Some ( false )
1861
+ } else {
1862
+ None
1863
+ } ;
1864
+ Ok ( OrderByExpr { expr, asc } )
1906
1865
}
1907
1866
1908
1867
/// Parse a LIMIT clause
@@ -1950,15 +1909,12 @@ impl Parser {
1950
1909
}
1951
1910
1952
1911
pub fn parse_values ( & mut self ) -> Result < Values , ParserError > {
1953
- let mut values = vec ! [ ] ;
1954
- loop {
1955
- self . expect_token ( & Token :: LParen ) ?;
1956
- values. push ( self . parse_expr_list ( ) ?) ;
1957
- self . expect_token ( & Token :: RParen ) ?;
1958
- if !self . consume_token ( & Token :: Comma ) {
1959
- break ;
1960
- }
1961
- }
1912
+ let values = self . parse_comma_separated ( |parser| {
1913
+ parser. expect_token ( & Token :: LParen ) ?;
1914
+ let e = parser. parse_expr_list ( ) ?;
1915
+ parser. expect_token ( & Token :: RParen ) ?;
1916
+ Ok ( e)
1917
+ } ) ?;
1962
1918
Ok ( Values ( values) )
1963
1919
}
1964
1920
0 commit comments