PostgreSQL: Parse NULLS [NOT] DISTINCT on column UNIQUE constraints

src/ast/ddl.rs

@@ -1978,7 +1978,7 @@ pub enum ColumnOption {
 
     /// `PRIMARY KEY [<constraint_characteristics>]`
     PrimaryKey(PrimaryKeyConstraint),
-    /// `UNIQUE [<constraint_characteristics>]`
+    /// `UNIQUE [NULLS [NOT] DISTINCT] [<constraint_characteristics>]`
     Unique(UniqueConstraint),
     /// A referential integrity constraint (`REFERENCES <foreign_table> (<referred_columns>)
     /// [ MATCH { FULL | PARTIAL | SIMPLE } ]
@@ -2113,7 +2113,11 @@ impl fmt::Display for ColumnOption {
                 Ok(())
             }
             Unique(constraint) => {
-                write!(f, "UNIQUE{:>}", constraint.index_type_display)?;
+                write!(
+                    f,
+                    "UNIQUE{:>}{}",
+                    constraint.index_type_display, constraint.nulls_distinct
+                )?;
                 if let Some(characteristics) = &constraint.characteristics {
                     write!(f, " {characteristics}")?;
                 }

src/parser/mod.rs

@@ -10129,6 +10129,7 @@ impl<'a> Parser<'a> {
                 } else {
                     KeyOrIndexDisplay::None
                 };
+            let nulls_distinct = self.parse_optional_nulls_distinct()?;
             let characteristics = self.parse_constraint_characteristics()?;
             Ok(Some(
                 UniqueConstraint {
@@ -10140,7 +10141,7 @@ impl<'a> Parser<'a> {
                     include: vec![],
                     index_options: vec![],
                     characteristics,
-                    nulls_distinct: NullsDistinctOption::None,
+                    nulls_distinct,
                 }
                 .into(),
             ))

tests/sqlparser_postgres.rs

@@ -11057,3 +11057,61 @@ fn parse_role_signed_connection_limit() {
         "sql parser error: Expected: option, found: CONNECTION"
     );
 }
+
+#[test]
+fn parse_create_table_column_unique_nulls_distinct() {
+    let Statement::CreateTable(CreateTable { columns, .. }) = pg_and_generic().verified_stmt(
+        "CREATE TABLE t (u INT UNIQUE NULLS NOT DISTINCT, v INT UNIQUE NULLS DISTINCT, w INT UNIQUE)",
+    ) else {
+        panic!("Expected CREATE TABLE");
+    };
+    let nulls_distinct: Vec<_> = columns
+        .iter()
+        .map(|column| match &column.options[..] {
+            [ColumnOptionDef {
+                option: ColumnOption::Unique(constraint),
+                ..
+            }] => &constraint.nulls_distinct,
+            options => panic!("Expected one UNIQUE option, got {options:?}"),
+        })
+        .collect();
+    assert_eq!(
+        nulls_distinct,
+        vec![
+            &NullsDistinctOption::NotDistinct,
+            &NullsDistinctOption::Distinct,
+            &NullsDistinctOption::None,
+        ]
+    );
+
+    pg_and_generic().verified_stmt(
+        "CREATE TABLE t (u INT CONSTRAINT k UNIQUE NULLS NOT DISTINCT DEFERRABLE NOT NULL)",
+    );
+
+    assert_eq!(
+        pg_and_generic()
+            .parse_sql_statements("CREATE TABLE t (u INT UNIQUE NULLS NOT)")
+            .unwrap_err(),
+        ParserError::ParserError("Expected: DISTINCT, found: )".to_string())
+    );
+}
+
+#[test]
+fn display_column_unique_nulls_distinct_propagates_formatter_errors() {
+    use core::fmt::{self, Write};
+
+    struct RejectingWriter;
+
+    impl Write for RejectingWriter {
+        fn write_str(&mut self, value: &str) -> fmt::Result {
+            if value.contains("NULLS") {
+                Err(fmt::Error)
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    let stmt = pg_and_generic().verified_stmt("CREATE TABLE t (u INT UNIQUE NULLS NOT DISTINCT)");
+    assert_eq!(write!(RejectingWriter, "{stmt}"), Err(fmt::Error));
+}