Fix(redshift): do not inherit postgres ROUND generator closes #6340

Author: georgesittas

sqlglot/dialects/postgres.py

@@ -268,6 +268,29 @@ def _versioned_anyvalue_sql(self: Postgres.Generator, expression: exp.AnyValue)
     return rename_func("ANY_VALUE")(self, expression)
 
 
+def _round_sql(self: Postgres.Generator, expression: exp.Round) -> str:
+    this = self.sql(expression, "this")
+    decimals = self.sql(expression, "decimals")
+
+    if not decimals:
+        return self.func("ROUND", this)
+
+    if not expression.type:
+        from sqlglot.optimizer.annotate_types import annotate_types
+
+        expression = annotate_types(expression, dialect=self.dialect)
+
+    # ROUND(double precision, integer) is not permitted in Postgres
+    # so it's necessary to cast to decimal before rounding.
+    if expression.this.is_type(exp.DataType.Type.DOUBLE):
+        decimal_type = exp.DataType.build(
+            exp.DataType.Type.DECIMAL, expressions=expression.expressions
+        )
+        this = self.sql(exp.Cast(this=this, to=decimal_type))
+
+    return self.func("ROUND", this, decimals)
+
+
 class Postgres(Dialect):
     INDEX_OFFSET = 1
     TYPED_DIVISION = True
@@ -663,6 +686,7 @@ class Generator(generator.Generator):
                 e.args.get("occurrence"),
                 regexp_replace_global_modifier(e),
             ),
+            exp.Round: _round_sql,
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_semi_and_anti_joins,
@@ -710,28 +734,6 @@ class Generator(generator.Generator):
             exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
         }
 
-        def round_sql(self, expression: exp.Round) -> str:
-            this = self.sql(expression, "this")
-            decimals = self.sql(expression, "decimals")
-
-            if not decimals:
-                return self.func("ROUND", this)
-
-            if not expression.type:
-                from sqlglot.optimizer.annotate_types import annotate_types
-
-                expression = annotate_types(expression, dialect=self.dialect)
-
-            # ROUND(double precision, integer) is not permitted in Postgres
-            # so it's necessary to cast to decimal before rounding.
-            if expression.this.is_type(exp.DataType.Type.DOUBLE):
-                decimal_type = exp.DataType.build(
-                    exp.DataType.Type.DECIMAL, expressions=expression.expressions
-                )
-                this = self.sql(exp.Cast(this=this, to=decimal_type))
-
-            return self.func("ROUND", this, decimals)
-
         def schemacommentproperty_sql(self, expression: exp.SchemaCommentProperty) -> str:
             self.unsupported("Table comments are not supported in the CREATE statement")
             return ""

sqlglot/dialects/redshift.py

@@ -231,6 +231,9 @@ class Generator(Postgres.Generator):
         TRANSFORMS.pop(exp.LastDay)
         TRANSFORMS.pop(exp.SHA2)
 
+        # Postgres does not permit a double precision argument in ROUND; Redshift does
+        TRANSFORMS.pop(exp.Round)
+
         RESERVED_KEYWORDS = {
             "aes128",
             "aes256",

tests/dialects/test_redshift.py

@@ -7,6 +7,9 @@ class TestRedshift(Validator):
 
     def test_redshift(self):
         self.validate_identity("SELECT COSH(1.5)")
+        self.validate_identity(
+            "ROUND(CAST(a AS DOUBLE PRECISION) / CAST(b AS DOUBLE PRECISION), 2)"
+        )
         self.validate_all(
             "SELECT SPLIT_TO_ARRAY('12,345,6789')",
             write={