Merge branch 'main' into dbt-sample

Author: jialuoo

bigframes/core/compile/scalar_op_compiler.py

@@ -487,9 +487,9 @@ def isalpha_op_impl(x: ibis_types.Value):
 
 @scalar_op_compiler.register_unary_op(ops.isdigit_op)
 def isdigit_op_impl(x: ibis_types.Value):
-    # Based on docs, should include superscript/subscript-ed numbers
-    # Tests however pass only when set to Nd unicode class
-    return typing.cast(ibis_types.StringValue, x).re_search(r"^(\p{Nd})+$")
+    return typing.cast(ibis_types.StringValue, x).re_search(
+        r"^[\p{Nd}\x{00B9}\x{00B2}\x{00B3}\x{2070}\x{2074}-\x{2079}\x{2080}-\x{2089}]+$"
+    )
 
 
 @scalar_op_compiler.register_unary_op(ops.isdecimal_op)

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

@@ -23,13 +23,52 @@
 from bigframes.core.compile.sqlglot.expressions.op_registration import OpRegistration
 from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
 
+_NAN = sge.Cast(this=sge.convert("NaN"), to="FLOAT64")
+_INF = sge.Cast(this=sge.convert("Infinity"), to="FLOAT64")
+
+# Approx Highest number you can pass in to EXP function and get a valid FLOAT64 result
+# FLOAT64 has 11 exponent bits, so max values is about 2**(2**10)
+# ln(2**(2**10)) == (2**10)*ln(2) ~= 709.78, so EXP(x) for x>709.78 will overflow.
+_FLOAT64_EXP_BOUND = sge.convert(709.78)
+
 UNARY_OP_REGISTRATION = OpRegistration()
 
 
 def compile(op: ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
     return UNARY_OP_REGISTRATION[op](op, expr)
 
 
+@UNARY_OP_REGISTRATION.register(ops.arccos_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.Case(
+        ifs=[
+            sge.If(
+                this=sge.func("ABS", expr.expr) > sge.convert(1),
+                true=_NAN,
+            )
+        ],
+        default=sge.func("ACOS", expr.expr),
+    )
+
+
+@UNARY_OP_REGISTRATION.register(ops.arcsin_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.Case(
+        ifs=[
+            sge.If(
+                this=sge.func("ABS", expr.expr) > sge.convert(1),
+                true=_NAN,
+            )
+        ],
+        default=sge.func("ASIN", expr.expr),
+    )
+
+
+@UNARY_OP_REGISTRATION.register(ops.arctan_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.func("ATAN", expr.expr)
+
+
 @UNARY_OP_REGISTRATION.register(ops.ArrayToStringOp)
 def _(op: ops.ArrayToStringOp, expr: TypedExpr) -> sge.Expression:
     return sge.ArrayToString(this=expr.expr, expression=f"'{op.delimiter}'")
@@ -72,6 +111,49 @@ def _(op: ops.ArraySliceOp, expr: TypedExpr) -> sge.Expression:
     return sge.array(selected_elements)
 
 
+@UNARY_OP_REGISTRATION.register(ops.cos_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.func("COS", expr.expr)
+
+
+@UNARY_OP_REGISTRATION.register(ops.hash_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.func("FARM_FINGERPRINT", expr.expr)
+
+
+@UNARY_OP_REGISTRATION.register(ops.isnull_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.Is(this=expr.expr, expression=sge.Null())
+
+
+@UNARY_OP_REGISTRATION.register(ops.notnull_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.Not(this=sge.Is(this=expr.expr, expression=sge.Null()))
+
+
+@UNARY_OP_REGISTRATION.register(ops.sin_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.func("SIN", expr.expr)
+
+
+@UNARY_OP_REGISTRATION.register(ops.sinh_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.Case(
+        ifs=[
+            sge.If(
+                this=sge.func("ABS", expr.expr) > _FLOAT64_EXP_BOUND,
+                true=sge.func("SIGN", expr.expr) * _INF,
+            )
+        ],
+        default=sge.func("SINH", expr.expr),
+    )
+
+
+@UNARY_OP_REGISTRATION.register(ops.tan_op)
+def _(op: ops.base_ops.UnaryOp, expr: TypedExpr) -> sge.Expression:
+    return sge.func("TAN", expr.expr)
+
+
 # JSON Ops
 @UNARY_OP_REGISTRATION.register(ops.JSONExtract)
 def _(op: ops.JSONExtract, expr: TypedExpr) -> sge.Expression:

samples/snippets/sessions_and_io_test.py

@@ -0,0 +1,169 @@
+# 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.
+
+
+def test_sessions_and_io(project_id: str, dataset_id: str) -> None:
+    YOUR_PROJECT_ID = project_id
+    YOUR_LOCATION = "us"
+
+    # [START bigquery_dataframes_create_and_use_session_instance]
+    import bigframes
+    import bigframes.pandas as bpd
+
+    # Create session object
+    context = bigframes.BigQueryOptions(
+        project=YOUR_PROJECT_ID,
+        location=YOUR_LOCATION,
+    )
+    session = bigframes.Session(context)
+
+    # Load a BigQuery table into a dataframe
+    df1 = session.read_gbq("bigquery-public-data.ml_datasets.penguins")
+
+    # Create a dataframe with local data:
+    df2 = bpd.DataFrame({"my_col": [1, 2, 3]}, session=session)
+    # [END bigquery_dataframes_create_and_use_session_instance]
+    assert df1 is not None
+    assert df2 is not None
+
+    # [START bigquery_dataframes_combine_data_from_multiple_sessions_raise_error]
+    import bigframes
+    import bigframes.pandas as bpd
+
+    context = bigframes.BigQueryOptions(location=YOUR_LOCATION, project=YOUR_PROJECT_ID)
+
+    session1 = bigframes.Session(context)
+    session2 = bigframes.Session(context)
+
+    series1 = bpd.Series([1, 2, 3, 4, 5], session=session1)
+    series2 = bpd.Series([1, 2, 3, 4, 5], session=session2)
+
+    try:
+        series1 + series2
+    except ValueError as e:
+        print(e)  # Error message: Cannot use combine sources from multiple sessions
+    # [END bigquery_dataframes_combine_data_from_multiple_sessions_raise_error]
+
+    # [START bigquery_dataframes_set_options_for_global_session]
+    import bigframes.pandas as bpd
+
+    # Set project ID for the global session
+    bpd.options.bigquery.project = YOUR_PROJECT_ID
+    # Update the global default session location
+    bpd.options.bigquery.location = YOUR_LOCATION
+    # [END bigquery_dataframes_set_options_for_global_session]
+
+    # [START bigquery_dataframes_global_session_is_the_default_session]
+    # The following two statements are essentiall the same
+    df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins")
+    df = bpd.get_global_session().read_gbq("bigquery-public-data.ml_datasets.penguins")
+    # [END bigquery_dataframes_global_session_is_the_default_session]
+    assert df is not None
+
+    # [START bigquery_dataframes_create_dataframe_from_py_and_np]
+    import numpy as np
+
+    import bigframes.pandas as bpd
+
+    s = bpd.Series([1, 2, 3])
+
+    # Create a dataframe with Python dict
+    df = bpd.DataFrame(
+        {
+            "col_1": [1, 2, 3],
+            "col_2": [4, 5, 6],
+        }
+    )
+
+    # Create a series with Numpy
+    s = bpd.Series(np.arange(10))
+    # [END bigquery_dataframes_create_dataframe_from_py_and_np]
+    assert s is not None
+
+    # [START bigquery_dataframes_create_dataframe_from_pandas]
+    import numpy as np
+    import pandas as pd
+
+    import bigframes.pandas as bpd
+
+    pd_df = pd.DataFrame(np.random.randn(4, 2))
+
+    # Convert Pandas dataframe to BigQuery DataFrame with read_pandas()
+    df_1 = bpd.read_pandas(pd_df)
+    # Convert Pandas dataframe to BigQuery DataFrame with the dataframe constructor
+    df_2 = bpd.DataFrame(pd_df)
+    # [END bigquery_dataframes_create_dataframe_from_pandas]
+    assert df_1 is not None
+    assert df_2 is not None
+
+    # [START bigquery_dataframes_convert_bq_dataframe_to_pandas]
+    import bigframes.pandas as bpd
+
+    bf_df = bpd.DataFrame({"my_col": [1, 2, 3]})
+    # Returns a Pandas Dataframe
+    bf_df.to_pandas()
+
+    bf_s = bpd.Series([1, 2, 3])
+    # Returns a Pandas Series
+    bf_s.to_pandas()
+    # [END bigquery_dataframes_convert_bq_dataframe_to_pandas]
+    assert bf_s.to_pandas() is not None
+
+    # [START bigquery_dataframes_to_pandas_dry_run]
+    import bigframes.pandas as bpd
+
+    df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins")
+
+    # Returns a Pandas series with dry run stats
+    df.to_pandas(dry_run=True)
+    # [END bigquery_dataframes_to_pandas_dry_run]
+    assert df.to_pandas(dry_run=True) is not None
+
+    # [START bigquery_dataframes_read_data_from_csv]
+    import bigframes.pandas as bpd
+
+    # Read a CSV file from GCS
+    df = bpd.read_csv("gs://cloud-samples-data/bigquery/us-states/us-states.csv")
+    # [END bigquery_dataframes_read_data_from_csv]
+    assert df is not None
+
+    # [START bigquery_dataframes_read_data_from_bigquery_table]
+    import bigframes.pandas as bpd
+
+    df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins")
+    # [END bigquery_dataframes_read_data_from_bigquery_table]
+    assert df is not None
+
+    # [START bigquery_dataframes_read_from_sql_query]
+    import bigframes.pandas as bpd
+
+    sql = """
+    SELECT species, island, body_mass_g
+    FROM bigquery-public-data.ml_datasets.penguins
+    WHERE sex = 'MALE'
+    """
+
+    df = bpd.read_gbq(sql)
+    # [END bigquery_dataframes_read_from_sql_query]
+    assert df is not None
+
+    table_name = "snippets-session-and-io-test"
+
+    # [START bigquery_dataframes_dataframe_to_bigquery_table]
+    import bigframes.pandas as bpd
+
+    df = bpd.DataFrame({"my_col": [1, 2, 3]})
+
+    df.to_gbq(f"{project_id}.{dataset_id}.{table_name}")
+    # [END bigquery_dataframes_dataframe_to_bigquery_table]

tests/system/small/operations/test_strings.py

@@ -324,13 +324,10 @@ def test_isalpha(weird_strings, weird_strings_pd):
     )
 
 
-@pytest.mark.skipif(
-    "dev" in pa.__version__,
-    # b/333484335 pyarrow is inconsistent on the behavior
-    reason="pyarrow dev version is inconsistent on isdigit behavior.",
-)
 def test_isdigit(weird_strings, weird_strings_pd):
-    pd_result = weird_strings_pd.str.isdigit()
+    # check the behavior against normal pandas str, since pyarrow has a bug with superscripts/fractions b/333484335
+    # astype object instead of str to support pd.NA
+    pd_result = weird_strings_pd.astype(object).str.isdigit()
     bf_result = weird_strings.str.isdigit().to_pandas()
 
     pd.testing.assert_series_equal(

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_arccos/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `float64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    CASE WHEN ABS(`bfcol_0`) > 1 THEN CAST('NaN' AS FLOAT64) ELSE ACOS(`bfcol_0`) END AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `float64_col`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_arcsin/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `float64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    CASE WHEN ABS(`bfcol_0`) > 1 THEN CAST('NaN' AS FLOAT64) ELSE ASIN(`bfcol_0`) END AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `float64_col`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_arctan/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `float64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    ATAN(`bfcol_0`) AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `float64_col`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_cos/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `float64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    COS(`bfcol_0`) AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `float64_col`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_hash/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `string_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    FARM_FINGERPRINT(`bfcol_0`) AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `string_col`
+FROM `bfcte_1`

tests/unit/core/compile/sqlglot/expressions/snapshots/test_unary_compiler/test_isnull/out.sql

@@ -0,0 +1,13 @@
+WITH `bfcte_0` AS (
+  SELECT
+    `float64_col` AS `bfcol_0`
+  FROM `bigframes-dev`.`sqlglot_test`.`scalar_types`
+), `bfcte_1` AS (
+  SELECT
+    *,
+    `bfcol_0` IS NULL AS `bfcol_1`
+  FROM `bfcte_0`
+)
+SELECT
+  `bfcol_1` AS `float64_col`
+FROM `bfcte_1`