@@ -3267,48 +3267,99 @@ def _expected_batch(unit: str) -> pa.RecordBatch:
     assert _expected_batch("ns" if format_version > 2 else "us").equals(actual_result)
 
 
-def test_task_to_record_batches_filter_without_positional_deletes_avoids_table_refilter(tmpdir: str) -> None:
+def test_task_to_record_batches_does_not_use_table_filter_without_positional_deletes(tmpdir: str) -> None:
+    """Regression test for https://github.com/apache/iceberg-python/issues/3272.
+
+    The old code always created a ``pa.Table`` via ``pa.Table.from_batches`` and called
+    ``filter`` / ``combine_chunks`` / ``to_batches()[0]`` — even when no positional deletes
+    existed and the scanner had already applied the predicate push-down.  On Apple Silicon
+    with affected PyArrow versions this triggered a SIGSEGV.  The fix removes that
+    Table-based code path for the no-positional-delete case.
+
+    We detect a regression by replacing ``pyarrow.Table`` with a sentinel class whose
+    ``from_batches`` raises immediately.  ``isinstance`` checks against the original
+    ``pa.Table`` are preserved via a custom metaclass so the rest of the code-path is
+    unaffected.  With the fix the sentinel is never reached; without the fix it is called
+    and the test fails.
+    """
+    from pyiceberg.expressions.visitors import bind
+
     arrow_schema = pa.schema((pa.field("id", pa.int32(), nullable=True, metadata={PYARROW_PARQUET_FIELD_ID_KEY: "1"}),))
     arrow_table = pa.table([pa.array([1, 2, 3], type=pa.int32())], schema=arrow_schema)
     data_file = _write_table_to_data_file(
-        f"{tmpdir}/test_task_to_record_batches_filter_no_positional.parquet", arrow_schema, arrow_table
+        f"{tmpdir}/test_task_to_record_batches_no_table_refilter.parquet", arrow_schema, arrow_table
     )
 
     table_schema = Schema(NestedField(1, "id", IntegerType(), required=False))
-    from pyiceberg.expressions.visitors import bind
 
-    result_batches = list(
-        _task_to_record_batches(
-            PyArrowFileIO(),
-            FileScanTask(data_file),
-            bound_row_filter=bind(table_schema, GreaterThan("id", 1), case_sensitive=True),
-            projected_schema=table_schema,
-            table_schema=table_schema,
-            projected_field_ids={1},
-            positional_deletes=None,
-            case_sensitive=True,
+    _real_Table = pa.Table
+
+    class _TableFilterSentinelMeta(type):
+        """Metaclass that delegates isinstance/issubclass to the real pa.Table."""
+
+        def __instancecheck__(cls, instance: object) -> bool:
+            return isinstance(instance, _real_Table)
+
+        def __subclasscheck__(cls, subclass: type) -> bool:
+            return issubclass(subclass, _real_Table)
+
+    class _TableFilterSentinel(metaclass=_TableFilterSentinelMeta):
+        @staticmethod
+        def from_batches(*_: object, **__: object) -> None:
+            raise AssertionError(
+                "pa.Table.from_batches must not be called when positional_deletes is None: "
+                "the SIGSEGV-prone workaround path (from_batches/filter/combine_chunks/to_batches) was taken"
+            )
+
+    with patch("pyarrow.Table", new=_TableFilterSentinel):
+        result_batches = list(
+            _task_to_record_batches(
+                PyArrowFileIO(),
+                FileScanTask(data_file),
+                bound_row_filter=bind(table_schema, GreaterThan("id", 1), case_sensitive=True),
+                projected_schema=table_schema,
+                table_schema=table_schema,
+                projected_field_ids={1},
+                positional_deletes=None,
+                case_sensitive=True,
+            )
         )
-    )
     assert len(result_batches) == 1
     assert result_batches[0].column(0).to_pylist() == [2, 3]
 
 
-def test_task_to_record_batches_filter_with_positional_deletes_handles_empty_batch(tmpdir: str) -> None:
+def test_task_to_record_batches_filter_applied_after_positional_deletes(tmpdir: str) -> None:
+    """Regression test: the row filter must be applied *after* positional deletes are removed.
+
+    When positional deletes are present the scanner does not push down the predicate, so
+    ``_task_to_record_batches`` must apply ``pyarrow_filter`` explicitly after ``take``.
+    This test uses data where the expected result differs from both
+    "filter only" and "deletes only" projections, ensuring that skipping either step
+    would produce the wrong answer.
+    """
+    from pyiceberg.expressions.visitors import bind
+
     arrow_schema = pa.schema((pa.field("id", pa.int32(), nullable=True, metadata={PYARROW_PARQUET_FIELD_ID_KEY: "1"}),))
-    arrow_table = pa.table([pa.array([1, 2, 3], type=pa.int32())], schema=arrow_schema)
+    # File rows (0-indexed positions): 0→1, 1→2, 2→3, 3→4, 4→5
+    arrow_table = pa.table([pa.array([1, 2, 3, 4, 5], type=pa.int32())], schema=arrow_schema)
     data_file = _write_table_to_data_file(
         f"{tmpdir}/test_task_to_record_batches_filter_with_positional.parquet", arrow_schema, arrow_table
     )
 
     table_schema = Schema(NestedField(1, "id", IntegerType(), required=False))
-    from pyiceberg.expressions.visitors import bind
 
-    positional_deletes = [pa.chunked_array([pa.array([], type=pa.int64())])]
+    # Delete file-positions 1 and 3 (values 2 and 4); survivors: [1, 3, 5]
+    # Then apply filter id >= 3; expected result: [3, 5]
+    #
+    # Wrong results that would indicate a bug:
+    #   [1, 3, 5]  — filter not applied after deletes
+    #   [3, 4, 5]  — positional deletes not applied (scanner skips filter push-down)
+    positional_deletes = [pa.chunked_array([pa.array([1, 3], type=pa.int64())])]
     result_batches = list(
         _task_to_record_batches(
             PyArrowFileIO(),
             FileScanTask(data_file),
-            bound_row_filter=bind(table_schema, GreaterThan("id", 100), case_sensitive=True),
+            bound_row_filter=bind(table_schema, GreaterThan("id", 2), case_sensitive=True),
             projected_schema=table_schema,
             table_schema=table_schema,
             projected_field_ids={1},
@@ -3317,7 +3368,8 @@ def test_task_to_record_batches_filter_with_positional_deletes_handles_empty_bat
         )
     )
 
-    assert result_batches == []
+    assert len(result_batches) == 1
+    assert result_batches[0].column(0).to_pylist() == [3, 5]
 
 
 def test_parse_location_defaults() -> None: