[python] Default scalar global-index search mode to full

paimon-python/pypaimon/common/options/core_options.py

@@ -733,7 +733,19 @@ class CoreOptions:
         .enum_type(GlobalIndexSearchMode)
         .default_value(GlobalIndexSearchMode.FAST)
         .with_description(
-            "Search mode for global index queries. "
+            "Search mode for vector and full-text global index queries. "
+            "Scalar index queries use 'scalar-index.search-mode'. "
+            "Supported values are 'fast', 'full', and 'detail'."
+        )
+    )
+
+    GLOBAL_INDEX_SCALAR_SEARCH_MODE: ConfigOption[GlobalIndexSearchMode] = (
+        ConfigOptions.key("scalar-index.search-mode")
+        .enum_type(GlobalIndexSearchMode)
+        .default_value(GlobalIndexSearchMode.FULL)
+        .with_description(
+            "Search mode for scalar (sorted/bitmap) global index queries. "
+            "Defaults to 'full' to include rows not covered by the index. "
             "Supported values are 'fast', 'full', and 'detail'."
         )
     )
@@ -1372,6 +1384,13 @@ def global_index_enabled(self, default=None):
     def global_index_search_mode(self):
         return self.options.get(CoreOptions.GLOBAL_INDEX_SEARCH_MODE)
 
+    def global_index_scalar_search_mode(self):
+        if self.options.contains(CoreOptions.GLOBAL_INDEX_SCALAR_SEARCH_MODE):
+            return self.options.get(CoreOptions.GLOBAL_INDEX_SCALAR_SEARCH_MODE)
+        if self.options.contains(CoreOptions.GLOBAL_INDEX_SEARCH_MODE):
+            return self.options.get(CoreOptions.GLOBAL_INDEX_SEARCH_MODE)
+        return GlobalIndexSearchMode.FULL
+
     def global_index_external_path(self, default=None):
         value = self.options.get(CoreOptions.GLOBAL_INDEX_EXTERNAL_PATH, default)
         if value is None:

paimon-python/pypaimon/globalindex/data_evolution_global_index_coverage.py

@@ -55,6 +55,7 @@ def unindexed_ranges(
         self,
         fields_or_field_id: Union[List[DataField], Collection[int], int],
         predicate: Optional[Predicate] = None,
+        search_mode: Optional[GlobalIndexSearchMode] = None,
     ) -> List[Range]:
         if isinstance(fields_or_field_id, int):
             field_ids = {fields_or_field_id}
@@ -67,7 +68,7 @@ def unindexed_ranges(
                 field = field_by_name.get(name)
                 if field is not None:
                     field_ids.add(field.id)
-        return self._unindexed_ranges(field_ids)
+        return self._unindexed_ranges(field_ids, search_mode)
 
     def _add_coverage(self, field_id: int, row_range: Range) -> None:
         self._coverage_by_field.setdefault(field_id, []).append(row_range)
@@ -84,8 +85,13 @@ def _indexed_ranges(self, field_ids: Collection[int]) -> List[Range]:
             return []
         return Range.sort_and_merge_overlap(ranges, True)
 
-    def _unindexed_ranges(self, field_ids: Collection[int]) -> List[Range]:
-        search_mode = _global_index_search_mode(self._table)
+    def _unindexed_ranges(
+        self,
+        field_ids: Collection[int],
+        search_mode: Optional[GlobalIndexSearchMode] = None,
+    ) -> List[Range]:
+        if search_mode is None:
+            search_mode = _global_index_search_mode(self._table)
         if search_mode == GlobalIndexSearchMode.FAST:
             return []
         next_row_id = getattr(self._snapshot, "next_row_id", None)

paimon-python/pypaimon/globalindex/data_evolution_global_index_scanner.py

@@ -209,12 +209,14 @@ def scan(self, predicate: Optional[Predicate]) -> Optional[GlobalIndexResult]:
         """Scan the global index with the given predicate."""
         return self._evaluator.evaluate(predicate)
 
-    def unindexed_rows(self, predicate: Optional[Predicate]) -> GlobalIndexResult:
+    def unindexed_rows(self, predicate: Optional[Predicate],
+                       search_mode=None) -> GlobalIndexResult:
         """Return coarse row ids not covered by global indexes."""
         if self._coverage is None:
             return GlobalIndexResult.create_empty()
         return GlobalIndexResult.from_ranges(
-            self._coverage.unindexed_ranges(self._fields, predicate))
+            self._coverage.unindexed_ranges(
+                self._fields, predicate, search_mode=search_mode))
 
     def close(self):
         """Close the scanner and release resources."""

