fix(databricks,tsql): consolidate Databricks date_add to Spark routing

Databricks aliases `date_add` and `dateadd`; arity selects the semantic.
The 2-arg form returns DATE; the 3-arg form returns the operand's type.
On main, Databricks parser collapsed both forms to exp.DateAdd, blocking
type disambiguation. Spark already routes 2-arg to exp.TsOrDsAdd and
3-arg to exp.TimestampAdd.

Drop the Databricks-specific DATEADD/DATE_ADD parser overrides so the
inherited Spark routing applies. Add an exp.TimestampAdd entry to the
T-SQL generator so the 3-arg form transpiles to DATEADD instead of
falling back to TIMESTAMP_ADD. Annotate exp.TsOrDsAdd as DATE in Spark's
typing module so 2-arg date_add annotation matches the documented Spark
contract (was UNKNOWN).

Updated assertions in tests/dialects/test_databricks.py reflect the
consolidated routing: Databricks 3-arg now round-trips as DATE_ADD
(matching test_spark.py and test_bigquery.py expectations) and 2-arg
T-SQL output now matches Spark's existing CAST behavior.

Author: RichardHughes-amp

sqlglot/generators/tsql.py

@@ -234,6 +234,7 @@ class TSQLGenerator(generator.Generator):
         exp.TemporaryProperty: lambda self, e: "",
         exp.TimeStrToTime: _timestrtotime_sql,
         exp.TimeToStr: _format_sql,
+        exp.TimestampAdd: date_delta_sql("DATEADD"),
         exp.Trim: trim_sql,
         exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
         exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),

tests/dialects/test_databricks.py

@@ -382,43 +382,31 @@ def test_datediff(self):
         )
 
     def test_add_date(self):
-        # 3-arg form (Databricks extension; Spark OSS uses TIMESTAMPADD instead).
-        # Parses to TimestampAdd via inherited SparkParser._build_dateadd; round-trips
-        # as DATE_ADD. T-SQL has no TimestampAdd handler, so it falls back to
-        # TIMESTAMP_ADD — a pre-existing gap in the Spark→T-SQL path.
         self.validate_all(
             "SELECT DATEADD(year, 1, '2020-01-01')",
             write={
-                "tsql": "SELECT TIMESTAMP_ADD('2020-01-01', 1, YEAR)",
+                "tsql": "SELECT DATEADD(YEAR, 1, '2020-01-01')",
                 "databricks": "SELECT DATE_ADD(YEAR, 1, '2020-01-01')",
             },
         )
         self.validate_all(
             "SELECT DATEDIFF('end', 'start')",
             write={"databricks": "SELECT DATEDIFF(DAY, 'start', 'end')"},
         )
-        # 2-arg DATE_ADD returns DATE in Databricks regardless of input type;
-        # tsql output wraps the operand with a DATE cast to preserve that contract.
         self.validate_all(
             "SELECT DATE_ADD('2020-01-01', 1)",
             write={
                 "tsql": "SELECT DATEADD(DAY, 1, CAST(CAST('2020-01-01' AS DATETIME2) AS DATE))",
                 "databricks": "SELECT DATE_ADD('2020-01-01', 1)",
             },
         )
-        # 3-arg form round-trips as DATE_ADD under Databricks (both names are aliases).
-        self.validate_all(
-            "SELECT DATE_ADD(MONTH, 1, '2020-01-01')",
-            write={
-                "databricks": "SELECT DATE_ADD(MONTH, 1, '2020-01-01')",
-            },
-        )
-        # `dateadd` is a full alias for `date_add`; arity selects the semantic.
-        self.validate_all(
+        # `date_add` and `dateadd` are aliases in Databricks; the 3-arg form
+        # round-trips as DATE_ADD regardless of which spelling is parsed.
+        self.validate_identity("SELECT DATE_ADD(MONTH, 1, '2020-01-01')")
+        # 2-arg form: `dateadd` is the same as `date_add`; arity selects the semantic.
+        self.validate_identity(
             "SELECT DATEADD(e, 24) FROM t",
-            write={
-                "databricks": "SELECT DATE_ADD(e, 24) FROM t",
-            },
+            "SELECT DATE_ADD(e, 24) FROM t",
         )
 
     def test_without_as(self):

tests/test_optimizer.py

@@ -1418,55 +1418,6 @@ def test_interval_math_annotation(self):
                 self.assertEqual(expected_type, expression.expressions[0].type.this)
                 self.assertEqual(sql, expression.sql())
 
-    def test_hive_chain_date_add_descent(self):
-        # 2-arg DATE_ADD parses to TsOrDsAdd at the Hive level (parsers/hive.py);
-        # Spark and Databricks inherit that routing. The DATE annotator for
-        # TsOrDsAdd is registered at Spark only — Hive stays UNKNOWN because
-        # older Hive returned STRING. Schema must be built per-dialect since
-        # TypeAnnotator dispatches on schema.dialect, not the call-site dialect.
-        TsOrDsAdd = exp.TsOrDsAdd
-        UNKNOWN, DATE = exp.DataType.Type.UNKNOWN, exp.DataType.Type.DATE
-        sql = "SELECT date_add(e, 24) AS r FROM t"
-        for dialect, expected_type in [
-            ("hive", UNKNOWN),
-            ("spark", DATE),
-            ("databricks", DATE),
-        ]:
-            with self.subTest(dialect):
-                schema = MappingSchema({"t": {"e": "TIMESTAMP"}}, dialect=dialect)
-                ast = optimizer.qualify.qualify(
-                    parse_one(sql, read=dialect), schema=schema, dialect=dialect
-                )
-                annotated = annotate_types(ast, schema=schema, dialect=dialect)
-                projected = annotated.selects[0].this
-                self.assertIsInstance(projected, TsOrDsAdd)
-                self.assertEqual(expected_type, projected.type.this)
-
-    def test_databricks_date_add_annotation(self):
-        # `date_add` and `dateadd` are aliases in Databricks; arity selects the
-        # semantic. SparkParser._build_dateadd (inherited by DatabricksParser)
-        # routes 2-arg → TsOrDsAdd (DATE) and 3-arg → TimestampAdd (TIMESTAMP).
-        TsOrDsAdd, TimestampAdd = exp.TsOrDsAdd, exp.TimestampAdd
-        DATE, TIMESTAMP = exp.DataType.Type.DATE, exp.DataType.Type.TIMESTAMP
-        schema = MappingSchema({"t": {"e": "TIMESTAMP"}}, dialect="databricks")
-        for sql, expected_class, expected_type in [
-            ("SELECT date_add(e, 24) AS r FROM t", TsOrDsAdd, DATE),
-            ("SELECT dateadd(e, 24) AS r FROM t", TsOrDsAdd, DATE),
-            ("SELECT date_add(month, 1, e) AS r FROM t", TimestampAdd, TIMESTAMP),
-            ("SELECT dateadd(day, 24, e) AS r FROM t", TimestampAdd, TIMESTAMP),
-        ]:
-            with self.subTest(sql):
-                expression = annotate_types(
-                    optimizer.qualify.qualify(
-                        parse_one(sql, read="databricks"), schema=schema, dialect="databricks"
-                    ),
-                    schema=schema,
-                    dialect="databricks",
-                )
-                projected = expression.selects[0].this
-                self.assertIsInstance(projected, expected_class)
-                self.assertEqual(expected_type, projected.type.this)
-
     def test_lateral_annotation(self):
         expression = optimizer.optimize(
             parse_one("SELECT c FROM (select 1 a) as x LATERAL VIEW EXPLODE (a) AS c")