chore: handle overwriting the unnested column

ibis/backends/sql/compiler.py

@@ -1514,15 +1514,25 @@ def visit_Unsupported(self, op, **_):
 
     def visit_TableUnnest(self, op, *, parent, column, offset: str | None):
         quoted = self.quoted
+        parent_schema = op.parent.schema
+        parent_alias = parent.alias_or_name
+        column_name = op.column.name
+
+        column_alias = sg.to_identifier(column_name, quoted=quoted)
         columns = [
-            sg.column(k, parent.alias_or_name, quoted=quoted)
-            for k in op.parent.schema.keys()
+            sg.column(k, parent_alias, quoted=quoted)
+            if k != column_name
+            else column_alias
+            for k in parent_schema.keys()
         ]
+        if column_name not in parent_schema:
+            columns.append(column_alias)
+
         if offset is not None:
             offset = sg.to_identifier(offset, quoted=quoted)
             columns.append(offset)
-        column_alias = sg.to_identifier(op.column.name, quoted=self.quoted)
-        expr = sg.select(*columns, column_alias)
+
+        expr = sg.select(*columns)
         alias = sge.TableAlias(columns=[column_alias])
         return expr.from_(parent).join(
             sge.Unnest(expressions=[column], alias=alias, offset=offset),

ibis/backends/tests/test_array.py

@@ -1392,6 +1392,6 @@ def test_zip_unnest_lift(con):
 
 def test_table_unnest(backend):
     t = backend.array_types
-    expr = t.unnest(t.x.name("unnested_x"), offset="i")
+    expr = t.unnest(t.x)
     result = expr.execute()
     assert len(result)

ibis/expr/operations/relations.py

@@ -480,7 +480,12 @@ def schema(self):
         column = self.column
         offset = self.offset
 
-        base = self.parent.schema | Schema({column.name: column.dtype.value_type})
+        base = Schema.from_tuples(
+            (name, dtype.value_type) if name == column.name else (name, dtype)
+            for name, dtype in self.parent.schema.items()
+        )
+        if column.name not in base:
+            base |= Schema({column.name: column.dtype.value_type})
         if offset is not None:
             base |= Schema({offset: dt.int64})
         return base