bigframes 2.42.0__tar.gz → 2.44.0__tar.gz

{bigframes-2.42.0/bigframes.egg-info → bigframes-2.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bigframes
-Version: 2.42.0
+Version: 2.44.0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://dataframes.bigquery.dev
 Download-URL: https://github.com/googleapis/google-cloud-python/tree/main/packages/bigframes/releases
@@ -42,7 +42,7 @@ Requires-Dist: grpc-google-iam-v1>=0.14.2
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: pandas>=1.5.3
 Requires-Dist: pandas-gbq>=0.26.1
-Requires-Dist: pyarrow>=15.0.2
+Requires-Dist: pyarrow>=23.0.1
 Requires-Dist: pydata-google-auth>=1.8.2
 Requires-Dist: requests>=2.27.1
 Requires-Dist: shapely>=1.8.5

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/_config/experiment_options.py

@@ -28,6 +28,7 @@ class ExperimentOptions:
         self._semantic_operators: bool = False
         self._ai_operators: bool = False
         self._sql_compiler: Literal["legacy", "stable", "experimental"] = "stable"
+        self._enable_python_transpiler: bool = False
 
     @property
     def semantic_operators(self) -> bool:
@@ -166,3 +167,17 @@ class ExperimentOptions:
         warnings.warn(msg, category=bfe.ApiDeprecationWarning)
 
         bigframes.options.display.blob_display_height = value
+
+    @property
+    def enable_python_transpiler(self) -> bool:
+        return self._enable_python_transpiler
+
+    @enable_python_transpiler.setter
+    def enable_python_transpiler(self, value: bool):
+        if value:
+            msg = bfe.format_message(
+                "Python transpiler is an unstable, experimental feature, and not yet fully "
+                "validated, use at your own risk."
+            )
+            warnings.warn(msg, category=bfe.PythonTranspilerPreviewWarning)
+        self._enable_python_transpiler = value

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/_tools/docs.py

@@ -34,6 +34,20 @@ def inherit_docs(source_class):
                         except AttributeError:
                             pass
 
+                        underlying = None
+                        if isinstance(target_item, property):
+                            underlying = target_item.fget
+                        elif hasattr(target_item, "__func__"):
+                            underlying = target_item.__func__
+                        elif hasattr(target_item, "func"):
+                            underlying = getattr(target_item, "func", None)
+
+                        if underlying is not None:
+                            try:
+                                underlying.__doc__ = source_item.__doc__
+                            except AttributeError:
+                                pass
+
         return target_class
 
     return decorator

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/bigquery/__init__.py

@@ -114,6 +114,33 @@ from bigframes.operations.googlesql.global_namespace.array import (
     flatten,
     generate_array,
 )
+from bigframes.operations.googlesql.global_namespace.bit import (
+    bit_count,
+)
+from bigframes.operations.googlesql.global_namespace.conversion import (
+    bool_,
+    double,
+    float64,
+    int64,
+    parse_bignumeric,
+    parse_numeric,
+    string,
+)
+from bigframes.operations.googlesql.global_namespace.date import (
+    current_date,
+    date,
+    date_add,
+    date_diff,
+    date_from_unix_date,
+    date_sub,
+    date_trunc,
+    extract,
+    format_date,
+    generate_date_array,
+    last_day,
+    parse_date,
+    unix_date,
+)
 
 _functions = [
     # approximate aggregate ops
@@ -134,6 +161,30 @@ _functions = [
     array_to_string,
     flatten,
     generate_array,
+    # bit ops
+    bit_count,
+    # conversion ops
+    bool_,
+    double,
+    float64,
+    int64,
+    parse_bignumeric,
+    parse_numeric,
+    string,
+    # date ops
+    current_date,
+    date,
+    date_add,
+    date_diff,
+    date_from_unix_date,
+    date_sub,
+    date_trunc,
+    extract,
+    format_date,
+    generate_date_array,
+    last_day,
+    parse_date,
+    unix_date,
     # datetime ops
     unix_micros,
     unix_millis,
@@ -208,6 +259,30 @@ __all__ = [
     "array_to_string",
     "flatten",
     "generate_array",
+    # bit ops
+    "bit_count",
+    # conversion ops
+    "bool_",
+    "double",
+    "float64",
+    "int64",
+    "parse_bignumeric",
+    "parse_numeric",
+    "string",
+    # date ops
+    "current_date",
+    "date",
+    "date_add",
+    "date_diff",
+    "date_from_unix_date",
+    "date_sub",
+    "date_trunc",
+    "extract",
+    "format_date",
+    "generate_date_array",
+    "last_day",
+    "parse_date",
+    "unix_date",
     # datetime ops
     "unix_micros",
     "unix_millis",

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/bigquery/_operations/ai.py

@@ -87,7 +87,7 @@ def generate(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -178,7 +178,7 @@ def generate_bool(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -252,7 +252,7 @@ def generate_int(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -326,7 +326,7 @@ def generate_double(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML selects a recent stable
             version of Gemini to use.
@@ -809,7 +809,7 @@ def if_(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an ENDPOINT value, BigQuery ML dynamically chooses a model based on your query to have the
             best cost to quality tradeoff for the task.
@@ -960,7 +960,7 @@ def score(
             Specifies the connection to use to communicate with the model. For example, ``myproject.us.myconnection``.
             If not provided, the query uses your end-user credential.
         endpoint (str, optional):
-            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-2.5-flash"``. You can specify any
+            Specifies the Vertex AI endpoint to use for the model. For example ``"gemini-3.5-flash"``. You can specify any
             generally available or preview Gemini model. If you specify the model name, BigQuery ML automatically identifies and
             uses the full endpoint of the model. If you don't specify an endpoint value, BigQuery ML dynamically chooses a model
             based on your query to have the best cost to quality tradeoff for the task.

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/core/block_transforms.py

@@ -14,8 +14,9 @@
 from __future__ import annotations
 
 import functools
+import inspect
 import typing
-from typing import Optional, Sequence
+from typing import Callable, Hashable, Optional, Sequence
 
 import bigframes_vendored.constants as constants
 import pandas as pd
@@ -23,13 +24,48 @@ import pandas as pd
 import bigframes.constants
 import bigframes.core as core
 import bigframes.core.blocks as blocks
+import bigframes.core.bytecode as bytecode
 import bigframes.core.expression as ex
 import bigframes.core.ordering as ordering
 import bigframes.core.window_spec as windows
 import bigframes.dtypes as dtypes
 import bigframes.operations as ops
 import bigframes.operations.aggregations as agg_ops
-from bigframes.core import agg_expressions
+from bigframes.core import agg_expressions, py_expressions
+
+
+def apply_to_block_rows(
+    func: Callable, block: blocks.Block, *args, **kwargs
+) -> blocks.Block:
+    """
+    Apply the given function to each row of the block.
+
+    The function is applied to each row of the block, and the result is returned
+    as a new block with the same index.
+    """
+    expr = bytecode._compile_bytecode_to_py_expr(func)
+    sig = inspect.signature(func)
+
+    bindings: dict[Hashable, ex.Expression] = {}
+
+    bound_args = sig.bind(*(None, *args), **kwargs)
+    bound_args.apply_defaults()
+    bound_params = bound_args.arguments
+    for name, value in bound_params.items():
+        bindings[name] = ex.const(value)
+
+    expr = py_expressions.resolve_py_exprs(
+        expr,
+        series_arg=next(iter(sig.parameters.keys())),
+        series_attrs={
+            label: col_id
+            for label in block.column_labels
+            if (col_id := block.resolve_label_exact(label)) is not None
+        },
+    )
+    expr = expr.bind_variables(bindings)
+
+    return block.project_exprs([expr], labels=[None], drop=True)
 
 
 def equals(block1: blocks.Block, block2: blocks.Block) -> bool:

bigframes-2.44.0/bigframes/core/bytecode.py

@@ -0,0 +1,260 @@
+# Copyright 2026 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.
+
+import dis
+import operator
+import sys
+from types import ModuleType
+from typing import Callable
+
+import bigframes.core.py_expressions as py_exprs
+from bigframes.core import expression
+
+_BINARY_OP_MAP = {
+    "+": operator.add,
+    "-": operator.sub,
+    "*": operator.mul,
+    "/": operator.truediv,
+    "//": operator.floordiv,
+    "%": operator.mod,
+    "**": operator.pow,
+}
+
+_COMPARE_OP_MAP = {
+    "==": operator.eq,
+    "!=": operator.ne,
+    "<": operator.lt,
+    "<=": operator.le,
+    ">": operator.gt,
+    ">=": operator.ge,
+}
+
+_OLD_BINARY_OP_MAP = {
+    "BINARY_ADD": operator.add,
+    "INPLACE_ADD": operator.add,
+    "BINARY_SUBTRACT": operator.sub,
+    "INPLACE_SUBTRACT": operator.sub,
+    "BINARY_MULTIPLY": operator.mul,
+    "INPLACE_MULTIPLY": operator.mul,
+    "BINARY_TRUE_DIVIDE": operator.truediv,
+    "INPLACE_TRUE_DIVIDE": operator.truediv,
+    "BINARY_FLOOR_DIVIDE": operator.floordiv,
+    "INPLACE_FLOOR_DIVIDE": operator.floordiv,
+    "BINARY_MODULO": operator.mod,
+    "INPLACE_MODULO": operator.mod,
+    "BINARY_POWER": operator.pow,
+    "INPLACE_POWER": operator.pow,
+}
+
+
+_NULL = py_exprs.PyObject(None)
+
+
+def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
+    instructions = list(dis.get_instructions(func))
+
+    stack: list[expression.Expression] = []
+    globals_dict = func.__globals__
+    import builtins
+
+    builtins_dict = builtins.__dict__
+
+    closure_dict = {}
+    if func.__closure__:
+        free_vars = func.__code__.co_freevars
+        for var, cell in zip(free_vars, func.__closure__):
+            try:
+                closure_dict[var] = cell.cell_contents
+            except ValueError:
+                pass
+
+    for inst in instructions:
+        opname = inst.opname
+
+        if opname in ("RESUME", "PRECALL"):
+            continue
+
+        elif opname in ("LOAD_FAST_LOAD_FAST", "LOAD_FAST_BORROW_LOAD_FAST_BORROW"):
+            var1, var2 = inst.argval
+            stack.append(expression.UnboundVariableExpression(var1))
+            stack.append(expression.UnboundVariableExpression(var2))
+
+        elif opname.startswith("LOAD_FAST"):
+            stack.append(expression.UnboundVariableExpression(inst.argval))
+
+        elif opname in ("LOAD_CONST", "LOAD_SMALL_INT"):
+            stack.append(py_exprs.PyObject(inst.argval))
+
+        elif opname == "LOAD_GLOBAL":
+            # In Python 3.11+, the lowest bit of inst.arg indicates that a NULL
+            # should be pushed before the global variable.
+            if sys.version_info >= (3, 11) and inst.arg is not None and (inst.arg & 1):
+                stack.append(_NULL)
+            name = inst.argval
+            found = False
+            val = None
+            if name in closure_dict:
+                val = closure_dict[name]
+                found = True
+            elif name in globals_dict:
+                val = globals_dict[name]
+                found = True
+            elif name in builtins_dict:
+                val = builtins_dict[name]
+                found = True
+
+            if found:
+                if isinstance(val, ModuleType):
+                    stack.append(py_exprs.Module(val))
+                else:
+                    stack.append(py_exprs.PyObject(val))
+            else:
+                stack.append(expression.UnboundVariableExpression(name))
+
+        elif opname in ("LOAD_ATTR", "LOAD_METHOD"):
+            if not stack:
+                raise ValueError("Stack is empty")
+            target = stack.pop()
+            stack.append(py_exprs.GetAttr(target, inst.argval))
+            if opname == "LOAD_METHOD":
+                if isinstance(target, py_exprs.Module):
+                    stack.append(_NULL)
+                else:
+                    stack.append(target)
+
+        elif opname == "PUSH_NULL":
+            stack.append(_NULL)
+
+        elif opname == "BINARY_OP":
+            if len(stack) < 2:
+                raise ValueError("Stack is empty")
+            right = stack.pop()
+            left = stack.pop()
+            op_symbol = inst.argrepr
+            if not op_symbol and isinstance(inst.argval, str):
+                op_symbol = inst.argval
+            if op_symbol and op_symbol.endswith("="):
+                op_symbol = op_symbol[:-1]
+
+            if op_symbol not in _BINARY_OP_MAP:
+                raise ValueError(f"Unsupported binary operator: {op_symbol}")
+            stack.append(
+                py_exprs.Call(
+                    py_exprs.PyObject(_BINARY_OP_MAP[op_symbol]), (left, right)
+                )
+            )
+
+        # Support older Python versions compatibility
+        elif opname in _OLD_BINARY_OP_MAP:
+            if len(stack) < 2:
+                raise ValueError("Stack has < 2 elements")
+            right = stack.pop()
+            left = stack.pop()
+            stack.append(
+                py_exprs.Call(
+                    py_exprs.PyObject(_OLD_BINARY_OP_MAP[opname]), (left, right)
+                )
+            )
+
+        elif opname == "COMPARE_OP":
+            if len(stack) < 2:
+                raise ValueError("Stack has < 2 elements")
+            right = stack.pop()
+            left = stack.pop()
+            op_symbol = inst.argval
+            if op_symbol not in _COMPARE_OP_MAP:
+                raise ValueError(f"Unsupported compare operator: {op_symbol}")
+            stack.append(
+                py_exprs.Call(
+                    py_exprs.PyObject(_COMPARE_OP_MAP[op_symbol]), (left, right)
+                )
+            )
+
+        elif opname in ("UNARY_NEGATIVE", "UNARY_INVERT"):
+            if not stack:
+                raise ValueError("Stack is empty")
+            target = stack.pop()
+            stack.append(
+                py_exprs.Call(
+                    py_exprs.PyObject(
+                        operator.neg if opname == "UNARY_NEGATIVE" else operator.invert
+                    ),
+                    (target,),
+                )
+            )
+
+        elif opname == "UNARY_POSITIVE":
+            if not stack:
+                raise ValueError("Stack is empty")
+            target = stack.pop()
+            stack.append(py_exprs.Call(py_exprs.PyObject(operator.pos), (target,)))
+
+        elif opname == "CALL_INTRINSIC_1":
+            if inst.argrepr == "INTRINSIC_UNARY_POSITIVE":
+                if not stack:
+                    raise ValueError("Stack is empty")
+                target = stack.pop()
+                stack.append(py_exprs.Call(py_exprs.PyObject(operator.pos), (target,)))
+            else:
+                raise ValueError(f"Unsupported intrinsic: {inst.argrepr}")
+
+        elif opname in ("CALL", "CALL_FUNCTION", "CALL_METHOD"):
+            num_args = inst.arg
+            assert num_args is not None
+            if len(stack) < num_args:
+                raise ValueError("Stack has < 2 elements")
+            args = [stack.pop() for _ in range(num_args)][::-1]
+            # In Python 3.11, LOAD_GLOBAL with NULL push puts NULL below the global.
+            # If NULL is below the callable on the stack, swap them to match
+            # the expected layout [callable, NULL].
+            if len(stack) >= 2 and stack[-2] == _NULL:
+                stack[-1], stack[-2] = stack[-2], stack[-1]
+            if stack and stack[-1] == _NULL:
+                stack.pop()
+            elif (
+                stack
+                and stack[-1] != _NULL
+                and isinstance(stack[-1], expression.Expression)
+            ):
+                self_arg = stack.pop()
+                args = [self_arg] + args
+            if not stack:
+                raise ValueError("Stack is empty")
+            callable_expr = stack.pop()
+            stack.append(py_exprs.Call(callable_expr, tuple(args)))
+
+        elif opname == "RETURN_VALUE":
+            if not stack:
+                raise ValueError("Stack is empty")
+            return stack[-1]
+
+        elif opname in ("STORE_FAST", "POP_TOP"):
+            if stack:
+                stack.pop()
+
+        else:
+            raise ValueError(f"Unsupported opcode: {opname}")
+
+    raise ValueError("No return value found")
+
+
+def py_to_expression(func: Callable) -> expression.Expression:
+    """
+    Try to convert a python function to a BigQuery expression.
+
+    This is "best effort" - if the function contains operations that cannot
+    be converted to BigQuery expressions, it will raise an Exception.
+    """
+    py_expr = _compile_bytecode_to_py_expr(func)
+    return py_exprs.resolve_py_exprs(py_expr)

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -922,35 +922,6 @@ def astype_op_impl(x: ibis_types.Value, op: ops.AsTypeOp):
         elif to_type == ibis_dtypes.time:
             return x_converted.time()
 
-    if to_type == ibis_dtypes.json:
-        if x.type() == ibis_dtypes.string:
-            return parse_json_in_safe(x) if op.safe else parse_json(x)
-        if x.type() == ibis_dtypes.bool:
-            x_bool = typing.cast(
-                ibis_types.StringValue,
-                bigframes.core.compile.ibis_types.cast_ibis_value(
-                    x, ibis_dtypes.string, safe=op.safe
-                ),
-            ).lower()
-            return parse_json_in_safe(x_bool) if op.safe else parse_json(x_bool)
-        if x.type() in (ibis_dtypes.int64, ibis_dtypes.float64):
-            x_str = bigframes.core.compile.ibis_types.cast_ibis_value(
-                x, ibis_dtypes.string, safe=op.safe
-            )
-            return parse_json_in_safe(x_str) if op.safe else parse_json(x_str)
-
-    if x.type() == ibis_dtypes.json:
-        if to_type == ibis_dtypes.int64:
-            return cast_json_to_int64_in_safe(x) if op.safe else cast_json_to_int64(x)
-        if to_type == ibis_dtypes.float64:
-            return (
-                cast_json_to_float64_in_safe(x) if op.safe else cast_json_to_float64(x)
-            )
-        if to_type == ibis_dtypes.bool:
-            return cast_json_to_bool_in_safe(x) if op.safe else cast_json_to_bool(x)
-        if to_type == ibis_dtypes.string:
-            return cast_json_to_string_in_safe(x) if op.safe else cast_json_to_string(x)
-
     # TODO: either inline this function, or push rest of this op into the function
     return bigframes.core.compile.ibis_types.cast_ibis_value(x, to_type, safe=op.safe)
 
@@ -1193,9 +1164,27 @@ def parse_json_op_impl(x: ibis_types.Value, op: ops.ParseJSON):
     return parse_json(json_str=x)
 
 
-@scalar_op_compiler.register_unary_op(ops.ToJSON)
-def to_json_op_impl(json_obj: ibis_types.Value):
-    return to_json(json_obj=json_obj)
+@scalar_op_compiler.register_unary_op(ops.ToJSON, pass_op=True)
+def to_json_op_impl(x: ibis_types.Value, op: ops.ToJSON):
+    if x.type() == ibis_dtypes.string:
+        return parse_json_in_safe(x) if op.safe else parse_json(x)
+    return x.isnull().ifelse(ibis.null().cast(ibis_dtypes.json), to_json(x))
+
+
+@scalar_op_compiler.register_unary_op(ops.JSONDecode, pass_op=True)
+def json_decode_op_impl(x: ibis_types.Value, op: ops.JSONDecode):
+    to_type = bigframes.core.compile.ibis_types.bigframes_dtype_to_ibis_dtype(
+        op.to_type
+    )
+    if to_type == ibis_dtypes.int64:
+        return cast_json_to_int64_in_safe(x) if op.safe else cast_json_to_int64(x)
+    if to_type == ibis_dtypes.float64:
+        return cast_json_to_float64_in_safe(x) if op.safe else cast_json_to_float64(x)
+    if to_type == ibis_dtypes.bool:
+        return cast_json_to_bool_in_safe(x) if op.safe else cast_json_to_bool(x)
+    if to_type == ibis_dtypes.string:
+        return cast_json_to_string_in_safe(x) if op.safe else cast_json_to_string(x)
+    raise TypeError(f"Cannot cast from JSON to type {to_type}")
 
 
 @scalar_op_compiler.register_unary_op(ops.ToJSONString)

{bigframes-2.42.0 → bigframes-2.44.0}/bigframes/core/compile/polars/compiler.py

@@ -138,11 +138,20 @@ if polars_installed:
         Should be extended to dispatch based on bigframes schema types.
         """
 
-        @functools.singledispatchmethod
+        _expr_types: dict[int, bigframes.dtypes.ExpressionType] = dataclasses.field(
+            default_factory=dict, init=False, compare=False
+        )
+
         def compile_expression(self, expression: ex.Expression) -> pl.Expr:
+            res = self._compile_expression(expression)
+            self._expr_types[id(res)] = expression.output_type
+            return res
+
+        @functools.singledispatchmethod
+        def _compile_expression(self, expression: ex.Expression) -> pl.Expr:
             raise NotImplementedError(f"Cannot compile expression: {expression}")
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.ScalarConstantExpression,
@@ -159,21 +168,21 @@ if polars_installed:
 
             return pl.lit(value, _bigframes_dtype_to_polars_dtype(expression.dtype))
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.DerefOp,
         ) -> pl.Expr:
             return pl.col(expression.id.sql)
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.ResolvedDerefOp,
         ) -> pl.Expr:
             return pl.col(expression.id.sql)
 
-        @compile_expression.register
+        @_compile_expression.register
         def _(
             self,
             expression: ex.OpExpression,
@@ -478,10 +487,21 @@ if polars_installed:
             )
 
         @compile_op.register(json_ops.JSONDecode)
-        def _(self, op: ops.ScalarOp, input: pl.Expr) -> pl.Expr:
+        def _(self, op: json_ops.JSONDecode, input: pl.Expr) -> pl.Expr:
             assert isinstance(op, json_ops.JSONDecode)
             return input.str.json_decode(_DTYPE_MAPPING[op.to_type])
 
+        @compile_op.register(json_ops.ToJSON)
+        def _(self, op: json_ops.ToJSON, input: pl.Expr) -> pl.Expr:
+            from_type = self._expr_types.get(id(input))
+            if from_type in (
+                bigframes.dtypes.STRING_DTYPE,
+                bigframes.dtypes.JSON_DTYPE,
+            ):
+                return input
+            else:
+                return input.cast(pl.String())
+
         @compile_op.register(arr_ops.ToArrayOp)
         def _(self, op: ops.ToArrayOp, *inputs: pl.Expr) -> pl.Expr:
             return pl.concat_list(*inputs)