fix(ir): ibis.parse_sql() removes where clause

ibis/expr/sql.py

@@ -125,8 +125,8 @@ def convert_join(join, catalog):
     catalog = catalog.overlay(join)
 
     left_name = join.name
+    left_table = catalog[left_name]
     for right_name, desc in join.joins.items():
-        left_table = catalog[left_name]
         right_table = catalog[right_name]
         join_kind = _join_types[desc["side"]]
 
@@ -139,11 +139,15 @@ def convert_join(join, catalog):
             else:
                 predicate &= left_key == right_key
 
-        catalog[left_name] = left_table.join(
-            right_table, predicates=predicate, how=join_kind
-        )
+        left_table = left_table.join(right_table, predicates=predicate, how=join_kind)
 
-    return catalog[left_name]
+    if join.condition:
+        predicate = convert(join.condition, catalog=catalog)
+        left_table = left_table.filter(predicate)
+
+    catalog[left_name] = left_table
+
+    return left_table
 
 
 @convert.register(sgp.Aggregate)

ibis/expr/tests/snapshots/test_sql/test_parse_sql_aggregation_with_multiple_joins/decompiled.py

@@ -0,0 +1,41 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+call_outcome = ibis.table(
+    name="call_outcome", schema={"outcome_text": "string", "id": "int64"}
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+innerjoin = employee.inner_join(call, employee.id == call.employee_id)
+
+result = (
+    innerjoin.inner_join(call_outcome, call.call_outcome_id == call_outcome.id)
+    .select(
+        [
+            innerjoin.first_name,
+            innerjoin.last_name,
+            innerjoin.id,
+            innerjoin.start_time,
+            innerjoin.end_time,
+            innerjoin.employee_id,
+            innerjoin.call_outcome_id,
+            innerjoin.call_attempts,
+            call_outcome.outcome_text,
+            call_outcome.id.name("id_right"),
+        ]
+    )
+    .group_by(call.employee_id)
+    .aggregate(call.call_attempts.mean().name("avg_attempts"))
+)

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_aggregation/decompiled.py

@@ -0,0 +1,17 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+
+result = call.group_by(call.employee_id).aggregate(
+    call.call_attempts.sum().name("attempts")
+)

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_aggregation_with_join/decompiled.py

@@ -0,0 +1,22 @@
+import ibis
+
+
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+leftjoin = employee.left_join(call, employee.id == call.employee_id)
+
+result = leftjoin.group_by(leftjoin.id).aggregate(
+    call.call_attempts.sum().name("attempts")
+)

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_join/inner/decompiled.py

@@ -0,0 +1,34 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+proj = employee.inner_join(call, employee.id == call.employee_id).filter(
+    employee.id < 5
+)
+
+result = proj.select(
+    [
+        proj.first_name,
+        proj.last_name,
+        proj.id,
+        call.start_time,
+        call.end_time,
+        call.employee_id,
+        call.call_outcome_id,
+        call.call_attempts,
+        proj.first_name.name("first"),
+    ]
+).order_by(proj.id.desc())

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_join/left/decompiled.py

@@ -0,0 +1,32 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+proj = employee.left_join(call, employee.id == call.employee_id).filter(employee.id < 5)
+
+result = proj.select(
+    [
+        proj.first_name,
+        proj.last_name,
+        proj.id,
+        call.start_time,
+        call.end_time,
+        call.employee_id,
+        call.call_outcome_id,
+        call.call_attempts,
+        proj.first_name.name("first"),
+    ]
+).order_by(proj.id.desc())

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_join/right/decompiled.py

@@ -0,0 +1,34 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+proj = employee.right_join(call, employee.id == call.employee_id).filter(
+    employee.id < 5
+)
+
+result = proj.select(
+    [
+        proj.first_name,
+        proj.last_name,
+        proj.id,
+        call.start_time,
+        call.end_time,
+        call.employee_id,
+        call.call_outcome_id,
+        call.call_attempts,
+        proj.first_name.name("first"),
+    ]
+).order_by(proj.id.desc())

ibis/expr/tests/snapshots/test_sql/test_parse_sql_basic_projection/decompiled.py

@@ -0,0 +1,12 @@
+import ibis
+
+
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+proj = employee.filter(employee.id < 5)
+
+result = proj.select(
+    [proj.first_name, proj.last_name, proj.id, proj.first_name.name("first")]
+).order_by(proj.id.desc())

ibis/expr/tests/snapshots/test_sql/test_parse_sql_join_with_filter/decompiled.py

@@ -0,0 +1,32 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+proj = employee.left_join(call, employee.id == call.employee_id).filter(employee.id < 5)
+
+result = proj.select(
+    [
+        proj.first_name,
+        proj.last_name,
+        proj.id,
+        call.start_time,
+        call.end_time,
+        call.employee_id,
+        call.call_outcome_id,
+        call.call_attempts,
+        proj.first_name.name("first"),
+    ]
+).order_by(proj.id.desc())

ibis/expr/tests/snapshots/test_sql/test_parse_sql_multiple_joins/decompiled.py

@@ -0,0 +1,38 @@
+import ibis
+
+
+call_outcome = ibis.table(
+    name="call_outcome", schema={"outcome_text": "string", "id": "int64"}
+)
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+innerjoin = employee.inner_join(call, employee.id == call.employee_id)
+
+result = innerjoin.inner_join(
+    call_outcome, call.call_outcome_id == call_outcome.id
+).select(
+    [
+        innerjoin.first_name,
+        innerjoin.last_name,
+        innerjoin.id,
+        innerjoin.start_time,
+        innerjoin.end_time,
+        innerjoin.employee_id,
+        innerjoin.call_outcome_id,
+        innerjoin.call_attempts,
+        call_outcome.outcome_text,
+        call_outcome.id.name("id_right"),
+    ]
+)

ibis/expr/tests/snapshots/test_sql/test_parse_sql_scalar_subquery/decompiled.py

@@ -0,0 +1,16 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+agg = call.aggregate(call.call_attempts.mean().name("mean"))
+
+result = call.inner_join(agg, [])

ibis/expr/tests/snapshots/test_sql/test_parse_sql_simple_reduction/decompiled.py

@@ -0,0 +1,15 @@
+import ibis
+
+
+call = ibis.table(
+    name="call",
+    schema={
+        "start_time": "timestamp",
+        "end_time": "timestamp",
+        "employee_id": "int64",
+        "call_outcome_id": "int64",
+        "call_attempts": "int64",
+    },
+)
+
+result = call.aggregate(call.call_attempts.mean().name("mean"))

ibis/expr/tests/snapshots/test_sql/test_parse_sql_simple_select_count/decompiled.py

@@ -0,0 +1,9 @@
+import ibis
+
+
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+
+result = employee.aggregate(employee.first_name.count().name("_col_0"))

ibis/expr/tests/snapshots/test_sql/test_parse_sql_table_alias/decompiled.py

@@ -0,0 +1,9 @@
+import ibis
+
+
+employee = ibis.table(
+    name="employee",
+    schema={"first_name": "string", "last_name": "string", "id": "int64"},
+)
+
+result = employee.select([employee.first_name, employee.last_name, employee.id])