fix: simplify search op

Author: tswast

bigframes/bigquery/_operations/search.py

@@ -20,10 +20,11 @@
 
 import google.cloud.bigquery as bigquery
 
+import bigframes.core.sql
+import bigframes.dataframe
 import bigframes.ml.utils as utils
 
 if typing.TYPE_CHECKING:
-    import bigframes.dataframe as dataframe
     import bigframes.series as series
     import bigframes.session
 
@@ -91,15 +92,15 @@ def create_vector_index(
 def vector_search(
     base_table: str,
     column_to_search: str,
-    query: Union["dataframe.DataFrame", "series.Series"],
+    query: Union[bigframes.dataframe.DataFrame, series.Series],
     *,
     query_column_to_search: Optional[str] = None,
     top_k: Optional[int] = None,
     distance_type: Optional[Literal["euclidean", "cosine", "dot_product"]] = None,
     fraction_lists_to_search: Optional[float] = None,
     use_brute_force: Optional[bool] = None,
     allow_large_results: Optional[bool] = None,
-) -> dataframe.DataFrame:
+) -> bigframes.dataframe.DataFrame:
     """
     Conduct vector search which searches embeddings to find semantically similar entities.
 
@@ -108,7 +109,6 @@ def vector_search(
 
     **Examples:**
 
-
         >>> import bigframes.pandas as bpd
         >>> import bigframes.bigquery as bbq
 
@@ -250,12 +250,8 @@ def vector_search(
 
 
 def search(
-    data_to_search: Union["dataframe.DataFrame", "series.Series"],
+    data_to_search: Union[bigframes.dataframe.DataFrame, series.Series],
     search_query: str,
-    *,
-    json_scope: Optional[str] = None,
-    analyzer: Optional[str] = None,
-    analyzer_options: Optional[str] = None,
 ) -> series.Series:
     """
     The SEARCH function checks to see whether a BigQuery table or other search
