Parse column constraints in any order

CREATE TABLE t (a INT NOT NULL DEFAULT 1 PRIMARY KEY) is as valid as
CREATE TABLE t (a INT DEFAULT 1 PRIMARY KEY NOT NULL).

Author: benesch

src/sqlast/ddl.rs

@@ -1,6 +1,6 @@
 //! AST types specific to CREATE/ALTER variants of `SQLStatement`
 //! (commonly referred to as Data Definition Language, or DDL)
-use super::{ASTNode, SQLIdent, SQLObjectName};
+use super::{ASTNode, SQLIdent, SQLObjectName, SQLType};
 
 /// An `ALTER TABLE` (`SQLStatement::SQLAlterTable`) operation
 #[derive(Debug, Clone, PartialEq)]
@@ -48,11 +48,6 @@ pub enum TableConstraint {
 
 impl ToString for TableConstraint {
     fn to_string(&self) -> String {
-        fn format_constraint_name(name: &Option<SQLIdent>) -> String {
-            name.as_ref()
-                .map(|name| format!("CONSTRAINT {} ", name))
-                .unwrap_or_default()
-        }
         match self {
             TableConstraint::Unique {
                 name,
@@ -84,3 +79,91 @@ impl ToString for TableConstraint {
         }
     }
 }
+
+/// SQL column definition
+#[derive(Debug, Clone, PartialEq)]
+pub struct SQLColumnDef {
+    pub name: SQLIdent,
+    pub data_type: SQLType,
+    pub constraints: Vec<ColumnConstraint>,
+}
+
+impl ToString for SQLColumnDef {
+    fn to_string(&self) -> String {
+        format!(
+            "{} {}{}",
+            self.name,
+            self.data_type.to_string(),
+            self.constraints
+                .iter()
+                .map(|c| format!(" {}", c.to_string()))
+                .collect::<Vec<_>>()
+                .join("")
+        )
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ColumnConstraint {
+    /// `NULL`
+    Null,
+    /// `NOT NULL`
+    NotNull,
+    /// `DEFAULT <restricted-expr>`
+    Default(ASTNode),
+    /// `[ CONSTRAINT <name> ] { PRIMARY KEY | UNIQUE }`
+    Unique {
+        name: Option<SQLIdent>,
+        /// Whether this is a `PRIMARY KEY` or just a `UNIQUE` constraint
+        is_primary: bool,
+    },
+    /// A referential integrity constraint (`[ CONSTRAINT <name> ] FOREIGN KEY
+    /// REFERENCES <foreign_table> (<referred_columns>)`)
+    ForeignKey {
+        name: Option<SQLIdent>,
+        foreign_table: SQLObjectName,
+        referred_columns: Vec<SQLIdent>,
+    },
+    // `[ CONSTRAINT <name> ] CHECK (<expr>)`
+    Check {
+        name: Option<SQLIdent>,
+        expr: Box<ASTNode>,
+    },
+}
+
+impl ToString for ColumnConstraint {
+    fn to_string(&self) -> String {
+        use ColumnConstraint::*;
+        match self {
+            Null => "NULL".to_string(),
+            NotNull => "NOT NULL".to_string(),
+            Default(expr) => format!("DEFAULT {}", expr.to_string()),
+            Unique { name, is_primary } => format!(
+                "{}{}",
+                format_constraint_name(name),
+                if *is_primary { "PRIMARY KEY" } else { "UNIQUE" },
+            ),
+            ForeignKey {
+                name,
+                foreign_table,
+                referred_columns,
+            } => format!(
+                "{}REFERENCES {} ({})",
+                format_constraint_name(name),
+                foreign_table.to_string(),
+                referred_columns.join(", ")
+            ),
+            Check { name, expr } => format!(
+                "{}CHECK ({})",
+                format_constraint_name(name),
+                expr.to_string()
+            ),
+        }
+    }
+}
+
+fn format_constraint_name(name: &Option<SQLIdent>) -> String {
+    name.as_ref()
+        .map(|name| format!("CONSTRAINT {} ", name))
+        .unwrap_or_default()
+}

src/sqlast/mod.rs

@@ -20,7 +20,7 @@ mod sql_operator;
 mod sqltype;
 mod value;
 
-pub use self::ddl::{AlterTableOperation, TableConstraint};
+pub use self::ddl::{AlterTableOperation, ColumnConstraint, SQLColumnDef, TableConstraint};
 pub use self::query::{
     Cte, Fetch, Join, JoinConstraint, JoinOperator, SQLOrderByExpr, SQLQuery, SQLSelect,
     SQLSelectItem, SQLSetExpr, SQLSetOperator, TableFactor,
@@ -570,36 +570,6 @@ impl ToString for SQLAssignment {
     }
 }
 
-/// SQL column definition
-#[derive(Debug, Clone, PartialEq)]
-pub struct SQLColumnDef {
-    pub name: SQLIdent,
-    pub data_type: SQLType,
-    pub is_primary: bool,
-    pub is_unique: bool,
-    pub default: Option<ASTNode>,
-    pub allow_null: bool,
-}
-
-impl ToString for SQLColumnDef {
-    fn to_string(&self) -> String {
-        let mut s = format!("{} {}", self.name, self.data_type.to_string());
-        if self.is_primary {
-            s += " PRIMARY KEY";
-        }
-        if self.is_unique {
-            s += " UNIQUE";
-        }
-        if let Some(ref default) = self.default {
-            s += &format!(" DEFAULT {}", default.to_string());
-        }
-        if !self.allow_null {
-            s += " NOT NULL";
-        }
-        s
-    }
-}
-
 /// External table's available file format
 #[derive(Debug, Clone, PartialEq)]
 pub enum FileFormat {

src/sqlparser.rs

@@ -155,29 +155,6 @@ impl Parser {
         Ok(expr)
     }
 
-    /// Parse expression for DEFAULT clause in CREATE TABLE
-    pub fn parse_default_expr(&mut self, precedence: u8) -> Result<ASTNode, ParserError> {
-        debug!("parsing expr");
-        let mut expr = self.parse_prefix()?;
-        debug!("prefix: {:?}", expr);
-        loop {
-            // stop parsing on `NULL` | `NOT NULL`
-            match self.peek_token() {
-                Some(Token::SQLWord(ref k)) if k.keyword == "NOT" || k.keyword == "NULL" => break,
-                _ => {}
-            }
-
-            let next_precedence = self.get_next_precedence()?;
-            debug!("next precedence: {:?}", next_precedence);
-            if precedence >= next_precedence {
-                break;
-            }
-
-            expr = self.parse_infix(expr, next_precedence)?;
-        }
-        Ok(expr)
-    }
-
     /// Parse an expression prefix
     pub fn parse_prefix(&mut self) -> Result<ASTNode, ParserError> {
         let tok = self
@@ -843,29 +820,18 @@ impl Parser {
             } else if let Some(Token::SQLWord(column_name)) = self.peek_token() {
                 self.next_token();
                 let data_type = self.parse_data_type()?;
-                let is_primary = self.parse_keywords(vec!["PRIMARY", "KEY"]);
-                let is_unique = self.parse_keyword("UNIQUE");
-                let default = if self.parse_keyword("DEFAULT") {
-                    let expr = self.parse_default_expr(0)?;
-                    Some(expr)
-                } else {
-                    None
-                };
-                let allow_null = if self.parse_keywords(vec!["NOT", "NULL"]) {
-                    false
-                } else {
-                    let _ = self.parse_keyword("NULL");
-                    true
-                };
-                debug!("default: {:?}", default);
+                let mut constraints = vec![];
+                loop {
+                    match self.peek_token() {
+                        None | Some(Token::Comma) | Some(Token::RParen) => break,
+                        _ => constraints.push(self.parse_column_constraint()?),
+                    }
+                }
 
                 columns.push(SQLColumnDef {
                     name: column_name.as_sql_ident(),
                     data_type,
-                    allow_null,
-                    is_primary,
-                    is_unique,
-                    default,
+                    constraints,
                 });
             } else {
                 return self.expected("column name or constraint definition", self.peek_token());
@@ -882,6 +848,58 @@ impl Parser {
         Ok((columns, constraints))
     }
 
+    pub fn parse_column_constraint(&mut self) -> Result<ColumnConstraint, ParserError> {
+        if self.parse_keywords(vec!["NOT", "NULL"]) {
+            return Ok(ColumnConstraint::NotNull);
+        } else if self.parse_keyword("NULL") {
+            return Ok(ColumnConstraint::Null);
+        } else if self.parse_keyword("DEFAULT") {
+            // We want to allow as many DEFAULT expressions as possible, but
+            // calling self.parse_expr() will choke on expressions like "DEFAULT
+            // 1 NOT NULL". Typically this would be a syntax error, as "1 NOT
+            // NULL" is not a valid SQL expression, but in this case we know
+            // that NOT NULL is part of the next column constraint. As it turns
+            // out, the only expressions that cause trouble all have precedence
+            // less than or equal to BETWEEN, so we pass BETWEEN_PREC to stop
+            // parsing on tokens with precedence less than or equal to BETWEEN.
+            // The same trick is employed by PostgreSQL [0].
+            // https://github.com/postgres/postgres/blob/56b78626c/src/backend/parser/gram.y#L13366-L13370
+            let expr = self.parse_subexpr(Self::BETWEEN_PREC)?;
+            return Ok(ColumnConstraint::Default(expr));
+        }
+
+        let name = if self.parse_keyword("CONSTRAINT") {
+            Some(self.parse_identifier()?)
+        } else {
+            None
+        };
+
+        if self.parse_keywords(vec!["PRIMARY", "KEY"]) {
+            Ok(ColumnConstraint::Unique {
+                name,
+                is_primary: true,
+            })
+        } else if self.parse_keyword("UNIQUE") {
+            Ok(ColumnConstraint::Unique {
+                name,
+                is_primary: false,
+            })
+        } else if self.parse_keyword("REFERENCES") {
+            let foreign_table = self.parse_object_name()?;
+            let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
+            Ok(ColumnConstraint::ForeignKey {
+                name,
+                foreign_table,
+                referred_columns,
+            })
+        } else {
+            parser_err!(format!(
+                "Unexpected token in column definition: {:?}",
+                self.peek_token()
+            ))
+        }
+    }
+
     pub fn parse_optional_table_constraint(
         &mut self,
     ) -> Result<Option<TableConstraint>, ParserError> {