supertable 2.5.4__tar.gz → 2.5.6__tar.gz

{supertable-2.5.4/supertable.egg-info → supertable-2.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supertable
-Version: 2.5.4
+Version: 2.5.6
 Summary: SuperTable — versioned data lake library for SQL analytics on Parquet + Redis.
 Author-email: Levente Kupas <lkupas@kladnasoft.com>
 License-Expression: LicenseRef-FSL-1.1-ALv2
@@ -54,7 +54,7 @@ Dynamic: license-file
 
 ![Python](https://img.shields.io/badge/python-3.10%2B-blue)
 ![License](https://img.shields.io/badge/license-FSL--1.1--ALv2-orange)
-![Version](https://img.shields.io/badge/version-2.5.1-brightgreen)
+![Version](https://img.shields.io/badge/version-2.5.6-brightgreen)
 
 **SuperTable — versioned data lake library for SQL analytics.**
 

{supertable-2.5.4 → supertable-2.5.6}/README.md

@@ -2,7 +2,7 @@
 
 ![Python](https://img.shields.io/badge/python-3.10%2B-blue)
 ![License](https://img.shields.io/badge/license-FSL--1.1--ALv2-orange)
-![Version](https://img.shields.io/badge/version-2.5.1-brightgreen)
+![Version](https://img.shields.io/badge/version-2.5.6-brightgreen)
 
 **SuperTable — versioned data lake library for SQL analytics.**
 

{supertable-2.5.4 → supertable-2.5.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "supertable"
-version = "2.5.4"
+version = "2.5.6"
 description = "SuperTable — versioned data lake library for SQL analytics on Parquet + Redis."
 readme = "README.md"
 requires-python = ">=3.10"

{supertable-2.5.4 → supertable-2.5.6}/supertable/__init__.py

@@ -25,11 +25,48 @@ See the ``supertable.demo`` package for runnable end-to-end demos and the
 project documentation for the full API surface.
 """
 
-__version__ = "2.5.4"
+__version__ = "2.5.6"
 
+import os
 from importlib import import_module
 from typing import TYPE_CHECKING, Any
 
+
+def _bootstrap_island_polars_cpu_limit() -> None:
+    """Apply an explicit Island CPU ceiling before Polars creates Rayon."""
+    raw = os.environ.get("SUPERTABLE_ISLAND_CPU_MAX")
+    if raw is None or not raw.strip():
+        return
+    try:
+        limit = int(raw.strip())
+    except ValueError:
+        raise RuntimeError(
+            "SUPERTABLE_ISLAND_CPU_MAX must be a non-negative integer"
+        ) from None
+    if limit < 0:
+        raise RuntimeError(
+            "SUPERTABLE_ISLAND_CPU_MAX must be a non-negative integer"
+        )
+    if limit == 0:
+        return
+    existing_raw = os.environ.get("POLARS_MAX_THREADS")
+    if existing_raw is not None and existing_raw.strip():
+        try:
+            existing = int(existing_raw.strip())
+        except ValueError:
+            raise RuntimeError(
+                "POLARS_MAX_THREADS must be a positive integer"
+            ) from None
+        if existing <= 0:
+            raise RuntimeError(
+                "POLARS_MAX_THREADS must be a positive integer"
+            )
+        limit = min(limit, existing)
+    os.environ["POLARS_MAX_THREADS"] = str(limit)
+
+
+_bootstrap_island_polars_cpu_limit()
+
 # This public alias predates the ``supertable.engine`` implementation package.
 # Importing the tiny enum after the now-lazy package is initialized ensures
 # later imports of engine submodules cannot replace ``supertable.engine`` with
@@ -37,7 +74,9 @@ from typing import TYPE_CHECKING, Any
 from supertable.engine.engine_enum import Engine as engine
 
 
-# Importing the package is intentionally cheap and side-effect-free.  The
+# Importing the package is intentionally cheap and does not import native data
+# engines. The only bootstrap side effect is the explicit Polars CPU ceiling
+# above, which must exist before Rayon is initialized. The
 # public convenience exports are loaded on first use (PEP 562) so importing
 # ``supertable`` does not import PyArrow/Polars, connect to Redis, probe the
 # filesystem, or initialise an application home.

{supertable-2.5.4 → supertable-2.5.6}/supertable/config/settings.py

@@ -263,7 +263,8 @@ class Settings:
     # Parquet files; selective remote Island scans use the range cache below.
     SUPERTABLE_ISLAND_CACHE_ENABLED: bool = True       # SUPERTABLE_ISLAND_CACHE_ENABLED
     SUPERTABLE_ISLAND_CACHE_DIR: str = ""              # SUPERTABLE_ISLAND_CACHE_DIR
-    SUPERTABLE_ISLAND_CACHE_MAX_BYTES: int = 20 * 1024 * 1024 * 1024  # SUPERTABLE_ISLAND_CACHE_MAX_BYTES
+    # Zero derives a safe share of currently free cache-filesystem capacity.
+    SUPERTABLE_ISLAND_CACHE_MAX_BYTES: int = 0  # SUPERTABLE_ISLAND_CACHE_MAX_BYTES
     # Published Parquet objects are immutable/version-addressed.  Capacity and
     # integrity, rather than age, rotate the local object cache by default.
     # Operators may still opt into an idle TTL with an explicitly positive
@@ -277,7 +278,7 @@ class Settings:
     # for. Every cached interval is sealed to the provider version/ETag.
     SUPERTABLE_ISLAND_RANGE_CACHE_ENABLED: bool = True   # SUPERTABLE_ISLAND_RANGE_CACHE_ENABLED
     SUPERTABLE_ISLAND_RANGE_CACHE_DIR: str = ""          # SUPERTABLE_ISLAND_RANGE_CACHE_DIR
-    SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES: int = 20 * 1024 * 1024 * 1024  # SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES
+    SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES: int = 0  # SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES
     # Immutable, version-sealed ranges rotate on capacity/corruption by default.
     # A positive value explicitly restores idle-TTL eviction.
     SUPERTABLE_ISLAND_RANGE_CACHE_TTL_SEC: int = 0  # SUPERTABLE_ISLAND_RANGE_CACHE_TTL_SEC
@@ -287,10 +288,11 @@ class Settings:
     # quotas are hard; Polars/Arrow scan pools are process-global, so decoded
     # scan-memory estimates are conservative routing/admission guards rather
     # than an in-process per-query allocator cap.
-    SUPERTABLE_ISLAND_MEMORY_FRACTION: float = 0.60       # SUPERTABLE_ISLAND_MEMORY_FRACTION
-    SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION: float = 0.80  # SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION
+    SUPERTABLE_ISLAND_MEMORY_FRACTION: float = 1.0        # SUPERTABLE_ISLAND_MEMORY_FRACTION
+    SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION: float = 1.0  # SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION
     SUPERTABLE_ISLAND_MAX_MEMORY_BYTES: int = 0           # SUPERTABLE_ISLAND_MAX_MEMORY_BYTES
-    SUPERTABLE_ISLAND_MAX_RESULT_BYTES: int = 512 * 1024 * 1024  # SUPERTABLE_ISLAND_MAX_RESULT_BYTES
+    # Zero derives the effective container memory available to this process.
+    SUPERTABLE_ISLAND_MAX_RESULT_BYTES: int = 0  # SUPERTABLE_ISLAND_MAX_RESULT_BYTES
     SUPERTABLE_ISLAND_CPU_MAX: int = 0                    # SUPERTABLE_ISLAND_CPU_MAX
     SUPERTABLE_ISLAND_IO_WORKERS_MAX: int = 16            # SUPERTABLE_ISLAND_IO_WORKERS_MAX
     # Hard wall-clock bound for one admitted IslandDB execution.  The bound is
@@ -637,7 +639,7 @@ def _build_settings() -> Settings:
         SUPERTABLE_ISLAND_CACHE_ENABLED=_env_bool("SUPERTABLE_ISLAND_CACHE_ENABLED", True),
         SUPERTABLE_ISLAND_CACHE_DIR=_env_str("SUPERTABLE_ISLAND_CACHE_DIR"),
         SUPERTABLE_ISLAND_CACHE_MAX_BYTES=_env_int(
-            "SUPERTABLE_ISLAND_CACHE_MAX_BYTES", 20 * 1024 * 1024 * 1024,
+            "SUPERTABLE_ISLAND_CACHE_MAX_BYTES", 0,
         ),
         SUPERTABLE_ISLAND_CACHE_TTL_SEC=_env_int(
             "SUPERTABLE_ISLAND_CACHE_TTL_SEC", 0,
@@ -655,22 +657,22 @@ def _build_settings() -> Settings:
             "SUPERTABLE_ISLAND_RANGE_CACHE_DIR",
         ),
         SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES=_env_int(
-            "SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES", 20 * 1024 * 1024 * 1024,
+            "SUPERTABLE_ISLAND_RANGE_CACHE_MAX_BYTES", 0,
         ),
         SUPERTABLE_ISLAND_RANGE_CACHE_TTL_SEC=_env_int(
             "SUPERTABLE_ISLAND_RANGE_CACHE_TTL_SEC", 0,
         ),
         SUPERTABLE_ISLAND_MEMORY_FRACTION=_env_float(
-            "SUPERTABLE_ISLAND_MEMORY_FRACTION", 0.60,
+            "SUPERTABLE_ISLAND_MEMORY_FRACTION", 1.0,
         ),
         SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION=_env_float(
-            "SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION", 0.80,
+            "SUPERTABLE_ISLAND_GLOBAL_MEMORY_FRACTION", 1.0,
         ),
         SUPERTABLE_ISLAND_MAX_MEMORY_BYTES=_env_int(
             "SUPERTABLE_ISLAND_MAX_MEMORY_BYTES", 0,
         ),
         SUPERTABLE_ISLAND_MAX_RESULT_BYTES=_env_int(
-            "SUPERTABLE_ISLAND_MAX_RESULT_BYTES", 512 * 1024 * 1024,
+            "SUPERTABLE_ISLAND_MAX_RESULT_BYTES", 0,
         ),
         SUPERTABLE_ISLAND_CPU_MAX=_env_int(
             "SUPERTABLE_ISLAND_CPU_MAX", 0,

{supertable-2.5.4 → supertable-2.5.6}/supertable/data_reader.py

@@ -191,6 +191,9 @@ class _MonitoredResultStream:
         self._finalize_complete = False
         self._finalizing_thread: Optional[int] = None
         self._finalize_error: BaseException | None = None
+        add_terminal_callback = getattr(inner, "add_terminal_callback", None)
+        if callable(add_terminal_callback):
+            add_terminal_callback(self._inner_terminal)
 
     def __iter__(self):
         return self
@@ -251,6 +254,29 @@ class _MonitoredResultStream:
         with self._finalize_condition:
             return self._finalized
 
+    def _inner_terminal(self, kind: str) -> None:
+        if kind == "completed":
+            status, message = Status.OK.value, None
+        elif kind == "timed_out":
+            status, message = Status.ERROR.value, "result stream timed out"
+        elif kind == "cancelled":
+            status, message = Status.ERROR.value, "result stream cancelled"
+        elif kind == "failed":
+            status, message = Status.ERROR.value, _QUERY_STREAM_ERROR
+        else:
+            status = Status.ERROR.value
+            message = "result stream closed before exhaustion"
+        try:
+            self._finish(status, message)
+        except BaseException as exc:
+            # A watcher-thread callback cannot raise into the request thread.
+            # _finish retains the error so any later stream operation observes
+            # it; protected failure audit emission has already been attempted.
+            logger.error(
+                "stream terminal monitoring failed; error_type=%s",
+                safe_exception_type(exc),
+            )
+
     def __next__(self):
         try:
             batch = next(self._inner)
@@ -909,6 +935,9 @@ class DataReader:
         actual_engine = str(
             getattr(engine_used, "value", engine_used) or ""
         )[:64]
+        audit_outcome = (
+            Outcome.SUCCESS if outcome == "success" else Outcome.FAILURE
+        )
         emit(
             category=EventCategory.DATA_ACCESS,
             action=Actions.QUERY_EXECUTE,
@@ -930,7 +959,7 @@ class DataReader:
                 "column_count": max(0, int(result_columns)),
                 "outcome": outcome,
             },
-            outcome=Outcome.SUCCESS,
+            outcome=audit_outcome,
         )
 
     def _assert_targets_exist(self, physical_tables) -> None:
@@ -1560,6 +1589,9 @@ class DataReader:
                 join_pruning_lanes=_engine_safe_join_pruning_lanes(engine),
                 plan_stats=self.plan_stats,
                 require_odata_identity=(_odata_identity is True),
+                require_bounded_resource_estimates=(
+                    getattr(engine, "value", None) in {"auto", "islanddb"}
+                ),
             )
             if aggregate_children:
                 estimator_kwargs["aggregate_children"] = aggregate_children
@@ -2113,6 +2145,7 @@ class DataReader:
                 })
                 stream_timer.capture_and_reset_timing(event="EXECUTING_QUERY")
                 stream_timer.capture_duration(event="TOTAL_EXECUTE")
+                monitoring_error: Optional[MonitoringPostExecutionError] = None
                 try:
                     extend_execution_plan(
                         query_plan_manager=stream_qpm,
@@ -2130,22 +2163,46 @@ class DataReader:
                     safe_cause = MonitoringDurabilityError(
                         "monitoring durability failure"
                     )
-                    raise MonitoringPostExecutionError(
+                    monitoring_error = MonitoringPostExecutionError(
                         organization=stream_qpm.organization,
                         super_name=stream_qpm.super_name,
                         query_id=str(getattr(stream_qpm, "query_id", "")),
                         status=final_status,
                         cause=safe_cause,
-                    ) from None
+                    )
                 finally:
                     stream_timer.capture_and_reset_timing(event="EXTENDING_PLAN")
-                if final_status == Status.OK.value:
-                    self._emit_successful_query_audit(
-                        role_name=role_name,
-                        engine_used=_engine_used,
-                        result_rows=result_rows,
-                        result_columns=result_columns,
+                audit_engine = _actual_engine_from_plan_stats(
+                    stream_plan_stats,
+                    fallback=_engine_used,
+                )
+                try:
+                    if final_status == Status.OK.value:
+                        self._emit_successful_query_audit(
+                            role_name=role_name,
+                            engine_used=audit_engine,
+                            result_rows=result_rows,
+                            result_columns=result_columns,
+                        )
+                    else:
+                        self._emit_successful_query_audit(
+                            role_name=role_name,
+                            engine_used=audit_engine,
+                            result_rows=result_rows,
+                            result_columns=result_columns,
+                            outcome="failure",
+                        )
+                except Exception:
+                    if final_status == Status.OK.value and monitoring_error is None:
+                        raise
+                    # Preserve the producer/cancellation or monitoring error
+                    # just as the materialized failure path does.
+                    logger.debug(
+                        self._lp("failed to emit query failure audit"),
+                        exc_info=True,
                     )
+                if monitoring_error is not None:
+                    raise monitoring_error
 
             return (
                 _MonitoredResultStream(result_value, _finalize_stream_monitoring),
@@ -2771,6 +2828,32 @@ def _engine_name(value: Any) -> str:
     return str(raw or "").strip().casefold()
 
 
+def _actual_engine_from_plan_stats(plan_stats: Any, *, fallback: Any) -> str:
+    """Resolve a stream's engine only after deferred delivery has finished."""
+    try:
+        stats = tuple(
+            entry for entry in (getattr(plan_stats, "stats", ()) or ())
+            if isinstance(entry, dict)
+        )
+        outcome = _latest_plan_stat(stats, "AUTO_ROUTING_OUTCOME")
+        if isinstance(outcome, dict):
+            actual = _engine_name(outcome.get("actual_engine"))
+            if actual:
+                return actual
+        recorded = _engine_name(_latest_plan_stat(stats, "ENGINE"))
+        if recorded:
+            return recorded
+        for entry in reversed(stats):
+            attempt = entry.get("ENGINE_ATTEMPT")
+            if isinstance(attempt, dict):
+                attempted = _engine_name(attempt.get("engine"))
+                if attempted:
+                    return attempted
+    except Exception:
+        pass
+    return _engine_name(fallback)
+
+
 def _update_query_out(
     reader: DataReader,
     out: Optional[Dict[str, Any]],
@@ -2837,14 +2920,10 @@ def _update_query_out(
     if not selected and isinstance(outcome, dict):
         selected = _engine_name(outcome.get("selected_engine"))
 
-    actual = ""
+    actual = _actual_engine_from_plan_stats(plan_stats, fallback="")
     fallback = False
     if isinstance(outcome, dict):
-        actual = _engine_name(outcome.get("actual_engine"))
         fallback = bool(outcome.get("fallback", False))
-    actual = actual or _engine_name(recorded_engine)
-    if not actual and engine_attempts:
-        actual = _engine_name(engine_attempts[-1].get("engine"))
     selected = selected or actual or requested
     if actual and selected and not isinstance(outcome, dict):
         fallback = actual != selected

{supertable-2.5.4 → supertable-2.5.6}/supertable/data_writer.py

@@ -1902,6 +1902,8 @@ class DataWriter:
                     profiler=profiler,
                     existing_tombstones=prev_dv_df,
                     storage=self.super_table.storage,
+                    organization=self.super_table.organization,
+                    catalog=self.catalog,
                     require_global_tombstone_disjoint_proof=(
                         tombstone_v3_transition_enabled
                     ),

{supertable-2.5.4 → supertable-2.5.6}/supertable/engine/adaptive_router.py

@@ -138,6 +138,7 @@ class RoutingFeatures:
     freshness_age_seconds: int = -1
     has_active_tombstone: bool = False
     streaming_result: bool = False
+    island_plan_evaluated: bool = False
     island_advice: str = ""
     island_cpu_workers: int = 0
     island_io_workers: int = 0
@@ -193,6 +194,7 @@ class RoutingFeatures:
             "stream" if self.streaming_result else "materialized",
             "tombstone" if self.has_active_tombstone else "clean",
             "fresh" if self.data_is_fresh else "stable",
+            "island_plan" if self.island_plan_evaluated else "no_island_plan",
             str(self.island_advice or "none"),
             str(self._magnitude_bucket(self.island_cpu_workers)),
             str(self._magnitude_bucket(self.island_io_workers)),
@@ -502,10 +504,23 @@ class AdaptiveEngineRouter:
             )
         if not features.source_bytes_complete:
             rejections[Engine.ISLANDDB].append("source byte estimate incomplete")
-        if features.island_advice not in {"island_in_memory", "island_spill"}:
+        if (
+            features.island_plan_evaluated
+            and features.island_advice not in {
+                "island_in_memory", "island_spill",
+            }
+        ):
             rejections[Engine.ISLANDDB].append(
                 "IslandDB resource plan is not executable"
             )
+        elif (
+            availability.island_enabled
+            and availability.island_supported
+            and not features.island_plan_evaluated
+        ):
+            rejections[Engine.ISLANDDB].append(
+                "IslandDB resource plan is unavailable"
+            )
 
         if not availability.spark_available:
             rejections[Engine.SPARK_SQL].append("no safe fitting Spark cluster")

{supertable-2.5.4 → supertable-2.5.6}/supertable/engine/data_estimator.py

@@ -47,6 +47,7 @@ from supertable.utils.sql_parser import TableDefinition
 from supertable.engine.join_pruner import prune_files_across_joins
 from supertable.processing import (
     integer_domains_from_complete_stats,
+    load_bounded_stats_for_planning,
     load_stats,
     prune_files_by_predicates,
     resource_object_seal,
@@ -557,6 +558,7 @@ class DataEstimator:
             Dict[Tuple[str, str], Iterable[str]]
         ] = None,
         require_odata_identity: bool = False,
+        require_bounded_resource_estimates: bool = False,
     ):
         self.organization = organization
         self.storage = storage
@@ -577,6 +579,13 @@ class DataEstimator:
         if type(require_odata_identity) is not bool:
             raise TypeError("require_odata_identity must be a bool")
         self.require_odata_identity = require_odata_identity
+        if type(require_bounded_resource_estimates) is not bool:
+            raise TypeError(
+                "require_bounded_resource_estimates must be a bool"
+            )
+        self.require_bounded_resource_estimates = (
+            require_bounded_resource_estimates
+        )
         # Aggregate relations (``super_name == simple_name``) are resolved and
         # authorized by DataReader before estimation.  Pin that exact child set
         # here so a table created between authorization and Redis SCAN cannot be
@@ -1684,11 +1693,13 @@ class DataEstimator:
             return 0, False
         widths: List[int] = []
         for name in requested:
-            width = self._decoded_fixed_width(normalized_types.get(name))
+            normalized_type = str(
+                normalized_types.get(name) or ""
+            ).strip().casefold()
+            width = self._decoded_fixed_width(normalized_type)
             if (
                 width is None
-                and str(normalized_types.get(name) or "").strip().casefold()
-                == "binary"
+                and normalized_type in {"binary", "string", "utf8"}
             ):
                 bound = (max_value_bytes or {}).get(name)
                 if (
@@ -1696,9 +1707,12 @@ class DataEstimator:
                     and not isinstance(bound, bool)
                     and bound >= 0
                 ):
-                    # Variable Binary owns a 32-bit offset per value in
-                    # addition to its exactly sealed maximum payload width.
-                    width = int(bound) + 4
+                    # Binary owns a 32-bit offset; Polars' native UTF-8 value
+                    # representation can retain a 16-byte string view.  The
+                    # caller adds validity/alignment slack below.
+                    width = int(bound) + (
+                        4 if normalized_type == "binary" else 16
+                    )
             if width is None:
                 return 0, False
             widths.append(width)
@@ -2211,11 +2225,12 @@ class DataEstimator:
                     self.predicate_constraints.get(key)
                 )
 
-                # Load the stats artifact ONCE per table and reuse it for predicate
-                # pruning, projection sizing AND cross-table join propagation
-                # (cache-backed: a repeated read of the same table is a memory
-                # hit). Only load when at least one consumer needs it, so a
-                # SELECT * that neither filters nor joins stays free.
+                # Load the stats artifact ONCE per table and reuse it for
+                # predicate pruning, projection sizing, cross-table join
+                # propagation, and bounded engine resource planning. The
+                # AUTO/IslandDB lane performs pre-decode admission; a normal
+                # cache miss would otherwise whole-decode the artifact before
+                # the cache byte cap can reject it.
                 stats_df: Optional["polars.DataFrame"] = None
                 stats_identity = (
                     stats_cache_identity(
@@ -2225,15 +2240,37 @@ class DataEstimator:
                     )
                     if stats_file else None
                 )
-                if stats_file and (need_projection or has_predicate or key in join_table_keys):
+                if stats_file and (
+                    need_projection
+                    or has_predicate
+                    or key in join_table_keys
+                    or bool(getattr(
+                        self, "require_bounded_resource_estimates", False,
+                    ))
+                ):
                     try:
-                        stats_df = load_stats(
-                            stats_file,
-                            allow_cache=True,
-                            cache_identity=stats_identity,
-                            profiler=prune_profiler,
-                            storage=self.storage,
-                        )
+                        if bool(getattr(
+                            self, "require_bounded_resource_estimates", False,
+                        )):
+                            if expected_stats_rows is None:
+                                raise ValueError(
+                                    "Statistics row count is unavailable"
+                                )
+                            stats_df = load_bounded_stats_for_planning(
+                                stats_file,
+                                expected_rows=expected_stats_rows,
+                                cache_identity=stats_identity,
+                                profiler=prune_profiler,
+                                storage=self.storage,
+                            )
+                        else:
+                            stats_df = load_stats(
+                                stats_file,
+                                allow_cache=True,
+                                cache_identity=stats_identity,
+                                profiler=prune_profiler,
+                                storage=self.storage,
+                            )
                     except Exception as stats_err:
                         # Stats are an optional optimisation artifact.  A stale,
                         # corrupt, unavailable, or malformed pointer must never
@@ -2511,7 +2548,9 @@ class DataEstimator:
                     for file_key in survivors
                 )
                 for column_name, type_name in schema_types.items()
-                if str(type_name).strip().casefold() == "binary"
+                if str(type_name).strip().casefold() in {
+                    "binary", "string", "utf8",
+                }
                 and survivors
                 and all(
                     isinstance(resource_value_bounds.get(file_key), dict)
@@ -2700,11 +2739,11 @@ class DataEstimator:
                 # selected-RG anti join and a full-file uniqueness proof for
                 # every referenced immutable resource. Stats deliberately omit
                 # system columns, so use manifest row counts for decoded Int64
-                # buffers and the entire file size as a conservative compressed
-                # upper bound for the proof scan. This is deliberately looser
-                # than the actual range read, but complete: active tombstones on
-                # 100+ files remain eligible for bounded Island planning without
-                # pretending ``8 * rows`` covers Parquet page overhead.
+                # buffers. Conservatively charge one entire file for each rowid
+                # consumer as compressed work: the candidate anti join and the
+                # full identity proof. This is deliberately looser than the
+                # actual range reads, but complete even when rowid chunks
+                # dominate tiny user columns.
                 full_rows_complete = all(
                     isinstance(resource_rows.get(file_key), int)
                     and not isinstance(resource_rows.get(file_key), bool)
@@ -2734,7 +2773,9 @@ class DataEstimator:
                 else:
                     table_proof_decoded_complete = False
                 if full_sizes_complete:
-                    table_rg_bytes += sum(key_size[file_key] for file_key in survivors)
+                    table_rg_bytes += 2 * sum(
+                        key_size[file_key] for file_key in survivors
+                    )
                 else:
                     table_rg_complete = False
             table_decoded_bytes = (