feat(optimizer): replace date funcs (#2299)

* feat(optimizer): replace date funcs

* fixup

sqlglot/expressions.py

@@ -5947,7 +5947,10 @@ def cast(expression: ExpOrStr, to: str | DataType | DataType.Type, **opts) -> Ca
         The new Cast instance.
     """
     expression = maybe_parse(expression, **opts)
-    return Cast(this=expression, to=DataType.build(to, **opts))
+    data_type = DataType.build(to, **opts)
+    expression = Cast(this=expression, to=data_type)
+    expression.type = data_type
+    return expression
 
 
 def table_(

sqlglot/optimizer/annotate_types.py

@@ -158,6 +158,7 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
             exp.TimeAdd,
             exp.TimeStrToTime,
             exp.TimeSub,
+            exp.Timestamp,
             exp.TimestampAdd,
             exp.TimestampSub,
             exp.UnixToTime,

sqlglot/optimizer/canonicalize.py

@@ -17,6 +17,7 @@ def canonicalize(expression: exp.Expression) -> exp.Expression:
     exp.replace_children(expression, canonicalize)
 
     expression = add_text_to_concat(expression)
+    expression = replace_date_funcs(expression)
     expression = coerce_type(expression)
     expression = remove_redundant_casts(expression)
     expression = ensure_bool_predicates(expression)
@@ -31,6 +32,14 @@ def add_text_to_concat(node: exp.Expression) -> exp.Expression:
     return node
 
 
+def replace_date_funcs(node: exp.Expression) -> exp.Expression:
+    if isinstance(node, exp.Date) and not node.expressions and not node.args.get("zone"):
+        return exp.cast(node.this, to=exp.DataType.Type.DATE)
+    if isinstance(node, exp.Timestamp) and not node.expression:
+        return exp.cast(node.this, to=exp.DataType.Type.TIMESTAMP)
+    return node
+
+
 def coerce_type(node: exp.Expression) -> exp.Expression:
     if isinstance(node, exp.Binary):
         _coerce_date(node.left, node.right)
@@ -84,10 +93,7 @@ def _coerce_date(a: exp.Expression, b: exp.Expression) -> None:
 
 
 def _replace_cast(node: exp.Expression, to: str) -> None:
-    data_type = exp.DataType.build(to)
-    cast = exp.Cast(this=node.copy(), to=data_type)
-    cast.type = data_type
-    node.replace(cast)
+    node.replace(exp.cast(node.copy(), to=to))
 
 
 def _replace_int_predicate(expression: exp.Expression) -> None:

tests/fixtures/optimizer/canonicalize.sql

@@ -28,3 +28,15 @@ SELECT "x"."a" AS "a" FROM "x" AS "x" GROUP BY "x"."a" HAVING SUM("x"."b") <> 0
 
 SELECT a FROM x WHERE 1;
 SELECT "x"."a" AS "a" FROM "x" AS "x" WHERE 1 <> 0;
+
+--------------------------------------
+-- Replace date functions
+--------------------------------------
+DATE('2023-01-01');
+CAST('2023-01-01' AS DATE);
+
+TIMESTAMP('2023-01-01');
+CAST('2023-01-01' AS TIMESTAMP);
+
+TIMESTAMP('2023-01-01', '12:00:00');
+TIMESTAMP('2023-01-01', '12:00:00');