Merge remote-tracking branch 'github/main' into groupby_describe

Author: TrevorBergeron

bigframes/_config/bigquery_options.py

@@ -22,7 +22,6 @@
 import google.auth.credentials
 import requests.adapters
 
-import bigframes._config.auth
 import bigframes._importing
 import bigframes.enums
 import bigframes.exceptions as bfe
@@ -38,7 +37,6 @@
 
 def _get_validated_location(value: Optional[str]) -> Optional[str]:
     import bigframes._tools.strings
-    import bigframes.constants
 
     if value is None or value in bigframes.constants.ALL_BIGQUERY_LOCATIONS:
         return value
@@ -143,52 +141,20 @@ def application_name(self, value: Optional[str]):
             )
         self._application_name = value
 
-    def _try_set_default_credentials_and_project(
-        self,
-    ) -> tuple[google.auth.credentials.Credentials, Optional[str]]:
-        # Don't fetch credentials or project if credentials is already set.
-        # If it's set, we've already authenticated, so if the user wants to
-        # re-auth, they should explicitly reset the credentials.
-        if self._credentials is not None:
-            return self._credentials, self._project
-
-        (
-            credentials,
-            credentials_project,
-        ) = bigframes._config.auth.get_default_credentials_with_project()
-        self._credentials = credentials
-
-        # Avoid overriding an explicitly set project with a default value.
-        if self._project is None:
-            self._project = credentials_project
-
-        return credentials, self._project
-
     @property
-    def credentials(self) -> google.auth.credentials.Credentials:
+    def credentials(self) -> Optional[google.auth.credentials.Credentials]:
         """The OAuth2 credentials to use for this client.
 
-        Set to None to force re-authentication.
-
         Returns:
             None or google.auth.credentials.Credentials:
                 google.auth.credentials.Credentials if exists; otherwise None.
         """
-        if self._credentials:
-            return self._credentials
-
-        credentials, _ = self._try_set_default_credentials_and_project()
-        return credentials
+        return self._credentials
 
     @credentials.setter
     def credentials(self, value: Optional[google.auth.credentials.Credentials]):
         if self._session_started and self._credentials is not value:
             raise ValueError(SESSION_STARTED_MESSAGE.format(attribute="credentials"))
-
-        if value is None:
-            # The user has _explicitly_ asked that we re-authenticate.
-            bigframes._config.auth.reset_default_credentials_and_project()
-
         self._credentials = value
 
     @property
