With Order Support for Memory Tables

src/ast/dml.rs

@@ -129,6 +129,9 @@ pub struct CreateTable {
     pub default_charset: Option<String>,
     pub collation: Option<String>,
     pub on_commit: Option<OnCommit>,
+    /// Datafusion "WITH ORDER" clause
+    /// <https://datafusion.apache.org/user-guide/sql/ddl.html#create-external-table/>
+    pub with_order: Vec<Vec<OrderByExpr>>,
     /// ClickHouse "ON CLUSTER" clause:
     /// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
     pub on_cluster: Option<Ident>,

src/ast/helpers/stmt_create_table.rs

@@ -10,8 +10,8 @@ use sqlparser_derive::{Visit, VisitMut};
 use super::super::dml::CreateTable;
 use crate::ast::{
     ClusteredBy, ColumnDef, CommentDef, Expr, FileFormat, HiveDistributionStyle, HiveFormat, Ident,
-    ObjectName, OnCommit, OneOrManyWithParens, Query, RowAccessPolicy, SqlOption, Statement,
-    TableConstraint, TableEngine, Tag, WrappedCollection,
+    ObjectName, OnCommit, OneOrManyWithParens, OrderByExpr, Query, RowAccessPolicy, SqlOption,
+    Statement, TableConstraint, TableEngine, Tag, WrappedCollection,
 };
 use crate::parser::ParserError;
 
@@ -75,6 +75,7 @@ pub struct CreateTableBuilder {
     pub on_commit: Option<OnCommit>,
     pub on_cluster: Option<Ident>,
     pub primary_key: Option<Box<Expr>>,
+    pub with_order: Vec<Vec<OrderByExpr>>,
     pub order_by: Option<OneOrManyWithParens<Expr>>,
     pub partition_by: Option<Box<Expr>>,
     pub cluster_by: Option<WrappedCollection<Vec<Ident>>>,
@@ -136,6 +137,7 @@ impl CreateTableBuilder {
             max_data_extension_time_in_days: None,
             default_ddl_collation: None,
             with_aggregation_policy: None,
+            with_order: vec![],
             with_row_access_policy: None,
             with_tags: None,
         }
@@ -273,6 +275,11 @@ impl CreateTableBuilder {
         self
     }
 
+    pub fn with_order(mut self, with_order: Vec<Vec<OrderByExpr>>) -> Self {
+        self.with_order = with_order;
+        self
+    }
+
     pub fn order_by(mut self, order_by: Option<OneOrManyWithParens<Expr>>) -> Self {
         self.order_by = order_by;
         self
@@ -397,6 +404,7 @@ impl CreateTableBuilder {
             max_data_extension_time_in_days: self.max_data_extension_time_in_days,
             default_ddl_collation: self.default_ddl_collation,
             with_aggregation_policy: self.with_aggregation_policy,
+            with_order: self.with_order,
             with_row_access_policy: self.with_row_access_policy,
             with_tags: self.with_tags,
         })
@@ -452,6 +460,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 max_data_extension_time_in_days,
                 default_ddl_collation,
                 with_aggregation_policy,
+                with_order,
                 with_row_access_policy,
                 with_tags,
             }) => Ok(Self {
@@ -496,6 +505,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 default_ddl_collation,
                 with_aggregation_policy,
                 with_row_access_policy,
+                with_order,
                 with_tags,
                 volatile,
             }),

src/parser/mod.rs

@@ -5589,7 +5589,23 @@ impl<'a> Parser<'a> {
         let clustered_by = self.parse_optional_clustered_by()?;
         let hive_formats = self.parse_hive_formats()?;
         // PostgreSQL supports `WITH ( options )`, before `AS`
-        let with_options = self.parse_options(Keyword::WITH)?;
+        let mut with_options: Vec<SqlOption> = vec![];
+        let mut order_exprs: Vec<Vec<OrderByExpr>> = vec![];
+        if self.parse_keyword(Keyword::WITH) {
+            if self.parse_keyword(Keyword::ORDER) {
+                self.expect_token(&Token::LParen)?;
+                loop {
+                    order_exprs.push(vec![self.parse_order_by_expr()?]);
+                    if !self.consume_token(&Token::Comma) {
+                        self.expect_token(&Token::RParen)?;
+                        break;
+                    }
+                }
+            } else {
+                with_options = self.parse_options_in_parentheses()?;
+            }
+        }
+
         let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
 
         let engine = if self.parse_keyword(Keyword::ENGINE) {
@@ -5738,6 +5754,7 @@ impl<'a> Parser<'a> {
             .cluster_by(create_table_config.cluster_by)
             .options(create_table_config.options)
             .primary_key(primary_key)
+            .with_order(order_exprs)
             .strict(strict)
             .build())
     }
@@ -6369,15 +6386,19 @@ impl<'a> Parser<'a> {
 
     pub fn parse_options(&mut self, keyword: Keyword) -> Result<Vec<SqlOption>, ParserError> {
         if self.parse_keyword(keyword) {
-            self.expect_token(&Token::LParen)?;
-            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
-            self.expect_token(&Token::RParen)?;
-            Ok(options)
+            self.parse_options_in_parentheses()
         } else {
             Ok(vec![])
         }
     }
 
+    fn parse_options_in_parentheses(&mut self) -> Result<Vec<SqlOption>, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let options = self.parse_comma_separated(Parser::parse_sql_option)?;
+        self.expect_token(&Token::RParen)?;
+        Ok(options)
+    }
+
     pub fn parse_options_with_keywords(
         &mut self,
         keywords: &[Keyword],
@@ -12364,6 +12385,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parse_create_table_with_order() {
+        let sql = "CREATE TABLE test (foo INT, bar VARCHAR(256)) WITH ORDER (foo ASC)";
+        let ast = Parser::parse_sql(&GenericDialect {}, sql).unwrap();
+        match ast[0].clone() {
+            Statement::CreateTable(CreateTable { with_order, .. }) => {
+                assert_eq!(
+                    with_order,
+                    vec![vec![OrderByExpr {
+                        expr: Expr::Identifier(Ident::from("foo")),
+                        asc: Some(true),
+                        nulls_first: None,
+                        with_fill: None,
+                    }]]
+                );
+            }
+            _ => unreachable!(),
+        }
+
+        let sql = "CREATE TABLE test (foo INT, bar VARCHAR(256)) WITH ORDER (bar DESC NULLS FIRST)";
+        let ast = Parser::parse_sql(&GenericDialect {}, sql).unwrap();
+        match ast[0].clone() {
+            Statement::CreateTable(CreateTable { with_order, .. }) => {
+                assert_eq!(
+                    with_order,
+                    vec![vec![OrderByExpr {
+                        expr: Expr::Identifier(Ident::from("bar")),
+                        asc: Some(false),
+                        nulls_first: Some(true),
+                        with_fill: None,
+                    }]]
+                );
+            }
+            _ => unreachable!(),
+        }
+    }
+
     #[test]
     fn test_parse_multipart_identifier_positive() {
         let dialect = TestedDialects {

tests/sqlparser_duckdb.rs

@@ -751,6 +751,7 @@ fn test_duckdb_union_datatype() {
             max_data_extension_time_in_days: Default::default(),
             default_ddl_collation: Default::default(),
             with_aggregation_policy: Default::default(),
+            with_order: Default::default(),
             with_row_access_policy: Default::default(),
             with_tags: Default::default()
         }),

tests/sqlparser_postgres.rs

@@ -4864,6 +4864,7 @@ fn parse_trigger_related_functions() {
             with_aggregation_policy: None,
             with_row_access_policy: None,
             with_tags: None,
+            with_order: vec![],
         }
     );