Merge branch 'main' into feature/2078-add-pgsql-reset-support

Author: watford-ep

src/ast/data_type.rs

@@ -375,7 +375,7 @@ pub enum DataType {
     /// Databricks timestamp without time zone. See [1].
     ///
     /// [1]: https://docs.databricks.com/aws/en/sql/language-manual/data-types/timestamp-ntz-type
-    TimestampNtz,
+    TimestampNtz(Option<u64>),
     /// Interval type.
     Interval {
         /// [PostgreSQL] fields specification like `INTERVAL YEAR TO MONTH`.
@@ -676,7 +676,9 @@ impl fmt::Display for DataType {
             DataType::Timestamp(precision, timezone_info) => {
                 format_datetime_precision_and_tz(f, "TIMESTAMP", precision, timezone_info)
             }
-            DataType::TimestampNtz => write!(f, "TIMESTAMP_NTZ"),
+            DataType::TimestampNtz(precision) => {
+                format_type_with_optional_length(f, "TIMESTAMP_NTZ", precision, false)
+            }
             DataType::Datetime64(precision, timezone) => {
                 format_clickhouse_datetime_precision_and_timezone(
                     f,

src/ast/operator.rs

@@ -33,35 +33,35 @@ use super::display_separated;
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum UnaryOperator {
+    /// `@-@` Length or circumference (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    AtDashAt,
+    /// Unary logical not operator: e.g. `! false` (Hive-specific)
+    BangNot,
+    /// Bitwise Not, e.g. `~9`
+    BitwiseNot,
+    /// `@@` Center (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    DoubleAt,
+    /// `#` Number of points in path or polygon (PostgreSQL/Redshift geometric operator)
+    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
+    Hash,
     /// Plus, e.g. `+9`
     Plus,
     /// Minus, e.g. `-9`
     Minus,
     /// Not, e.g. `NOT(true)`
     Not,
-    /// Bitwise Not, e.g. `~9` (PostgreSQL-specific)
-    PGBitwiseNot,
-    /// Square root, e.g. `|/9` (PostgreSQL-specific)
-    PGSquareRoot,
+    /// Absolute value, e.g. `@ -9` (PostgreSQL-specific)
+    PGAbs,
     /// Cube root, e.g. `||/27` (PostgreSQL-specific)
     PGCubeRoot,
     /// Factorial, e.g. `9!` (PostgreSQL-specific)
     PGPostfixFactorial,
     /// Factorial, e.g. `!!9` (PostgreSQL-specific)
     PGPrefixFactorial,
-    /// Absolute value, e.g. `@ -9` (PostgreSQL-specific)
-    PGAbs,
-    /// Unary logical not operator: e.g. `! false` (Hive-specific)
-    BangNot,
-    /// `#` Number of points in path or polygon (PostgreSQL/Redshift geometric operator)
-    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
-    Hash,
-    /// `@-@` Length or circumference (PostgreSQL/Redshift geometric operator)
-    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
-    AtDashAt,
-    /// `@@` Center (PostgreSQL/Redshift geometric operator)
-    /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
-    DoubleAt,
+    /// Square root, e.g. `|/9` (PostgreSQL-specific)
+    PGSquareRoot,
     /// `?-` Is horizontal? (PostgreSQL/Redshift geometric operator)
     /// see <https://www.postgresql.org/docs/9.5/functions-geometry.html>
     QuestionDash,
@@ -73,19 +73,19 @@ pub enum UnaryOperator {
 impl fmt::Display for UnaryOperator {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match self {
-            UnaryOperator::Plus => "+",
+            UnaryOperator::AtDashAt => "@-@",
+            UnaryOperator::BangNot => "!",
+            UnaryOperator::BitwiseNot => "~",
+            UnaryOperator::DoubleAt => "@@",
+            UnaryOperator::Hash => "#",
             UnaryOperator::Minus => "-",
             UnaryOperator::Not => "NOT",
-            UnaryOperator::PGBitwiseNot => "~",
-            UnaryOperator::PGSquareRoot => "|/",
+            UnaryOperator::PGAbs => "@",
             UnaryOperator::PGCubeRoot => "||/",
             UnaryOperator::PGPostfixFactorial => "!",
             UnaryOperator::PGPrefixFactorial => "!!",
-            UnaryOperator::PGAbs => "@",
-            UnaryOperator::BangNot => "!",
-            UnaryOperator::Hash => "#",
-            UnaryOperator::AtDashAt => "@-@",
-            UnaryOperator::DoubleAt => "@@",
+            UnaryOperator::PGSquareRoot => "|/",
+            UnaryOperator::Plus => "+",
             UnaryOperator::QuestionDash => "?-",
             UnaryOperator::QuestionPipe => "?|",
         })

src/parser/mod.rs

@@ -1634,15 +1634,13 @@ impl<'a> Parser<'a> {
             | tok @ Token::PGSquareRoot
             | tok @ Token::PGCubeRoot
             | tok @ Token::AtSign
-            | tok @ Token::Tilde
                 if dialect_is!(dialect is PostgreSqlDialect) =>
             {
                 let op = match tok {
                     Token::DoubleExclamationMark => UnaryOperator::PGPrefixFactorial,
                     Token::PGSquareRoot => UnaryOperator::PGSquareRoot,
                     Token::PGCubeRoot => UnaryOperator::PGCubeRoot,
                     Token::AtSign => UnaryOperator::PGAbs,
-                    Token::Tilde => UnaryOperator::PGBitwiseNot,
                     _ => unreachable!(),
                 };
                 Ok(Expr::UnaryOp {
@@ -1652,6 +1650,10 @@ impl<'a> Parser<'a> {
                     ),
                 })
             }
+            Token::Tilde => Ok(Expr::UnaryOp {
+                op: UnaryOperator::BitwiseNot,
+                expr: Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?),
+            }),
             tok @ Token::Sharp
             | tok @ Token::AtDashAt
             | tok @ Token::AtAt
@@ -10543,7 +10545,9 @@ impl<'a> Parser<'a> {
                     self.parse_optional_precision()?,
                     TimezoneInfo::Tz,
                 )),
-                Keyword::TIMESTAMP_NTZ => Ok(DataType::TimestampNtz),
+                Keyword::TIMESTAMP_NTZ => {
+                    Ok(DataType::TimestampNtz(self.parse_optional_precision()?))
+                }
                 Keyword::TIME => {
                     let precision = self.parse_optional_precision()?;
                     let tz = if self.parse_keyword(Keyword::WITH) {

tests/sqlparser_common.rs

@@ -17614,6 +17614,25 @@ fn test_parse_alter_user() {
     verified_stmt("ALTER USER u1 SET DEFAULT_SECONDARY_ROLES=('ALL'), PASSWORD='secret', WORKLOAD_IDENTITY=(TYPE=AWS, ARN='arn:aws:iam::123456789:r1/')");
 }
 
+#[test]
+fn parse_generic_unary_ops() {
+    let unary_ops = &[
+        ("~", UnaryOperator::BitwiseNot),
+        ("-", UnaryOperator::Minus),
+        ("+", UnaryOperator::Plus),
+    ];
+    for (str_op, op) in unary_ops {
+        let select = verified_only_select(&format!("SELECT {}expr", &str_op));
+        assert_eq!(
+            UnnamedExpr(UnaryOp {
+                op: *op,
+                expr: Box::new(Identifier(Ident::new("expr"))),
+            }),
+            select.projection[0]
+        );
+    }
+}
+
 #[test]
 fn parse_reset_statement() {
     match verified_stmt("RESET some_parameter") {

tests/sqlparser_databricks.rs

@@ -328,7 +328,7 @@ fn data_type_timestamp_ntz() {
     assert_eq!(
         databricks().verified_expr("TIMESTAMP_NTZ '2025-03-29T18:52:00'"),
         Expr::TypedString(TypedString {
-            data_type: DataType::TimestampNtz,
+            data_type: DataType::TimestampNtz(None),
             value: ValueWithSpan {
                 value: Value::SingleQuotedString("2025-03-29T18:52:00".to_owned()),
                 span: Span::empty(),
@@ -345,7 +345,7 @@ fn data_type_timestamp_ntz() {
             expr: Box::new(Expr::Nested(Box::new(Expr::Identifier(
                 "created_at".into()
             )))),
-            data_type: DataType::TimestampNtz,
+            data_type: DataType::TimestampNtz(None),
             format: None
         }
     );
@@ -357,7 +357,7 @@ fn data_type_timestamp_ntz() {
                 columns,
                 vec![ColumnDef {
                     name: "x".into(),
-                    data_type: DataType::TimestampNtz,
+                    data_type: DataType::TimestampNtz(None),
                     options: vec![],
                 }]
             );

tests/sqlparser_postgres.rs

@@ -2144,13 +2144,11 @@ fn parse_ampersand_arobase() {
 #[test]
 fn parse_pg_unary_ops() {
     let pg_unary_ops = &[
-        ("~", UnaryOperator::PGBitwiseNot),
         ("|/", UnaryOperator::PGSquareRoot),
         ("||/", UnaryOperator::PGCubeRoot),
         ("!!", UnaryOperator::PGPrefixFactorial),
         ("@", UnaryOperator::PGAbs),
     ];
-
     for (str_op, op) in pg_unary_ops {
         let select = pg().verified_only_select(&format!("SELECT {}a", &str_op));
         assert_eq!(

tests/sqlparser_snowflake.rs

@@ -4638,6 +4638,21 @@ fn test_create_database() {
     assert!(err.contains("Expected"), "Unexpected error: {err}");
 }
 
+#[test]
+fn test_timestamp_ntz_with_precision() {
+    snowflake().verified_stmt("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(1))");
+    snowflake().verified_stmt("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(9))");
+
+    let select =
+        snowflake().verified_only_select("SELECT CAST('2024-01-01 01:00:00' AS TIMESTAMP_NTZ(9))");
+    match expr_from_projection(only(&select.projection)) {
+        Expr::Cast { data_type, .. } => {
+            assert_eq!(*data_type, DataType::TimestampNtz(Some(9)));
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn test_drop_constraints() {
     snowflake().verified_stmt("ALTER TABLE tbl DROP PRIMARY KEY");