@@ -217,11 +183,7 @@ def project(self) -> Optional[str]:
             None or str:
                 Google Cloud project ID as a string; otherwise None.
         """
-        if self._project:
-            return self._project
-
-        _, project = self._try_set_default_credentials_and_project()
-        return project
+        return self._project
 
     @project.setter
     def project(self, value: Optional[str]):

bigframes/bigquery/__init__.py

@@ -51,6 +51,7 @@
     json_value,
     json_value_array,
     parse_json,
+    to_json,
     to_json_string,
 )
 from bigframes.bigquery._operations.search import create_vector_index, vector_search
@@ -89,6 +90,7 @@
     json_value,
     json_value_array,
     parse_json,
+    to_json,
     to_json_string,
     # search ops
     create_vector_index,

bigframes/bigquery/_operations/json.py

@@ -430,6 +430,40 @@ def json_value_array(
     return input._apply_unary_op(ops.JSONValueArray(json_path=json_path))
 
 
+def to_json(
+    input: series.Series,
+) -> series.Series:
+    """Converts a series with a JSON value to a JSON-formatted STRING value.
+
+    **Examples:**
+
+        >>> import bigframes.pandas as bpd
+        >>> import bigframes.bigquery as bbq
+        >>> bpd.options.display.progress_bar = None
+
+        >>> s = bpd.Series([1, 2, 3])
+        >>> bbq.to_json(s)
+        0    1
+        1    2
+        2    3
+        dtype: extension<dbjson<JSONArrowType>>[pyarrow]
+
+        >>> s = bpd.Series([{"int": 1, "str": "pandas"}, {"int": 2, "str": "numpy"}])
+        >>> bbq.to_json(s)
+        0    {"int":1,"str":"pandas"}
+        1     {"int":2,"str":"numpy"}
+        dtype: extension<dbjson<JSONArrowType>>[pyarrow]
+
+    Args:
+        input (bigframes.series.Series):
+            The Series containing JSON or JSON-formatted string values.
+
+    Returns:
+        bigframes.series.Series: A new Series with the JSON value.
+    """
+    return input._apply_unary_op(ops.ToJSON())
+
+
 def to_json_string(
     input: series.Series,
 ) -> series.Series:

bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -1302,6 +1302,11 @@ 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.ToJSONString)
 def to_json_string_op_impl(x: ibis_types.Value):
     return to_json_string(value=x)
@@ -2093,6 +2098,11 @@ def json_extract_string_array(  # type: ignore[empty-body]
     """Extracts a JSON array and converts it to a SQL ARRAY of STRINGs."""
 
 
+@ibis_udf.scalar.builtin(name="to_json")
+def to_json(json_obj) -> ibis_dtypes.JSON:  # type: ignore[empty-body]
+    """Convert to JSON."""
+
+
 @ibis_udf.scalar.builtin(name="to_json_string")
 def to_json_string(value) -> ibis_dtypes.String:  # type: ignore[empty-body]
     """Convert value to JSON-formatted string."""

bigframes/core/compile/sqlglot/__init__.py

@@ -14,7 +14,18 @@
 from __future__ import annotations
 
 from bigframes.core.compile.sqlglot.compiler import SQLGlotCompiler
+import bigframes.core.compile.sqlglot.expressions.array_ops  # noqa: F401
 import bigframes.core.compile.sqlglot.expressions.binary_compiler  # noqa: F401
-import bigframes.core.compile.sqlglot.expressions.unary_compiler  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.blob_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.comparison_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.date_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.datetime_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.generic_ops  # noqa: F401
+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.string_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.struct_ops  # noqa: F401
+import bigframes.core.compile.sqlglot.expressions.timedelta_ops  # noqa: F401
 
 __all__ = ["SQLGlotCompiler"]

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

@@ -0,0 +1,68 @@
+# 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 typing
+
+import sqlglot
+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_unary_op = scalar_compiler.scalar_op_compiler.register_unary_op
+
+
+@register_unary_op(ops.ArrayToStringOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.ArrayToStringOp) -> sge.Expression:
+    return sge.ArrayToString(this=expr.expr, expression=f"'{op.delimiter}'")
+
+
+@register_unary_op(ops.ArrayIndexOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.ArrayIndexOp) -> sge.Expression:
+    return sge.Bracket(
+        this=expr.expr,
+        expressions=[sge.Literal.number(op.index)],
+        safe=True,
+        offset=False,
+    )
+
+
+@register_unary_op(ops.ArraySliceOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.ArraySliceOp) -> sge.Expression:
+    slice_idx = sqlglot.to_identifier("slice_idx")
+
+    conditions: typing.List[sge.Predicate] = [slice_idx >= op.start]
+
+    if op.stop is not None:
+        conditions.append(slice_idx < op.stop)
+
+    # local name for each element in the array
+    el = sqlglot.to_identifier("el")
+
+    selected_elements = (
+        sge.select(el)
+        .from_(
+            sge.Unnest(
+                expressions=[expr.expr],
+                alias=sge.TableAlias(columns=[el]),
+                offset=slice_idx,
+            )
+        )
+        .where(*conditions)
+    )
+
+    return sge.array(selected_elements)

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

@@ -0,0 +1,33 @@
+# 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_unary_op = scalar_compiler.scalar_op_compiler.register_unary_op
+
+
+@register_unary_op(ops.obj_fetch_metadata_op)
+def _(expr: TypedExpr) -> sge.Expression:
+    return sge.func("OBJ.FETCH_METADATA", expr.expr)
+
+
+@register_unary_op(ops.ObjGetAccessUrl)
+def _(expr: TypedExpr) -> sge.Expression:
+    return sge.func("OBJ.GET_ACCESS_URL", expr.expr)

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

@@ -0,0 +1,59 @@
+# 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 typing
+
+import pandas as pd
+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
+import bigframes.dtypes as dtypes
+
+register_unary_op = scalar_compiler.scalar_op_compiler.register_unary_op
+
+
+@register_unary_op(ops.IsInOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.IsInOp) -> sge.Expression:
+    values = []
+    is_numeric_expr = dtypes.is_numeric(expr.dtype)
+    for value in op.values:
+        if value is None:
+            continue
+        dtype = dtypes.bigframes_type(type(value))
+        if expr.dtype == dtype or is_numeric_expr and dtypes.is_numeric(dtype):
+            values.append(sge.convert(value))
+
+    if op.match_nulls:
+        contains_nulls = any(_is_null(value) for value in op.values)
+        if contains_nulls:
+            return sge.Is(this=expr.expr, expression=sge.Null()) | sge.In(
+                this=expr.expr, expressions=values
+            )
+
+    if len(values) == 0:
+        return sge.convert(False)
+
+    return sge.func(
+        "COALESCE", sge.In(this=expr.expr, expressions=values), sge.convert(False)
+    )
+
+
+# Helpers
+def _is_null(value) -> bool:
+    # float NaN/inf should be treated as distinct from 'true' null values
+    return typing.cast(bool, pd.isna(value)) and not isinstance(value, float)