Adding additional relational simplification patterns for datetime comparisons (#405)

Patterns include:
- Switch comparisons between `QUARTER(x)` and a literal use `MONTH(x)` instead, e.g. `QUARTER(x) == 2` becomes `ISIN(MONTH(x), [4, 5, 6])`
- Having patterns such as `MONTH(x) < 0` return False and `HOUR(x) <= 60` return True
- Simplify `DATETIME(DATETIME(u, v, w), x, y, z)` -> `DATETIME(u, v, w, x, y, z)`
- Simplify a chain of `DATETIME` information on a literal to produce the final literal (e.g. `DATETIME('2024-13-05', '+25 days', 'start of month')` -> `'2024-02-01`)
- Simplify datetime part extraction on literals, e.g. `YEAR('2023-01-01')` ->` 2023`
- Infer that a column `x` is non-null if it is used in a filter / join condition (for an inner/semi join) where the condition would be false if `x` were NULL
- Simplify more functions to a NULL literal if any of their arguments are a NULL literal.

Author: knassre-bodo

pydough/conversion/filter_pushdown.py

@@ -6,6 +6,7 @@
 
 
 import pydough.pydough_operators as pydop
+from pydough.configs import PyDoughConfigs
 from pydough.relational import (
     Aggregate,
     CallExpression,
@@ -65,7 +66,7 @@ class FilterPushdownShuttle(RelationalShuttle):
     cannot be pushed further.
     """
 
-    def __init__(self):
+    def __init__(self, configs: PyDoughConfigs):
         # The set of filters that are currently being pushed down. When
         # visit_xxx is called, it is presumed that the set of conditions in
         # self.filters are the conditions that can be pushed down as far as the
@@ -75,7 +76,7 @@ def __init__(self):
         # simplification logic to aid in advanced filter predicate inference,
         # such as determining that a left join is redundant because if the RHS
         # column is null then the filter will always be false.
-        self.simplifier: SimplificationShuttle = SimplificationShuttle()
+        self.simplifier: SimplificationShuttle = SimplificationShuttle(configs)
 
     def reset(self):
         self.filters = set()
@@ -299,18 +300,19 @@ def visit_empty_singleton(self, empty_singleton: EmptySingleton) -> RelationalNo
         return self.flush_remaining_filters(empty_singleton, self.filters, set())
 
 
-def push_filters(node: RelationalNode) -> RelationalNode:
+def push_filters(node: RelationalNode, configs: PyDoughConfigs) -> RelationalNode:
     """
     Transpose filter conditions down as far as possible.
 
     Args:
         `node`: The current node of the relational tree.
+        `configs`: The PyDough configuration settings.
 
     Returns:
         The transformed version of `node` and all of its descendants with
         filters pushed down as far as possible, either materializing them above
         the node or into one of its inputs, or possibly both if there are
         multiple filters.
     """
-    pusher: FilterPushdownShuttle = FilterPushdownShuttle()
+    pusher: FilterPushdownShuttle = FilterPushdownShuttle(configs)
     return node.accept_shuttle(pusher)

pydough/conversion/relational_converter.py

@@ -1451,7 +1451,7 @@ def optimize_relational_tree(
     root = ColumnPruner().prune_unused_columns(root)
 
     # Step 1: push filters down as far as possible
-    root = confirm_root(push_filters(root))
+    root = confirm_root(push_filters(root, configs))
 
     # Step 2: merge adjacent projections, unless it would result in excessive
     # duplicate subexpression computations.
@@ -1492,8 +1492,8 @@ def optimize_relational_tree(
     # pullup and pushdown and so on.
     for _ in range(2):
         root = confirm_root(pullup_projections(root))
-        simplify_expressions(root, additional_shuttles)
-        root = confirm_root(push_filters(root))
+        simplify_expressions(root, configs, additional_shuttles)
+        root = confirm_root(push_filters(root, configs))
         root = ColumnPruner().prune_unused_columns(root)
 
     # Step 9: re-run projection merging, without pushing into joins. This