refactor(ir): rethink the relational operations

.github/renovate.json

@@ -46,7 +46,7 @@
       "addLabels": ["bigquery"]
     },
     {
-      "matchPackagePatterns": ["duckdb", "duckdb-engine"],
+      "matchPackagePatterns": ["duckdb"],
       "addLabels": ["duckdb"]
     },
     {

docs/how-to/extending/sql.qmd

@@ -177,7 +177,7 @@ with closing(con.raw_sql("CREATE TEMP TABLE my_table AS SELECT * FROM RANGE(10)"
 
 Here's an example:
 
-```{python}
+```python
 cur = con.raw_sql("CREATE TEMP TABLE t AS SELECT * FROM RANGE(10)")
 cur.close()  # <1>
 ```

ibis/backends/base/__init__.py

@@ -1216,9 +1216,9 @@ def _cached(self, expr: ir.Table):
         if (result := self._query_cache.get(op)) is None:
             self._query_cache.store(expr)
             result = self._query_cache[op]
-        return ir.CachedTable(result)
+        return ir.CachedTableExpr(result)
 
-    def _release_cached(self, expr: ir.CachedTable) -> None:
+    def _release_cached(self, expr: ir.CachedTableExpr) -> None:
         """Releases the provided cached expression.
 
         Parameters

ibis/backends/base/df/timecontext.py

@@ -267,19 +267,19 @@ def adjust_context_alias(
     return adjust_context(op.arg, scope, timecontext)
 
 
-@adjust_context.register(ops.AsOfJoin)
-def adjust_context_asof_join(
-    op: ops.AsOfJoin, scope: Scope, timecontext: TimeContext
-) -> TimeContext:
-    begin, end = timecontext
+# @adjust_context.register(ops.AsOfJoin)
+# def adjust_context_asof_join(
+#     op: ops.AsOfJoin, scope: Scope, timecontext: TimeContext
+# ) -> TimeContext:
+#     begin, end = timecontext
 
-    if op.tolerance is not None:
-        from ibis.backends.pandas.execution import execute
+#     if op.tolerance is not None:
+#         from ibis.backends.pandas.execution import execute
 
-        timedelta = execute(op.tolerance)
-        return (begin - timedelta, end)
+#         timedelta = execute(op.tolerance)
+#         return (begin - timedelta, end)
 
-    return timecontext
+#     return timecontext
 
 
 @adjust_context.register(ops.WindowFunction)

ibis/backends/base/sql/alchemy/registry.py

@@ -605,7 +605,7 @@ class array_filter(FunctionElement):
     ops.Coalesce: varargs(sa.func.coalesce),
     ops.NullIf: fixed_arity(sa.func.nullif, 2),
     ops.InValues: _in_values,
-    ops.InColumn: _in_column,
+    ops.InSubquery: _in_column,
     ops.Count: reduction(sa.func.count),
     ops.CountStar: _count_star,
     ops.CountDistinctStar: _count_distinct_star,
@@ -629,8 +629,7 @@ class array_filter(FunctionElement):
     ops.Literal: _literal,
     ops.SimpleCase: _simple_case,
     ops.SearchedCase: _searched_case,
-    ops.TableColumn: _table_column,
-    ops.TableArrayView: _table_array_view,
+    ops.Field: _table_column,
     ops.ExistsSubquery: _exists_subquery,
     # miscellaneous varargs
     ops.Least: varargs(sa.func.least),

ibis/backends/base/sql/compiler/query_builder.py

@@ -23,15 +23,15 @@
 
 
 class TableSetFormatter:
-    _join_names = {
-        ops.InnerJoin: "INNER JOIN",
-        ops.LeftJoin: "LEFT OUTER JOIN",
-        ops.RightJoin: "RIGHT OUTER JOIN",
-        ops.OuterJoin: "FULL OUTER JOIN",
-        ops.LeftAntiJoin: "LEFT ANTI JOIN",
-        ops.LeftSemiJoin: "LEFT SEMI JOIN",
-        ops.CrossJoin: "CROSS JOIN",
-    }
+    # _join_names = {
+    #     ops.InnerJoin: "INNER JOIN",
+    #     ops.LeftJoin: "LEFT OUTER JOIN",
+    #     ops.RightJoin: "RIGHT OUTER JOIN",
+    #     ops.OuterJoin: "FULL OUTER JOIN",
+    #     ops.LeftAntiJoin: "LEFT ANTI JOIN",
+    #     ops.LeftSemiJoin: "LEFT SEMI JOIN",
+    #     ops.CrossJoin: "CROSS JOIN",
+    # }
 
     def __init__(self, parent, node, indent=2):
         # `parent` is a `Select` instance, not a `TableSetFormatter`

ibis/backends/base/sql/compiler/select_builder.py

@@ -86,9 +86,9 @@ def _populate_context(self):
     def _make_table_aliases(self, node):
         ctx = self.context
 
-        if isinstance(node, ops.Join):
+        if isinstance(node, ops.JoinChain):
             for arg in node.args:
-                if isinstance(arg, ops.TableNode):
+                if isinstance(arg, ops.Relation):
                     self._make_table_aliases(arg)
         elif not ctx.is_extracted(node):
             ctx.make_alias(node)
@@ -112,7 +112,7 @@ def _collect_elements(self):
 
         if isinstance(self.op, ops.DummyTable):
             self.select_set = list(self.op.values)
-        elif isinstance(self.op, ops.TableNode):
+        elif isinstance(self.op, ops.Relation):
             self._collect(self.op, toplevel=True)
         else:
             self.select_set = [self.op]
@@ -125,7 +125,7 @@ def _collect(self, op, toplevel=False):
             f(op, toplevel=toplevel)
         elif isinstance(op, (ops.PhysicalTable, ops.SQLQueryResult)):
             self._collect_PhysicalTable(op, toplevel=toplevel)
-        elif isinstance(op, ops.Join):
+        elif isinstance(op, ops.JoinChain):
             self._collect_Join(op, toplevel=toplevel)
         elif isinstance(op, ops.WindowingTVF):
             self._collect_WindowingTVF(op, toplevel=toplevel)
@@ -140,7 +140,7 @@ def _collect_Distinct(self, op, toplevel=False):
 
     def _collect_Limit(self, op, toplevel=False):
         if toplevel:
-            if isinstance(table := op.table, ops.Limit):
+            if isinstance(table := op.parent, ops.Limit):
                 self.table_set = table
                 self.select_set = [table]
             else:
@@ -184,27 +184,18 @@ def _collect_Aggregation(self, op, toplevel=False):
 
             self._collect(op.table)
 
-    def _collect_Selection(self, op, toplevel=False):
-        table = op.table
+    def _collect_Project(self, op, toplevel=False):
+        table = op.parent
 
         if toplevel:
-            if isinstance(table, ops.Join):
+            if isinstance(table, ops.JoinChain):
                 self._collect_Join(table)
             else:
                 self._collect(table)
 
-            selections = op.selections
-            sort_keys = op.sort_keys
-            filters = op.predicates
-
-            if not selections:
-                # select *
-                selections = [table]
-
-            self.order_by = sort_keys
-            self.select_set = selections
+            selections = op.values
+            self.select_set = list(selections.values())
             self.table_set = table
-            self.filters = filters
 
     def _collect_InMemoryTable(self, node, toplevel=False):
         if toplevel:

ibis/backends/base/sql/registry/main.py

@@ -338,11 +338,10 @@ def count_star(translator, op):
     ops.IfElse: fixed_arity("if", 3),
     ops.Between: between,
     ops.InValues: binary_infix.in_values,
-    ops.InColumn: binary_infix.in_column,
+    ops.InSubquery: binary_infix.in_column,
     ops.SimpleCase: case.simple_case,
     ops.SearchedCase: case.searched_case,
-    ops.TableColumn: table_column,
-    ops.TableArrayView: table_array_view,
+    ops.Field: table_column,
     ops.DateAdd: timestamp.timestamp_op("date_add"),
     ops.DateSub: timestamp.timestamp_op("date_sub"),
     ops.DateDiff: timestamp.timestamp_op("datediff"),