@@ -926,7 +926,25 @@ def _concat_arrow_tables(table_chunks: List["pyarrow.Table"]) -> "pyarrow.Table"
     bundled pyarrow -- e.g. DBR 13.3 (12.x) / 14.3 -- where ``promote_options``
     raises ``TypeError: unexpected keyword argument``. Fall back to the legacy
     ``promote=True`` there (equivalent to ``promote_options="default"``).
+
+    Schema promotion triggers Arrow's schema unification, which rejects
+    duplicate field names (``ArrowInvalid: Can't unify schema with duplicate
+    field names``) even when no promotion is actually needed -- breaking valid
+    SQL like ``SELECT 1 AS a, 2 AS a`` or ``SELECT * FROM a JOIN b`` (GH #989).
+    Promotion is only needed when chunk schemas actually differ (e.g. the
+    nullability case from GH #418), so when every chunk shares the first
+    chunk's schema we concatenate without promotion.
+
+    Known limitation: a result set that has *both* duplicate column names *and*
+    chunks whose schemas genuinely differ falls through to the promotion path
+    and still re-raises ``ArrowInvalid: Can't unify schema with duplicate field
+    names``. Arrow cannot unify a schema with duplicate field names, so there is
+    no promotion-based fix for that combination without renaming fields; it is a
+    narrow, pre-existing edge left unhandled here.
     """
+    if all(table.schema.equals(table_chunks[0].schema) for table in table_chunks[1:]):
+        return pyarrow.concat_tables(table_chunks)
+
     try:
         return pyarrow.concat_tables(table_chunks, promote_options="default")
     except TypeError:
 
@@ -453,6 +453,29 @@ def test_create_table_will_return_empty_result_set(self, extra_params):
             finally:
                 cursor.execute("DROP TABLE IF EXISTS {}".format(table_name))
 
+    @skipUnless(pysql_supports_arrow(), "arrow test needs arrow support")
+    def test_duplicate_column_names_survive_arrow_fetch(self):
+        """Queries whose result has two columns with the same name must survive
+        the Arrow fetch path (concat_table_chunks). Regressed in 4.2.6 by the
+        promote_options change (GH #989); 4.2.5 returned Row(a=1, a=2)."""
+        with self.cursor({}) as cursor:
+            cursor.execute("SELECT 1 AS a, 2 AS a")
+            arrow_table = cursor.fetchall_arrow()
+            assert arrow_table.column_names == ["a", "a"]
+            assert arrow_table.column(0).to_pylist() == [1]
+            assert arrow_table.column(1).to_pylist() == [2]
+
+        with self.cursor({}) as cursor:
+            cursor.execute("SELECT 1 AS a, 2 AS a")
+            rows = cursor.fetchall()
+            assert len(rows) == 1
+            assert list(rows[0]) == [1, 2]
+
+        with self.cursor({}) as cursor:
+            cursor.execute("SELECT 1 AS a, 2 AS a")
+            row = cursor.fetchone()
+            assert list(row) == [1, 2]
+
     def test_dml_rowcount(self):
         """cursor.rowcount reports the affected-row count for DML
         (INSERT/UPDATE/DELETE) instead of the hardcoded -1, and resets
 
@@ -174,6 +174,23 @@ def old_concat(tables, promote_options=None, **kwargs):
         result_table = concat_table_chunks([arrow_table1, arrow_table2])
         assert result_table.column("col1").to_pylist() == [1, 2, 3, 4]
 
+    @pytest.mark.skipif(pyarrow is None, reason="PyArrow is not installed")
+    def test_concat_table_chunks_duplicate_column_names(self):
+        # Duplicate column names are valid SQL (e.g. SELECT 1 AS a, 2 AS a).
+        # Schema promotion rejects them with ArrowInvalid, so when chunk
+        # schemas match we must concatenate without promotion (GH #989).
+        arrow_table1 = pyarrow.Table.from_arrays(
+            [pyarrow.array([1]), pyarrow.array([2])], names=["a", "a"]
+        )
+        arrow_table2 = pyarrow.Table.from_arrays(
+            [pyarrow.array([3]), pyarrow.array([4])], names=["a", "a"]
+        )
+
+        result_table = concat_table_chunks([arrow_table1, arrow_table2])
+        assert result_table.column_names == ["a", "a"]
+        assert result_table.column(0).to_pylist() == [1, 3]
+        assert result_table.column(1).to_pylist() == [2, 4]
+
     def test_concat_table_chunks_empty(self):
         result_table = concat_table_chunks([])
         assert result_table == []