fix(postgres): transpile duckdb LIST_HAS_ANY and LIST_CONTAINS (tobymao#5440)

* fix(postgres): transpile duckdb LIST_HAS_ANY and LIST_CONTAINS

* refactor arraycontains_sql

* more refactor

Author: geooo109

sqlglot/dialects/duckdb.py

@@ -416,7 +416,9 @@ class Parser(parser.Parser):
             "JSON": exp.ParseJSON.from_arg_list,
             "JSON_EXTRACT_PATH": parser.build_extract_json_with_path(exp.JSONExtract),
             "JSON_EXTRACT_STRING": parser.build_extract_json_with_path(exp.JSONExtractScalar),
+            "LIST_CONTAINS": exp.ArrayContains.from_arg_list,
             "LIST_HAS": exp.ArrayContains.from_arg_list,
+            "LIST_HAS_ANY": exp.ArrayOverlaps.from_arg_list,
             "LIST_REVERSE_SORT": _build_sort_array_desc,
             "LIST_SORT": exp.SortArray.from_arg_list,
             "LIST_VALUE": lambda args: exp.Array(expressions=args),

sqlglot/dialects/postgres.py

@@ -818,3 +818,29 @@ def interval_sql(self, expression: exp.Interval) -> str:
         def placeholder_sql(self, expression: exp.Placeholder) -> str:
             this = f"({expression.name})" if expression.this else ""
             return f"{self.NAMED_PLACEHOLDER_TOKEN}{this}s"
+
+        def arraycontains_sql(self, expression: exp.ArrayContains) -> str:
+            # Convert DuckDB's LIST_CONTAINS(array, value) to PostgreSQL
+            # DuckDB behavior:
+            #   - LIST_CONTAINS([1,2,3], 2) -> true
+            #   - LIST_CONTAINS([1,2,3], 4) -> false
+            #   - LIST_CONTAINS([1,2,NULL], 4) -> false (not NULL)
+            #   - LIST_CONTAINS([1,2,3], NULL) -> NULL
+            #
+            # PostgreSQL equivalent: CASE WHEN value IS NULL THEN NULL
+            #                            ELSE COALESCE(value = ANY(array), FALSE) END
+            value = expression.expression
+            array = expression.this
+
+            coalesce_expr = exp.Coalesce(
+                this=value.eq(exp.Any(this=exp.paren(expression=array, copy=False))),
+                expressions=[exp.false()],
+            )
+
+            case_expr = (
+                exp.Case()
+                .when(exp.Is(this=value, expression=exp.null()), exp.null(), copy=False)
+                .else_(coalesce_expr, copy=False)
+            )
+
+            return self.sql(case_expr)

tests/dialects/test_duckdb.py

@@ -978,6 +978,28 @@ def test_duckdb(self):
         self.validate_identity("SELECT #2, #1 FROM (VALUES (1, 'foo'))")
         self.validate_identity("SELECT #2 AS a, #1 AS b FROM (VALUES (1, 'foo'))")
 
+        self.validate_all(
+            "LIST_CONTAINS([1, 2, NULL], 1)",
+            write={
+                "duckdb": "ARRAY_CONTAINS([1, 2, NULL], 1)",
+                "postgres": "CASE WHEN 1 IS NULL THEN NULL ELSE COALESCE(1 = ANY(ARRAY[1, 2, NULL]), FALSE) END",
+            },
+        )
+        self.validate_all(
+            "LIST_CONTAINS([1, 2, NULL], NULL)",
+            write={
+                "duckdb": "ARRAY_CONTAINS([1, 2, NULL], NULL)",
+                "postgres": "CASE WHEN NULL IS NULL THEN NULL ELSE COALESCE(NULL = ANY(ARRAY[1, 2, NULL]), FALSE) END",
+            },
+        )
+        self.validate_all(
+            "LIST_HAS_ANY([1, 2, 3], [1,2])",
+            write={
+                "duckdb": "[1, 2, 3] && [1, 2]",
+                "postgres": "ARRAY[1, 2, 3] && ARRAY[1, 2]",
+            },
+        )
+
     def test_array_index(self):
         with self.assertLogs(helper_logger) as cm:
             self.validate_all(