fix(join): disallow "", require "{name}" instead

There is this code inside expr/types/join.py:

```python
def disambiguate_fields(
    how,
    predicates,
    equalities,
    left_fields,
    right_fields,
    left_template,
    right_template,
):
    """Resolve name collisions between the left and right tables."""
    collisions = set()
    left_template = left_template or "{name}"
    right_template = right_template or "{name}"
   ...
```

This made it so that "" was treated equivalently to "{name}". But I think this is inconsistent, it is a remnant from when we had the rsuffix and lsuffix API.
I dug into this when I was confused as to the logic behind how the default values of "" resulted in the input column.

This doesn't have any impact on default behavior, since I adjusted the default values to. If someone WAS passing in a falsy value, such as "", False, or None, then this is breaking.

Author: NickCrews

ibis/expr/types/joins.py

@@ -42,8 +42,6 @@ def disambiguate_fields(
 ):
     """Resolve name collisions between the left and right tables."""
     collisions = set()
-    left_renamer = left_renamer or "{name}"
-    right_renamer = right_renamer or "{name}"
 
     if how == "inner" and util.all_of(predicates, ops.Equals):
         # for inner joins composed exclusively of equality predicates, we can
@@ -229,7 +227,7 @@ def join(
         predicates: Any = (),
         how: JoinKind = "inner",
         *,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ):
         if not isinstance(right, Table):
@@ -285,7 +283,7 @@ def asof_join(
         predicates=(),
         tolerance=None,
         *,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ):
         predicates = util.promote_list(predicates)
@@ -363,7 +361,7 @@ def cross_join(
         self: Table,
         right: Table,
         *rest: Table,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ):
         left = self.join(right, how="cross", predicates=(), lname=lname, rname=rname)

ibis/expr/types/relations.py

@@ -65,7 +65,7 @@ def f(  # noqa: D417
             | Sequence[str | tuple[str | ir.Column, str | ir.Column] | ir.BooleanValue]
         ) = (),
         *,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ) -> ir.Table:
         """Perform a join between two tables.
@@ -3007,7 +3007,7 @@ def join(
         ) = (),
         how: JoinKind = "inner",
         *,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ) -> Table:
         """Perform a join between two tables.
@@ -3177,7 +3177,7 @@ def asof_join(
         predicates: str | ir.Column | Sequence[str | ir.Column] = (),
         tolerance: str | ir.IntervalScalar | None = None,
         *,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ) -> Table:
         """Perform an "as-of" join between `left` and `right`.
@@ -3301,7 +3301,7 @@ def cross_join(
         left: Table,
         right: Table,
         *rest: Table,
-        lname: str = "",
+        lname: str = "{name}",
         rname: str = "{name}_right",
     ) -> Table:
         """Compute the cross join of a sequence of tables.

ibis/tests/expr/test_table.py

@@ -1780,7 +1780,7 @@ def test_join_lname_rname(how):
     expr = method(right, rname="right_{name}")
     assert expr.columns == ("id", "first_name", "right_id", "last_name")
 
-    expr = method(right, lname="left_{name}", rname="")
+    expr = method(right, lname="left_{name}", rname="{name}")
     assert expr.columns == ("left_id", "first_name", "id", "last_name")
 
     expr = method(right, rname="right_{name}", lname="left_{name}")