paimon-python/pypaimon/read/scanner/file_scanner.py

@@ -498,7 +498,9 @@ def _eval_global_index(self, snapshot=None):
                 result = scanner.scan(self.predicate)
                 if result is None:
                     return None
-                return result.or_(scanner.unindexed_rows(self.predicate))
+                scalar_mode = self.table.options.global_index_scalar_search_mode()
+                return result.or_(
+                    scanner.unindexed_rows(self.predicate, search_mode=scalar_mode))
         except Exception:
             return None
 

paimon-python/pypaimon/tests/global_index_scalar_search_mode_test.py

@@ -0,0 +1,100 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import unittest
+from types import SimpleNamespace
+
+from pypaimon.common.options.core_options import CoreOptions, GlobalIndexSearchMode
+from pypaimon.common.options.options import Options
+from pypaimon.globalindex.data_evolution_global_index_coverage import (
+    DataEvolutionGlobalIndexCoverage,
+)
+from pypaimon.globalindex.data_evolution_global_index_scanner import (
+    DataEvolutionGlobalIndexScanner,
+)
+
+
+def _ranges(result):
+    inner = result.results() if hasattr(result, "results") else result
+    for attr in ("to_range_list", "to_ranges", "ranges"):
+        if hasattr(inner, attr):
+            value = getattr(inner, attr)
+            value = value() if callable(value) else value
+            return [(r.from_, r.to) for r in value]
+    raise AssertionError("cannot extract ranges from %r" % (result,))
+
+
+def _coverage(options):
+    meta = SimpleNamespace(
+        row_range_start=0, row_range_end=99, index_field_id=1, extra_field_ids=None)
+    snapshot = SimpleNamespace(next_row_id=200)
+    table = SimpleNamespace(options=options)
+    return DataEvolutionGlobalIndexCoverage(
+        table, snapshot, None, [SimpleNamespace(global_index_meta=meta)])
+
+
+class ScalarGlobalIndexSearchModeTest(unittest.TestCase):
+
+    def test_default_values(self):
+        options = CoreOptions(Options.from_none())
+        self.assertEqual(
+            GlobalIndexSearchMode.FULL, options.global_index_scalar_search_mode())
+        self.assertEqual(
+            GlobalIndexSearchMode.FAST, options.global_index_search_mode())
+
+    def test_scalar_option_override(self):
+        options = CoreOptions(Options({"scalar-index.search-mode": "detail"}))
+        self.assertEqual(
+            GlobalIndexSearchMode.DETAIL, options.global_index_scalar_search_mode())
+
+    def test_inherits_explicit_global_index_search_mode(self):
+        options = CoreOptions(Options({"global-index.search-mode": "detail"}))
+        self.assertEqual(
+            GlobalIndexSearchMode.DETAIL, options.global_index_scalar_search_mode())
+
+    def test_scalar_key_wins_over_global_index_key(self):
+        options = CoreOptions(Options({
+            "scalar-index.search-mode": "detail",
+            "global-index.search-mode": "fast",
+        }))
+        self.assertEqual(
+            GlobalIndexSearchMode.DETAIL, options.global_index_scalar_search_mode())
+
+    def test_coverage_honours_search_mode_override(self):
+        coverage = _coverage(CoreOptions(Options.from_none()))
+        self.assertEqual(
+            [], coverage.unindexed_ranges(1, search_mode=GlobalIndexSearchMode.FAST))
+        full = coverage.unindexed_ranges(1, search_mode=GlobalIndexSearchMode.FULL)
+        self.assertEqual([(100, 199)], [(r.from_, r.to) for r in full])
+        self.assertEqual([], coverage.unindexed_ranges(1))
+
+    def test_scanner_applies_passed_scalar_mode(self):
+        coverage = _coverage(CoreOptions(Options.from_none()))
+        scanner = SimpleNamespace(_coverage=coverage, _fields=[1])
+        result = DataEvolutionGlobalIndexScanner.unindexed_rows(
+            scanner, None, search_mode=GlobalIndexSearchMode.FULL)
+        self.assertEqual([(100, 199)], _ranges(result))
+
+    def test_scanner_default_is_general_mode(self):
+        coverage = _coverage(CoreOptions(Options.from_none()))
+        scanner = SimpleNamespace(_coverage=coverage, _fields=[1])
+        result = DataEvolutionGlobalIndexScanner.unindexed_rows(scanner, None)
+        self.assertEqual([], _ranges(result))
+
+
+if __name__ == "__main__":
+    unittest.main()