feat(snowflake)!: support Snowflake to DuckDB transpilation of ZIPF (#6618)

* ZIP transpilation for Snowflake to DuckDB

* updated tests

* changed s and n to force constnatns

* improved parameter checking

* tweaked to fix random issue

* templated the ZIPF transpilation

* templated the ZIPF transpilation

Author: fivetran-kwoodbeck

sqlglot/dialects/duckdb.py

@@ -1646,6 +1646,67 @@ def randstr_sql(self: DuckDB.Generator, expression: exp.Randstr) -> str:
             )
             return f"({self.sql(query)})"
 
+        # Template for ZIPF transpilation - placeholders get replaced with actual parameters
+        ZIPF_TEMPLATE: t.ClassVar[exp.Expression] = exp.maybe_parse(
+            """
+            WITH rand AS (SELECT :random_expr AS r),
+            weights AS (
+                SELECT i, 1.0 / POWER(i, :s) AS w
+                FROM RANGE(1, :n + 1) AS t(i)
+            ),
+            cdf AS (
+                SELECT i, SUM(w) OVER (ORDER BY i) / SUM(w) OVER () AS p
+                FROM weights
+            )
+            SELECT MIN(i)
+            FROM cdf
+            WHERE p >= (SELECT r FROM rand)
+            """
+        )
+
+        def zipf_sql(self: DuckDB.Generator, expression: exp.Zipf) -> str:
+            """
+            Transpile Snowflake's ZIPF to DuckDB using CDF-based inverse sampling.
+            Uses a pre-parsed template with placeholders replaced by expression nodes.
+            """
+            s = expression.this
+            n = expression.args.get("elementcount")
+            gen = expression.args.get("gen")
+
+            random_expr: exp.Expression
+            if isinstance(gen, exp.Rand):
+                # Use RANDOM() for non-deterministic output
+                random_expr = exp.Rand()
+            elif gen:
+                # (ABS(HASH(seed)) % 1000000) / 1000000.0
+                random_expr = exp.Div(
+                    this=exp.Paren(
+                        this=exp.Mod(
+                            this=exp.Abs(this=exp.Anonymous(this="HASH", expressions=[gen.copy()])),
+                            expression=exp.Literal.number(1000000),
+                        )
+                    ),
+                    expression=exp.Literal.number(1000000.0),
+                )
+            else:
+                random_expr = exp.Rand()
+
+            # s, n are required args per Zipf.arg_types
+            assert s is not None and n is not None
+            replacements: dict[str, exp.Expression] = {
+                "s": s,
+                "n": n,
+                "random_expr": random_expr,
+            }
+
+            def replace_placeholder(node: exp.Expression) -> exp.Expression:
+                if isinstance(node, exp.Placeholder) and node.name in replacements:
+                    return replacements[node.name].copy()
+                return node
+
+            query = self.ZIPF_TEMPLATE.copy().transform(replace_placeholder)
+            return f"({self.sql(query)})"
+
         def tobinary_sql(self: DuckDB.Generator, expression: exp.ToBinary) -> str:
             """
             TO_BINARY(value, format) transpilation if the return type is BINARY:

tests/dialects/test_snowflake.py

@@ -279,8 +279,22 @@ def test_snowflake(self):
             },
         )
 
-        self.validate_identity("SELECT ZIPF(1, 10, RANDOM())")
-        self.validate_identity("SELECT ZIPF(2, 100, 1234)")
+        self.validate_all(
+            "SELECT ZIPF(1, 10, 1234)",
+            write={
+                "duckdb": "SELECT (WITH rand AS (SELECT (ABS(HASH(1234)) % 1000000) / 1000000.0 AS r), weights AS (SELECT i, 1.0 / POWER(i, 1) AS w FROM RANGE(1, 10 + 1) AS t(i)), cdf AS (SELECT i, SUM(w) OVER (ORDER BY i NULLS FIRST) / SUM(w) OVER () AS p FROM weights) SELECT MIN(i) FROM cdf WHERE p >= (SELECT r FROM rand))",
+                "snowflake": "SELECT ZIPF(1, 10, 1234)",
+            },
+        )
+
+        self.validate_all(
+            "SELECT ZIPF(2, 100, RANDOM())",
+            write={
+                "duckdb": "SELECT (WITH rand AS (SELECT RANDOM() AS r), weights AS (SELECT i, 1.0 / POWER(i, 2) AS w FROM RANGE(1, 100 + 1) AS t(i)), cdf AS (SELECT i, SUM(w) OVER (ORDER BY i NULLS FIRST) / SUM(w) OVER () AS p FROM weights) SELECT MIN(i) FROM cdf WHERE p >= (SELECT r FROM rand))",
+                "snowflake": "SELECT ZIPF(2, 100, RANDOM())",
+            },
+        )
+
         self.validate_identity("SELECT GROUPING_ID(a, b) AS g_id FROM x GROUP BY ROLLUP (a, b)")
         self.validate_identity("PARSE_URL('https://example.com/path')")
         self.validate_identity("PARSE_URL('https://example.com/path', 1)")