@@ -288,46 +284,28 @@ def search(
         search_query (str):
             A STRING literal, or a STRING constant expression that represents
             the terms of the search query.
-        json_scope (str, optional):
-            A named argument with a STRING value. Takes one of the following
-            values to indicate the scope of JSON data to be searched. It has no
-            effect if data_to_search isn't a JSON value or doesn't contain a
-            JSON field.
-        analyzer (str, optional):
-            A named argument with a STRING value. Takes one of the following
-            values to indicate the text analyzer to use: 'LOG_ANALYZER',
-            'NO_OP_ANALYZER', 'PATTERN_ANALYZER'.
-        analyzer_options (str, optional):
-            A named argument with a JSON-formatted STRING value. Takes a list
-            of text analysis rules.
 
     Returns:
         bigframes.series.Series: A new Series with the boolean result.
     """
     import bigframes.operations.search_ops as search_ops
     import bigframes.series
 
-    if not isinstance(data_to_search, (bigframes.series.Series, bigframes.dataframe.DataFrame)):
+    if not isinstance(
+        data_to_search, (bigframes.series.Series, bigframes.dataframe.DataFrame)
+    ):
         raise ValueError("data_to_search must be a Series or DataFrame")
 
     if isinstance(data_to_search, bigframes.dataframe.DataFrame):
-        # SEARCH on a table (or dataframe) treats it as a STRUCT
-        # We need to apply the op on the dataframe, which should handle it as a struct or row
-        # However, unary ops are usually applied on Series.
-        # But DataFrame can be passed if we convert it to a struct first?
-        # Or does DataFrame support _apply_unary_op?
-        # bigframes.dataframe.DataFrame does not have _apply_unary_op.
-        # We can convert DataFrame to a Series of Structs.
-        # But SEARCH in BigQuery can take a table reference which is evaluated as a STRUCT.
-        # So creating a struct from all columns seems correct.
+        # SEARCH on a table (or dataframe) treats it as a STRUCT.  For easier
+        # application of a scalar unary op, we convert to a struct proactively
+        # in the expression.
         import bigframes.bigquery._operations.struct as struct_ops
+
         data_to_search = struct_ops.struct(data_to_search)
 
     return data_to_search._apply_unary_op(
         search_ops.SearchOp(
             search_query=search_query,
-            json_scope=json_scope,
-            analyzer=analyzer,
-            analyzer_options=analyzer_options,
         )
     )

bigframes/core/compile/ibis_compiler/__init__.py

@@ -22,4 +22,5 @@
 
 import bigframes.core.compile.ibis_compiler.operations.generic_ops  # noqa: F401
 import bigframes.core.compile.ibis_compiler.operations.geo_ops  # noqa: F401
+import bigframes.core.compile.ibis_compiler.operations.search_ops  # noqa: F401
 import bigframes.core.compile.ibis_compiler.scalar_op_registry  # noqa: F401

bigframes/core/compile/ibis_compiler/operations/search_ops.py

@@ -0,0 +1,40 @@
+# Copyright 2025 Google LLC
+#
+# Licensed 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.
+
+"""
+BigFrames -> Ibis compilation for the operations in bigframes.operations.search_ops.
+
+Please keep implementations in sequential order by op name.
+"""
+
+from __future__ import annotations
+
+from bigframes_vendored.ibis.expr import types as ibis_types
+import bigframes_vendored.ibis.expr.operations.udf as ibis_udf
+
+from bigframes.core.compile.ibis_compiler import scalar_op_compiler
+from bigframes.operations import search_ops
+
+register_unary_op = scalar_op_compiler.scalar_op_compiler.register_unary_op
+
+
+@register_unary_op(search_ops.SearchOp, pass_op=True)
+def search_op_impl(x: ibis_types.Value, op: search_ops.SearchOp):
+    return search(x, op.search_query)
+
+
+@ibis_udf.scalar.builtin(name="search")
+def search(data_to_search, search_query) -> bool:
+    """Checks to see whether a table or other search data contains a set of search terms."""
+    return False  # pragma: NO COVER

bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -2153,43 +2153,6 @@ def str_lstrip_op(  # type: ignore[empty-body]
     """Remove leading and trailing characters."""
 
 
-@scalar_op_compiler.register_unary_op(ops.SearchOp, pass_op=True)
-def search_op_impl(x: ibis_types.Value, op: ops.SearchOp):
-    values = [
-        typing.cast(ibis_generic.Value, x.op()),
-        typing.cast(ibis_generic.Value, ibis_types.literal(op.search_query).op()),
-    ]
-    sql_template = "SEARCH({0}, {1}"
-    arg_index = 2
-    if op.json_scope is not None:
-        values.append(
-            typing.cast(ibis_generic.Value, ibis_types.literal(op.json_scope).op())
-        )
-        sql_template += f", json_scope=>{{{arg_index}}}"
-        arg_index += 1
-    if op.analyzer is not None:
-        values.append(
-            typing.cast(ibis_generic.Value, ibis_types.literal(op.analyzer).op())
-        )
-        sql_template += f", analyzer=>{{{arg_index}}}"
-        arg_index += 1
-    if op.analyzer_options is not None:
-        values.append(
-            typing.cast(
-                ibis_generic.Value, ibis_types.literal(op.analyzer_options).op()
-            )
-        )
-        sql_template += f", analyzer_options=>{{{arg_index}}}"
-        arg_index += 1
-    sql_template += ")"
-
-    return ibis_generic.SqlScalar(
-        ibis_generic.Literal(sql_template, dtype=ibis_dtypes.string),
-        values=tuple(values),
-        output_type=ibis_dtypes.boolean,
-    ).to_expr()
-
-
 @ibis_udf.scalar.builtin(name="rtrim")
 def str_rstrip_op(  # type: ignore[empty-body]
     x: ibis_dtypes.String, to_strip: ibis_dtypes.String

bigframes/core/compile/sqlglot/__init__.py

@@ -25,6 +25,7 @@
 import bigframes.core.compile.sqlglot.expressions.geo_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.json_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.numeric_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.search_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.string_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.struct_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.timedelta_ops  # noqa: F401

bigframes/core/compile/sqlglot/expressions/search_ops.py

@@ -0,0 +1,29 @@
+# Copyright 2025 Google LLC
+#
+# Licensed 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.
+
+from __future__ import annotations
+
+import sqlglot.expressions as sge
+
+from bigframes import operations as ops
+from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
+import bigframes.core.compile.sqlglot.scalar_compiler as scalar_compiler
+
+register_nary_op = scalar_compiler.scalar_op_compiler.register_nary_op
+register_unary_op = scalar_compiler.scalar_op_compiler.register_unary_op
+
+
+@register_unary_op(ops.SearchOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.SearchOp) -> sge.Expression:
+    return sge.func("SEARCH", expr.expr, sge.convert(op.search_query))

bigframes/operations/search_ops.py

@@ -23,9 +23,6 @@
 class SearchOp(base_ops.UnaryOp):
     name: typing.ClassVar[str] = "search"
     search_query: str
-    json_scope: typing.Optional[str] = None
-    analyzer: typing.Optional[str] = None
-    analyzer_options: typing.Optional[str] = None
 
     def output_type(self, *input_types):
         return dtypes.BOOL_DTYPE