diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 863a345da1..7e46c73d0d 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,6 +20,7 @@ repos: hooks: - id: trailing-whitespace - id: end-of-file-fixer + exclude: "^tests/unit/core/compile/sqlglot/snapshots" - id: check-yaml - repo: https://github.com/pycqa/isort rev: 5.12.0 diff --git a/CHANGELOG.md b/CHANGELOG.md index b6c08af05e..8cf9b3fc7d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,32 @@ [1]: https://pypi.org/project/bigframes/#history +## [2.3.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.2.0...v2.3.0) (2025-05-06) + + +### Features + +* Add dry_run parameter to `read_gbq()`, `read_gbq_table()` and `read_gbq_query()` ([#1674](https://github.com/googleapis/python-bigquery-dataframes/issues/1674)) ([4c5dee5](https://github.com/googleapis/python-bigquery-dataframes/commit/4c5dee5e6f4b30deb01e258670aa21dbf3ac9aa5)) + + +### Bug Fixes + +* Guarantee guid thread safety across threads ([#1684](https://github.com/googleapis/python-bigquery-dataframes/issues/1684)) ([cb0267d](https://github.com/googleapis/python-bigquery-dataframes/commit/cb0267deea227ea85f20d6dbef8c29cf03526d7a)) +* Support large lists of lists in bpd.Series() constructor ([#1662](https://github.com/googleapis/python-bigquery-dataframes/issues/1662)) ([0f4024c](https://github.com/googleapis/python-bigquery-dataframes/commit/0f4024c84508c17657a9104ef1f8718094827ada)) +* Use value equality to check types for unix epoch functions and timestamp diff ([#1690](https://github.com/googleapis/python-bigquery-dataframes/issues/1690)) ([81e8fb8](https://github.com/googleapis/python-bigquery-dataframes/commit/81e8fb8627f1d35423dbbdcc99d02ab0ad362d11)) + + +### Performance Improvements + +* `to_datetime()` now avoids caching inputs unless data is inspected to infer format ([#1667](https://github.com/googleapis/python-bigquery-dataframes/issues/1667)) ([dd08857](https://github.com/googleapis/python-bigquery-dataframes/commit/dd08857f65140cbe5c524050d2d538949897c3cc)) + + +### Documentation + +* Add a visualization notebook to BigFrame samples ([#1675](https://github.com/googleapis/python-bigquery-dataframes/issues/1675)) ([ee062bf](https://github.com/googleapis/python-bigquery-dataframes/commit/ee062bfc29c27949205ca21d6c1dcd6125300e5e)) +* Fix spacing of k-means code snippet ([#1687](https://github.com/googleapis/python-bigquery-dataframes/issues/1687)) ([99f45dd](https://github.com/googleapis/python-bigquery-dataframes/commit/99f45dd14bd9632d209389a5fef009f18c57adbf)) +* Update snippet for `Create a k-means` model tutorial ([#1664](https://github.com/googleapis/python-bigquery-dataframes/issues/1664)) ([761c364](https://github.com/googleapis/python-bigquery-dataframes/commit/761c364f4df045b9e9d8d3d5fee91d9a87b772db)) + ## [2.2.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v2.1.0...v2.2.0) (2025-04-30) diff --git a/bigframes/core/blocks.py b/bigframes/core/blocks.py index cc3b70f8a8..6426b7b22b 100644 --- a/bigframes/core/blocks.py +++ b/bigframes/core/blocks.py @@ -22,7 +22,6 @@ from __future__ import annotations import ast -import copy import dataclasses import datetime import functools @@ -30,17 +29,7 @@ import random import textwrap import typing -from typing import ( - Any, - Iterable, - List, - Literal, - Mapping, - Optional, - Sequence, - Tuple, - Union, -) +from typing import Iterable, List, Literal, Mapping, Optional, Sequence, Tuple, Union import warnings import bigframes_vendored.constants as constants @@ -69,6 +58,8 @@ import bigframes.exceptions as bfe import bigframes.operations as ops import bigframes.operations.aggregations as agg_ops +from bigframes.session import dry_runs +from bigframes.session import executor as executors # Type constraint for wherever column labels are used Label = typing.Hashable @@ -821,59 +812,18 @@ def _compute_dry_run( if sampling.enable_downsampling: raise NotImplementedError("Dry run with sampling is not supported") - index: List[Any] = [] - values: List[Any] = [] - - index.append("columnCount") - values.append(len(self.value_columns)) - index.append("columnDtypes") - values.append( - { - col: self.expr.get_column_type(self.resolve_label_exact_or_error(col)) - for col in self.column_labels - } - ) - - index.append("indexLevel") - values.append(self.index.nlevels) - index.append("indexDtypes") - values.append(self.index.dtypes) - expr = self._apply_value_keys_to_expr(value_keys=value_keys) query_job = self.session._executor.dry_run(expr, ordered) - job_api_repr = copy.deepcopy(query_job._properties) - - job_ref = job_api_repr["jobReference"] - for key, val in job_ref.items(): - index.append(key) - values.append(val) - - index.append("jobType") - values.append(job_api_repr["configuration"]["jobType"]) - - query_config = job_api_repr["configuration"]["query"] - for key in ("destinationTable", "useLegacySql"): - index.append(key) - values.append(query_config.get(key)) - - query_stats = job_api_repr["statistics"]["query"] - for key in ( - "referencedTables", - "totalBytesProcessed", - "cacheHit", - "statementType", - ): - index.append(key) - values.append(query_stats.get(key)) - index.append("creationTime") - values.append( - pd.Timestamp( - job_api_repr["statistics"]["creationTime"], unit="ms", tz="UTC" - ) - ) + column_dtypes = { + col: self.expr.get_column_type(self.resolve_label_exact_or_error(col)) + for col in self.column_labels + } - return pd.Series(values, index=index), query_job + dry_run_stats = dry_runs.get_query_stats_with_dtypes( + query_job, column_dtypes, self.index.dtypes + ) + return dry_run_stats, query_job def _apply_value_keys_to_expr(self, value_keys: Optional[Iterable[str]] = None): expr = self._expr @@ -1560,12 +1510,19 @@ def retrieve_repr_request_results( """ # head caches full underlying expression, so row_count will be free after - head_result = self.session._executor.head(self.expr, max_results) + executor = self.session._executor + executor.cached( + array_value=self.expr, + config=executors.CacheConfig(optimize_for="head", if_cached="reuse-strict"), + ) + head_result = self.session._executor.execute( + self.expr.slice(start=None, stop=max_results, step=None) + ) row_count = self.session._executor.execute(self.expr.row_count()).to_py_scalar() - df = head_result.to_pandas() - self._copy_index_to_pandas(df) - return df, row_count, head_result.query_job + head_df = head_result.to_pandas() + self._copy_index_to_pandas(head_df) + return head_df, row_count, head_result.query_job def promote_offsets(self, label: Label = None) -> typing.Tuple[Block, str]: expr, result_id = self._expr.promote_offsets() @@ -2535,9 +2492,12 @@ def cached(self, *, force: bool = False, session_aware: bool = False) -> None: # use a heuristic for whether something needs to be cached self.session._executor.cached( self.expr, - force=force, - use_session=session_aware, - cluster_cols=self.index_columns, + config=executors.CacheConfig( + optimize_for="auto" + if session_aware + else executors.HierarchicalKey(tuple(self.index_columns)), + if_cached="replace" if force else "reuse-any", + ), ) def _is_monotonic( diff --git a/bigframes/core/compile/sqlglot/compiler.py b/bigframes/core/compile/sqlglot/compiler.py index cb510ce365..f6d63531da 100644 --- a/bigframes/core/compile/sqlglot/compiler.py +++ b/bigframes/core/compile/sqlglot/compiler.py @@ -15,24 +15,28 @@ import dataclasses import functools -import itertools import typing from google.cloud import bigquery import pyarrow as pa import sqlglot.expressions as sge -from bigframes.core import expression, identifiers, nodes, rewrite +from bigframes.core import expression, guid, identifiers, nodes, rewrite from bigframes.core.compile import configs import bigframes.core.compile.sqlglot.scalar_compiler as scalar_compiler import bigframes.core.compile.sqlglot.sqlglot_ir as ir import bigframes.core.ordering as bf_ordering -@dataclasses.dataclass(frozen=True) class SQLGlotCompiler: """Compiles BigFrame nodes into SQL using SQLGlot.""" + uid_gen: guid.SequentialUIDGenerator + """Generator for unique identifiers.""" + + def __init__(self): + self.uid_gen = guid.SequentialUIDGenerator() + def compile( self, node: nodes.BigFrameNode, @@ -82,7 +86,7 @@ def _compile_sql(self, request: configs.CompileRequest) -> configs.CompileResult result_node = typing.cast( nodes.ResultNode, rewrite.column_pruning(result_node) ) - result_node = _remap_variables(result_node) + result_node = self._remap_variables(result_node) sql = self._compile_result_node(result_node) return configs.CompileResult( sql, result_node.schema.to_bigquery(), result_node.order_by @@ -92,7 +96,7 @@ def _compile_sql(self, request: configs.CompileRequest) -> configs.CompileResult result_node = dataclasses.replace(result_node, order_by=None) result_node = typing.cast(nodes.ResultNode, rewrite.column_pruning(result_node)) - result_node = _remap_variables(result_node) + result_node = self._remap_variables(result_node) sql = self._compile_result_node(result_node) # Return the ordering iff no extra columns are needed to define the row order if ordering is not None: @@ -106,63 +110,62 @@ def _compile_sql(self, request: configs.CompileRequest) -> configs.CompileResult sql, result_node.schema.to_bigquery(), output_order ) + def _remap_variables(self, node: nodes.ResultNode) -> nodes.ResultNode: + """Remaps `ColumnId`s in the BFET of a `ResultNode` to produce deterministic UIDs.""" + + result_node, _ = rewrite.remap_variables( + node, map(identifiers.ColumnId, self.uid_gen.get_uid_stream("bfcol_")) + ) + return typing.cast(nodes.ResultNode, result_node) + def _compile_result_node(self, root: nodes.ResultNode) -> str: - sqlglot_ir = compile_node(root.child) + sqlglot_ir = self.compile_node(root.child) # TODO: add order_by, limit, and selections to sqlglot_expr return sqlglot_ir.sql + @functools.lru_cache(maxsize=5000) + def compile_node(self, node: nodes.BigFrameNode) -> ir.SQLGlotIR: + """Compiles node into CompileArrayValue. Caches result.""" + return node.reduce_up( + lambda node, children: self._compile_node(node, *children) + ) -def _replace_unsupported_ops(node: nodes.BigFrameNode): - node = nodes.bottom_up(node, rewrite.rewrite_slice) - node = nodes.bottom_up(node, rewrite.rewrite_timedelta_expressions) - node = nodes.bottom_up(node, rewrite.rewrite_range_rolling) - return node - - -def _remap_variables(node: nodes.ResultNode) -> nodes.ResultNode: - """Remaps `ColumnId`s in the BFET of a `ResultNode` to produce deterministic UIDs.""" - - def anonymous_column_ids() -> typing.Generator[identifiers.ColumnId, None, None]: - for i in itertools.count(): - yield identifiers.ColumnId(name=f"bfcol_{i}") - - result_node, _ = rewrite.remap_variables(node, anonymous_column_ids()) - return typing.cast(nodes.ResultNode, result_node) - - -@functools.lru_cache(maxsize=5000) -def compile_node(node: nodes.BigFrameNode) -> ir.SQLGlotIR: - """Compiles node into CompileArrayValue. Caches result.""" - return node.reduce_up(lambda node, children: _compile_node(node, *children)) - - -@functools.singledispatch -def _compile_node( - node: nodes.BigFrameNode, *compiled_children: ir.SQLGlotIR -) -> ir.SQLGlotIR: - """Defines transformation but isn't cached, always use compile_node instead""" - raise ValueError(f"Can't compile unrecognized node: {node}") + @functools.singledispatchmethod + def _compile_node( + self, node: nodes.BigFrameNode, *compiled_children: ir.SQLGlotIR + ) -> ir.SQLGlotIR: + """Defines transformation but isn't cached, always use compile_node instead""" + raise ValueError(f"Can't compile unrecognized node: {node}") + + @_compile_node.register + def compile_readlocal(self, node: nodes.ReadLocalNode, *args) -> ir.SQLGlotIR: + pa_table = node.local_data_source.data + pa_table = pa_table.select([item.source_id for item in node.scan_list.items]) + pa_table = pa_table.rename_columns( + [item.id.sql for item in node.scan_list.items] + ) + offsets = node.offsets_col.sql if node.offsets_col else None + if offsets: + pa_table = pa_table.append_column( + offsets, pa.array(range(pa_table.num_rows), type=pa.int64()) + ) -@_compile_node.register -def compile_readlocal(node: nodes.ReadLocalNode, *args) -> ir.SQLGlotIR: - pa_table = node.local_data_source.data - pa_table = pa_table.select([item.source_id for item in node.scan_list.items]) - pa_table = pa_table.rename_columns([item.id.sql for item in node.scan_list.items]) + return ir.SQLGlotIR.from_pyarrow(pa_table, node.schema, uid_gen=self.uid_gen) - offsets = node.offsets_col.sql if node.offsets_col else None - if offsets: - pa_table = pa_table.append_column( - offsets, pa.array(range(pa_table.num_rows), type=pa.int64()) + @_compile_node.register + def compile_selection( + self, node: nodes.SelectionNode, child: ir.SQLGlotIR + ) -> ir.SQLGlotIR: + selected_cols: tuple[tuple[str, sge.Expression], ...] = tuple( + (id.sql, scalar_compiler.compile_scalar_expression(expr)) + for expr, id in node.input_output_pairs ) + return child.select(selected_cols) - return ir.SQLGlotIR.from_pyarrow(pa_table, node.schema) - -@_compile_node.register -def compile_selection(node: nodes.SelectionNode, child: ir.SQLGlotIR) -> ir.SQLGlotIR: - select_cols: typing.Dict[str, sge.Expression] = { - id.name: scalar_compiler.compile_scalar_expression(expr) - for expr, id in node.input_output_pairs - } - return child.select(select_cols) +def _replace_unsupported_ops(node: nodes.BigFrameNode): + node = nodes.bottom_up(node, rewrite.rewrite_slice) + node = nodes.bottom_up(node, rewrite.rewrite_timedelta_expressions) + node = nodes.bottom_up(node, rewrite.rewrite_range_rolling) + return node diff --git a/bigframes/core/compile/sqlglot/sqlglot_ir.py b/bigframes/core/compile/sqlglot/sqlglot_ir.py index 607e712a2b..660576670d 100644 --- a/bigframes/core/compile/sqlglot/sqlglot_ir.py +++ b/bigframes/core/compile/sqlglot/sqlglot_ir.py @@ -23,6 +23,7 @@ import sqlglot.expressions as sge from bigframes import dtypes +from bigframes.core import guid import bigframes.core.compile.sqlglot.sqlglot_types as sgt import bigframes.core.local_data as local_data import bigframes.core.schema as schemata @@ -52,6 +53,9 @@ class SQLGlotIR: pretty: bool = True """Whether to pretty-print the generated SQL.""" + uid_gen: guid.SequentialUIDGenerator = guid.SequentialUIDGenerator() + """Generator for unique identifiers.""" + @property def sql(self) -> str: """Generate SQL string from the given expression.""" @@ -59,7 +63,10 @@ def sql(self) -> str: @classmethod def from_pyarrow( - cls, pa_table: pa.Table, schema: schemata.ArraySchema + cls, + pa_table: pa.Table, + schema: schemata.ArraySchema, + uid_gen: guid.SequentialUIDGenerator, ) -> SQLGlotIR: """Builds SQLGlot expression from pyarrow table.""" dtype_expr = sge.DataType( @@ -95,21 +102,44 @@ def from_pyarrow( ), ], ) - return cls(expr=sg.select(sge.Star()).from_(expr)) + return cls(expr=sg.select(sge.Star()).from_(expr), uid_gen=uid_gen) def select( self, - select_cols: typing.Dict[str, sge.Expression], + selected_cols: tuple[tuple[str, sge.Expression], ...], ) -> SQLGlotIR: - selected_cols = [ + cols_expr = [ sge.Alias( this=expr, alias=sge.to_identifier(id, quoted=self.quoted), ) - for id, expr in select_cols.items() + for id, expr in selected_cols ] - expr = self.expr.select(*selected_cols, append=False) - return SQLGlotIR(expr=expr) + new_expr = self._encapsulate_as_cte().select(*cols_expr, append=False) + return SQLGlotIR(expr=new_expr) + + def _encapsulate_as_cte( + self, + ) -> sge.Select: + """Transforms a given sge.Select query by pushing its main SELECT statement + into a new CTE and then generates a 'SELECT * FROM new_cte_name' + for the new query.""" + select_expr = self.expr.copy() + + existing_ctes = select_expr.args.pop("with", []) + new_cte_name = sge.to_identifier( + next(self.uid_gen.get_uid_stream("bfcte_")), quoted=self.quoted + ) + new_cte = sge.CTE( + this=select_expr, + alias=new_cte_name, + ) + new_with_clause = sge.With(expressions=existing_ctes + [new_cte]) + new_select_expr = ( + sge.Select().select(sge.Star()).from_(sge.Table(this=new_cte_name)) + ) + new_select_expr.set("with", new_with_clause) + return new_select_expr def _literal(value: typing.Any, dtype: dtypes.Dtype) -> sge.Expression: diff --git a/bigframes/core/guid.py b/bigframes/core/guid.py index 8930d0760a..f9b666d32b 100644 --- a/bigframes/core/guid.py +++ b/bigframes/core/guid.py @@ -11,11 +11,36 @@ # 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 threading +import typing +_GUID_LOCK = threading.Lock() _GUID_COUNTER = 0 def generate_guid(prefix="col_"): - global _GUID_COUNTER - _GUID_COUNTER += 1 - return f"bfuid_{prefix}{_GUID_COUNTER}" + global _GUID_LOCK + with _GUID_LOCK: + global _GUID_COUNTER + _GUID_COUNTER += 1 + return f"bfuid_{prefix}{_GUID_COUNTER}" + + +class SequentialUIDGenerator: + """Produces a sequence of UIDs, such as {"t0", "t1", "c0", "t2", ...}, by + cycling through provided prefixes (e.g., "t" and "c"). + Note: this function is not thread-safe. + """ + + def __init__(self): + self.prefix_counters: typing.Dict[str, int] = {} + + def get_uid_stream(self, prefix: str) -> typing.Generator[str, None, None]: + """Yields a continuous stream of raw UID strings for the given prefix.""" + if prefix not in self.prefix_counters: + self.prefix_counters[prefix] = 0 + + while True: + uid = f"{prefix}{self.prefix_counters[prefix]}" + self.prefix_counters[prefix] += 1 + yield uid diff --git a/bigframes/core/rewrite/identifiers.py b/bigframes/core/rewrite/identifiers.py index d49e5c1b42..0093e183b4 100644 --- a/bigframes/core/rewrite/identifiers.py +++ b/bigframes/core/rewrite/identifiers.py @@ -13,22 +13,20 @@ # limitations under the License. from __future__ import annotations -from typing import Generator, Tuple +import typing -import bigframes.core.identifiers -import bigframes.core.nodes +from bigframes.core import identifiers, nodes # TODO: May as well just outright remove selection nodes in this process. def remap_variables( - root: bigframes.core.nodes.BigFrameNode, - id_generator: Generator[bigframes.core.identifiers.ColumnId, None, None], -) -> Tuple[ - bigframes.core.nodes.BigFrameNode, - dict[bigframes.core.identifiers.ColumnId, bigframes.core.identifiers.ColumnId], + root: nodes.BigFrameNode, + id_generator: typing.Iterator[identifiers.ColumnId], +) -> typing.Tuple[ + nodes.BigFrameNode, + dict[identifiers.ColumnId, identifiers.ColumnId], ]: - """ - Remap all variables in the BFET using the id_generator. + """Remaps `ColumnId`s in the BFET to produce deterministic and sequential UIDs. Note: this will convert a DAG to a tree. """ diff --git a/bigframes/core/tools/datetimes.py b/bigframes/core/tools/datetimes.py index 2abb86a2f3..26afdc7910 100644 --- a/bigframes/core/tools/datetimes.py +++ b/bigframes/core/tools/datetimes.py @@ -52,7 +52,7 @@ def to_datetime( f"to datetime is not implemented. {constants.FEEDBACK_LINK}" ) - arg = bigframes.series.Series(arg)._cached() + arg = bigframes.series.Series(arg) if format and unit and arg.dtype in (bigframes.dtypes.INT_DTYPE, bigframes.dtypes.FLOAT_DTYPE): # type: ignore raise ValueError("cannot specify both format and unit") @@ -74,6 +74,11 @@ def to_datetime( ) assert unit is None + + # The following operations evaluate individual values to infer a format, + # so cache if needed. + arg = arg._cached(force=False) + as_datetime = arg._apply_unary_op( # type: ignore ops.ToDatetimeOp( format=format, diff --git a/bigframes/ml/llm.py b/bigframes/ml/llm.py index 3aecc34142..bd414102e1 100644 --- a/bigframes/ml/llm.py +++ b/bigframes/ml/llm.py @@ -617,7 +617,7 @@ def predict( It creates a struct column of the items of the iterable, and use the concatenated result as the input prompt. No-op if set to None. output_schema (Mapping[str, str] or None, default None): The schema used to generate structured output as a bigframes DataFrame. The schema is a string key-value pair of :. - Supported types are int64, float64, bool and string. If None, output text result. + Supported types are int64, float64, bool, string, array and struct. If None, output text result. Returns: bigframes.dataframe.DataFrame: DataFrame of shape (n_samples, n_input_columns + n_prediction_columns). Returns predicted values. """ diff --git a/bigframes/operations/datetime_ops.py b/bigframes/operations/datetime_ops.py index 3ea4c652f1..6e7fb32941 100644 --- a/bigframes/operations/datetime_ops.py +++ b/bigframes/operations/datetime_ops.py @@ -84,7 +84,7 @@ class UnixSeconds(base_ops.UnaryOp): name: typing.ClassVar[str] = "unix_seconds" def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: - if input_types[0] is not dtypes.TIMESTAMP_DTYPE: + if input_types[0] != dtypes.TIMESTAMP_DTYPE: raise TypeError("expected timestamp input") return dtypes.INT_DTYPE @@ -94,7 +94,7 @@ class UnixMillis(base_ops.UnaryOp): name: typing.ClassVar[str] = "unix_millis" def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: - if input_types[0] is not dtypes.TIMESTAMP_DTYPE: + if input_types[0] != dtypes.TIMESTAMP_DTYPE: raise TypeError("expected timestamp input") return dtypes.INT_DTYPE @@ -104,7 +104,7 @@ class UnixMicros(base_ops.UnaryOp): name: typing.ClassVar[str] = "unix_micros" def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: - if input_types[0] is not dtypes.TIMESTAMP_DTYPE: + if input_types[0] != dtypes.TIMESTAMP_DTYPE: raise TypeError("expected timestamp input") return dtypes.INT_DTYPE @@ -114,7 +114,7 @@ class TimestampDiff(base_ops.BinaryOp): name: typing.ClassVar[str] = "timestamp_diff" def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: - if input_types[0] is not input_types[1]: + if input_types[0] != input_types[1]: raise TypeError( f"two inputs have different types. left: {input_types[0]}, right: {input_types[1]}" ) diff --git a/bigframes/pandas/io/api.py b/bigframes/pandas/io/api.py index a119ff67b0..ecf8a59bb7 100644 --- a/bigframes/pandas/io/api.py +++ b/bigframes/pandas/io/api.py @@ -25,6 +25,7 @@ Literal, MutableSequence, Optional, + overload, Sequence, Tuple, Union, @@ -155,6 +156,38 @@ def read_json( read_json.__doc__ = inspect.getdoc(bigframes.session.Session.read_json) +@overload +def read_gbq( # type: ignore[overload-overlap] + query_or_table: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[False] = ..., +) -> bigframes.dataframe.DataFrame: + ... + + +@overload +def read_gbq( + query_or_table: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[True] = ..., +) -> pandas.Series: + ... + + def read_gbq( query_or_table: str, *, @@ -165,7 +198,8 @@ def read_gbq( filters: vendored_pandas_gbq.FiltersType = (), use_cache: Optional[bool] = None, col_order: Iterable[str] = (), -) -> bigframes.dataframe.DataFrame: + dry_run: bool = False, +) -> bigframes.dataframe.DataFrame | pandas.Series: _set_default_session_location_if_possible(query_or_table) return global_session.with_default_session( bigframes.session.Session.read_gbq, @@ -177,6 +211,7 @@ def read_gbq( filters=filters, use_cache=use_cache, col_order=col_order, + dry_run=dry_run, ) @@ -208,6 +243,38 @@ def read_gbq_object_table( ) +@overload +def read_gbq_query( # type: ignore[overload-overlap] + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + dry_run: Literal[False] = ..., +) -> bigframes.dataframe.DataFrame: + ... + + +@overload +def read_gbq_query( + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + dry_run: Literal[True] = ..., +) -> pandas.Series: + ... + + def read_gbq_query( query: str, *, @@ -218,7 +285,8 @@ def read_gbq_query( use_cache: Optional[bool] = None, col_order: Iterable[str] = (), filters: vendored_pandas_gbq.FiltersType = (), -) -> bigframes.dataframe.DataFrame: + dry_run: bool = False, +) -> bigframes.dataframe.DataFrame | pandas.Series: _set_default_session_location_if_possible(query) return global_session.with_default_session( bigframes.session.Session.read_gbq_query, @@ -230,12 +298,43 @@ def read_gbq_query( use_cache=use_cache, col_order=col_order, filters=filters, + dry_run=dry_run, ) read_gbq_query.__doc__ = inspect.getdoc(bigframes.session.Session.read_gbq_query) +@overload +def read_gbq_table( # type: ignore[overload-overlap] + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + max_results: Optional[int] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + use_cache: bool = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[False] = ..., +) -> bigframes.dataframe.DataFrame: + ... + + +@overload +def read_gbq_table( + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + max_results: Optional[int] = ..., + filters: vendored_pandas_gbq.FiltersType = ..., + use_cache: bool = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[True] = ..., +) -> pandas.Series: + ... + + def read_gbq_table( query: str, *, @@ -245,7 +344,8 @@ def read_gbq_table( filters: vendored_pandas_gbq.FiltersType = (), use_cache: bool = True, col_order: Iterable[str] = (), -) -> bigframes.dataframe.DataFrame: + dry_run: bool = False, +) -> bigframes.dataframe.DataFrame | pandas.Series: _set_default_session_location_if_possible(query) return global_session.with_default_session( bigframes.session.Session.read_gbq_table, @@ -256,6 +356,7 @@ def read_gbq_table( filters=filters, use_cache=use_cache, col_order=col_order, + dry_run=dry_run, ) diff --git a/bigframes/session/__init__.py b/bigframes/session/__init__.py index 6801937fbe..998e6e57bc 100644 --- a/bigframes/session/__init__.py +++ b/bigframes/session/__init__.py @@ -31,6 +31,7 @@ Literal, MutableSequence, Optional, + overload, Sequence, Tuple, Union, @@ -382,6 +383,38 @@ def close(self): self.bqclient, self.cloudfunctionsclient, self.session_id ) + @overload + def read_gbq( # type: ignore[overload-overlap] + self, + query_or_table: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[False] = ..., + ) -> dataframe.DataFrame: + ... + + @overload + def read_gbq( + self, + query_or_table: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[True] = ..., + ) -> pandas.Series: + ... + def read_gbq( self, query_or_table: str, @@ -393,8 +426,9 @@ def read_gbq( filters: third_party_pandas_gbq.FiltersType = (), use_cache: Optional[bool] = None, col_order: Iterable[str] = (), + dry_run: bool = False # Add a verify index argument that fails if the index is not unique. - ) -> dataframe.DataFrame: + ) -> dataframe.DataFrame | pandas.Series: # TODO(b/281571214): Generate prompt to show the progress of read_gbq. if columns and col_order: raise ValueError( @@ -404,7 +438,7 @@ def read_gbq( columns = col_order if bf_io_bigquery.is_query(query_or_table): - return self._loader.read_gbq_query( + return self._loader.read_gbq_query( # type: ignore # for dry_run overload query_or_table, index_col=index_col, columns=columns, @@ -413,6 +447,7 @@ def read_gbq( api_name="read_gbq", use_cache=use_cache, filters=filters, + dry_run=dry_run, ) else: if configuration is not None: @@ -422,7 +457,7 @@ def read_gbq( "'configuration' or use a query." ) - return self._loader.read_gbq_table( + return self._loader.read_gbq_table( # type: ignore # for dry_run overload query_or_table, index_col=index_col, columns=columns, @@ -430,6 +465,7 @@ def read_gbq( api_name="read_gbq", use_cache=use_cache if use_cache is not None else True, filters=filters, + dry_run=dry_run, ) def _register_object( @@ -440,6 +476,38 @@ def _register_object( ): self._objects.append(weakref.ref(object)) + @overload + def read_gbq_query( # type: ignore[overload-overlap] + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + dry_run: Literal[False] = ..., + ) -> dataframe.DataFrame: + ... + + @overload + def read_gbq_query( + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + use_cache: Optional[bool] = ..., + col_order: Iterable[str] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + dry_run: Literal[True] = ..., + ) -> pandas.Series: + ... + def read_gbq_query( self, query: str, @@ -451,7 +519,8 @@ def read_gbq_query( use_cache: Optional[bool] = None, col_order: Iterable[str] = (), filters: third_party_pandas_gbq.FiltersType = (), - ) -> dataframe.DataFrame: + dry_run: bool = False, + ) -> dataframe.DataFrame | pandas.Series: """Turn a SQL query into a DataFrame. Note: Because the results are written to a temporary table, ordering by @@ -517,7 +586,7 @@ def read_gbq_query( elif col_order: columns = col_order - return self._loader.read_gbq_query( + return self._loader.read_gbq_query( # type: ignore # for dry_run overload query=query, index_col=index_col, columns=columns, @@ -526,8 +595,39 @@ def read_gbq_query( api_name="read_gbq_query", use_cache=use_cache, filters=filters, + dry_run=dry_run, ) + @overload + def read_gbq_table( # type: ignore[overload-overlap] + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + max_results: Optional[int] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + use_cache: bool = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[False] = ..., + ) -> dataframe.DataFrame: + ... + + @overload + def read_gbq_table( + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + max_results: Optional[int] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + use_cache: bool = ..., + col_order: Iterable[str] = ..., + dry_run: Literal[True] = ..., + ) -> pandas.Series: + ... + def read_gbq_table( self, query: str, @@ -538,7 +638,8 @@ def read_gbq_table( filters: third_party_pandas_gbq.FiltersType = (), use_cache: bool = True, col_order: Iterable[str] = (), - ) -> dataframe.DataFrame: + dry_run: bool = False, + ) -> dataframe.DataFrame | pandas.Series: """Turn a BigQuery table into a DataFrame. **Examples:** @@ -569,7 +670,7 @@ def read_gbq_table( elif col_order: columns = col_order - return self._loader.read_gbq_table( + return self._loader.read_gbq_table( # type: ignore # for dry_run overload table_id=query, index_col=index_col, columns=columns, @@ -577,6 +678,7 @@ def read_gbq_table( api_name="read_gbq_table", use_cache=use_cache, filters=filters, + dry_run=dry_run, ) def read_gbq_table_streaming( @@ -1054,6 +1156,13 @@ def read_parquet( if engine == "bigquery": job_config = bigquery.LoadJobConfig() job_config.source_format = bigquery.SourceFormat.PARQUET + + # Ensure we can load pyarrow.list_ / BQ ARRAY type. + # See internal issue 414374215. + parquet_options = bigquery.ParquetOptions() + parquet_options.enable_list_inference = True + job_config.parquet_options = parquet_options + job_config.labels = {"bigframes-api": "read_parquet"} table_id = self._loader.load_file(path, job_config=job_config) return self._loader.read_gbq_table(table_id) diff --git a/bigframes/session/bq_caching_executor.py b/bigframes/session/bq_caching_executor.py index ec5795f9a8..4c10d76253 100644 --- a/bigframes/session/bq_caching_executor.py +++ b/bigframes/session/bq_caching_executor.py @@ -243,46 +243,37 @@ def peek( plan, ordered=False, destination=destination_table, peek=n_rows ) - def head( - self, array_value: bigframes.core.ArrayValue, n_rows: int - ) -> executor.ExecuteResult: - plan = self.logical_plan(array_value.node) - if (plan.row_count is not None) and (plan.row_count <= n_rows): - return self._execute_plan(plan, ordered=True) - - if not self.strictly_ordered and not array_value.node.explicitly_ordered: - # No user-provided ordering, so just get any N rows, its faster! - return self.peek(array_value, n_rows) - - if not tree_properties.can_fast_head(plan): - # If can't get head fast, we are going to need to execute the whole query - # Will want to do this in a way such that the result is reusable, but the first - # N values can be easily extracted. - # This currently requires clustering on offsets. - self._cache_with_offsets(array_value) - # Get a new optimized plan after caching - plan = self.logical_plan(array_value.node) - assert tree_properties.can_fast_head(plan) - - head_plan = generate_head_plan(plan, n_rows) - return self._execute_plan(head_plan, ordered=True) - def cached( - self, - array_value: bigframes.core.ArrayValue, - *, - force: bool = False, - use_session: bool = False, - cluster_cols: Sequence[str] = (), + self, array_value: bigframes.core.ArrayValue, *, config: executor.CacheConfig ) -> None: """Write the block to a session table.""" - # use a heuristic for whether something needs to be cached - if (not force) and self._is_trivially_executable(array_value): - return - if use_session: + # First, see if we can reuse the existing cache + # TODO(b/415105423): Provide feedback to user on whether new caching action was deemed necessary + # TODO(b/415105218): Make cached a deferred action + if config.if_cached == "reuse-any": + if self._is_trivially_executable(array_value): + return + elif config.if_cached == "reuse-strict": + # This path basically exists to make sure that repr in head mode is optimized for subsequent repr operations. + if config.optimize_for == "head": + if tree_properties.can_fast_head(array_value.node): + return + else: + raise NotImplementedError( + "if_cached='reuse-strict' currently only supported with optimize_for='head'" + ) + elif config.if_cached != "replace": + raise ValueError(f"Unexpected 'if_cached' arg: {config.if_cached}") + + if config.optimize_for == "auto": self._cache_with_session_awareness(array_value) + elif config.optimize_for == "head": + self._cache_with_offsets(array_value) else: - self._cache_with_cluster_cols(array_value, cluster_cols=cluster_cols) + assert isinstance(config.optimize_for, executor.HierarchicalKey) + self._cache_with_cluster_cols( + array_value, cluster_cols=config.optimize_for.columns + ) # Helpers def _run_execute_query( @@ -571,7 +562,3 @@ def _sanitize( ) for f in schema ) - - -def generate_head_plan(node: nodes.BigFrameNode, n: int): - return nodes.SliceNode(node, start=None, stop=n) diff --git a/bigframes/session/dry_runs.py b/bigframes/session/dry_runs.py new file mode 100644 index 0000000000..4d5b41345e --- /dev/null +++ b/bigframes/session/dry_runs.py @@ -0,0 +1,134 @@ +# 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 copy +from typing import Any, Dict, List, Sequence + +from google.cloud import bigquery +import pandas + +from bigframes import dtypes + + +def get_table_stats(table: bigquery.Table) -> pandas.Series: + values: List[Any] = [] + index: List[Any] = [] + + # Indicate that no query is executed. + index.append("isQuery") + values.append(False) + + # Populate column and index types + col_dtypes = dtypes.bf_type_from_type_kind(table.schema) + index.append("columnCount") + values.append(len(col_dtypes)) + index.append("columnDtypes") + values.append(col_dtypes) + + for key in ("numBytes", "numRows", "location", "type"): + index.append(key) + values.append(table._properties[key]) + + index.append("creationTime") + values.append(table.created) + + index.append("lastModifiedTime") + values.append(table.modified) + + return pandas.Series(values, index=index) + + +def get_query_stats_with_inferred_dtypes( + query_job: bigquery.QueryJob, + value_cols: Sequence[str], + index_cols: Sequence[str], +) -> pandas.Series: + if query_job.schema is None: + # If the schema is not available, don't bother inferring dtypes. + return get_query_stats(query_job) + + col_dtypes = dtypes.bf_type_from_type_kind(query_job.schema) + + if value_cols: + value_col_dtypes = { + col: col_dtypes[col] for col in value_cols if col in col_dtypes + } + else: + # Use every column that is not mentioned as an index column + value_col_dtypes = { + col: dtype + for col, dtype in col_dtypes.items() + if col not in set(index_cols) + } + + index_dtypes = [col_dtypes[col] for col in index_cols] + + return get_query_stats_with_dtypes(query_job, value_col_dtypes, index_dtypes) + + +def get_query_stats_with_dtypes( + query_job: bigquery.QueryJob, + column_dtypes: Dict[str, dtypes.Dtype], + index_dtypes: Sequence[dtypes.Dtype], +) -> pandas.Series: + index = ["columnCount", "columnDtypes", "indexLevel", "indexDtypes"] + values = [len(column_dtypes), column_dtypes, len(index_dtypes), index_dtypes] + + s = pandas.Series(values, index=index) + + return pandas.concat([s, get_query_stats(query_job)]) + + +def get_query_stats( + query_job: bigquery.QueryJob, +) -> pandas.Series: + """Returns important stats from the query job as a Pandas Series.""" + + index = [] + values = [] + + job_api_repr = copy.deepcopy(query_job._properties) + + job_ref = job_api_repr["jobReference"] + for key, val in job_ref.items(): + index.append(key) + values.append(val) + + index.append("jobType") + values.append(job_api_repr["configuration"]["jobType"]) + + query_config = job_api_repr["configuration"]["query"] + for key in ("destinationTable", "useLegacySql"): + index.append(key) + values.append(query_config.get(key)) + + query_stats = job_api_repr["statistics"]["query"] + for key in ( + "referencedTables", + "totalBytesProcessed", + "cacheHit", + "statementType", + ): + index.append(key) + values.append(query_stats.get(key)) + + index.append("creationTime") + values.append( + pandas.Timestamp( + job_api_repr["statistics"]["creationTime"], unit="ms", tz="UTC" + ) + ) + + return pandas.Series(values, index=index) diff --git a/bigframes/session/executor.py b/bigframes/session/executor.py index 0ba4ee3c2d..9075f4eee6 100644 --- a/bigframes/session/executor.py +++ b/bigframes/session/executor.py @@ -73,6 +73,17 @@ def to_py_scalar(self): return column[0] +@dataclasses.dataclass(frozen=True) +class HierarchicalKey: + columns: tuple[str, ...] + + +@dataclasses.dataclass(frozen=True) +class CacheConfig(abc.ABC): + optimize_for: Union[Literal["auto", "head"], HierarchicalKey] = "auto" + if_cached: Literal["reuse-strict", "reuse-any", "replace"] = "reuse-any" + + class Executor(abc.ABC): """ Interface for an executor, which compiles and executes ArrayValue objects. @@ -149,21 +160,10 @@ def peek( """ raise NotImplementedError("peek not implemented for this executor") - # TODO: Remove this and replace with efficient slice operator that can use execute() - def head( - self, array_value: bigframes.core.ArrayValue, n_rows: int - ) -> ExecuteResult: - """ - Preview the first n rows of the dataframe. This is less efficient than the unordered peek preview op. - """ - raise NotImplementedError("head not implemented for this executor") - def cached( self, array_value: bigframes.core.ArrayValue, *, - force: bool = False, - use_session: bool = False, - cluster_cols: Sequence[str] = (), + config: CacheConfig, ) -> None: raise NotImplementedError("cached not implemented for this executor") diff --git a/bigframes/session/loader.py b/bigframes/session/loader.py index e6b24e016c..f748f0fd76 100644 --- a/bigframes/session/loader.py +++ b/bigframes/session/loader.py @@ -30,6 +30,7 @@ List, Literal, Optional, + overload, Sequence, Tuple, ) @@ -49,6 +50,7 @@ import bigframes.core.schema as schemata import bigframes.dtypes import bigframes.formatting_helpers as formatting_helpers +from bigframes.session import dry_runs import bigframes.session._io.bigquery as bf_io_bigquery import bigframes.session._io.bigquery.read_gbq_table as bf_read_gbq_table import bigframes.session.metrics @@ -217,6 +219,13 @@ def load_data( job_config = bigquery.LoadJobConfig() job_config.source_format = bigquery.SourceFormat.PARQUET + + # Ensure we can load pyarrow.list_ / BQ ARRAY type. + # See internal issue 414374215. + parquet_options = bigquery.ParquetOptions() + parquet_options.enable_list_inference = True + job_config.parquet_options = parquet_options + job_config.schema = bq_schema if api_name: job_config.labels = {"bigframes-api": api_name} @@ -346,6 +355,48 @@ def _start_generic_job(self, job: formatting_helpers.GenericJob): else: job.result() + @overload + def read_gbq_table( # type: ignore[overload-overlap] + self, + table_id: str, + *, + index_col: Iterable[str] + | str + | Iterable[int] + | int + | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + names: Optional[Iterable[str]] = ..., + max_results: Optional[int] = ..., + api_name: str = ..., + use_cache: bool = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + enable_snapshot: bool = ..., + dry_run: Literal[False] = ..., + ) -> dataframe.DataFrame: + ... + + @overload + def read_gbq_table( + self, + table_id: str, + *, + index_col: Iterable[str] + | str + | Iterable[int] + | int + | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + names: Optional[Iterable[str]] = ..., + max_results: Optional[int] = ..., + api_name: str = ..., + use_cache: bool = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + enable_snapshot: bool = ..., + dry_run: Literal[True] = ..., + ) -> pandas.Series: + ... + def read_gbq_table( self, table_id: str, @@ -362,7 +413,8 @@ def read_gbq_table( use_cache: bool = True, filters: third_party_pandas_gbq.FiltersType = (), enable_snapshot: bool = True, - ) -> dataframe.DataFrame: + dry_run: bool = False, + ) -> dataframe.DataFrame | pandas.Series: import bigframes._tools.strings import bigframes.dataframe as dataframe @@ -488,14 +540,18 @@ def read_gbq_table( time_travel_timestamp=None, ) - return self.read_gbq_query( + return self.read_gbq_query( # type: ignore # for dry_run overload query, index_col=index_cols, columns=columns, api_name=api_name, use_cache=use_cache, + dry_run=dry_run, ) + if dry_run: + return dry_runs.get_table_stats(table) + # ----------------------------------------- # Validate table access and features # ----------------------------------------- @@ -646,6 +702,38 @@ def load_file( table_id = f"{table.project}.{table.dataset_id}.{table.table_id}" return table_id + @overload + def read_gbq_query( # type: ignore[overload-overlap] + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + api_name: str = ..., + use_cache: Optional[bool] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + dry_run: Literal[False] = ..., + ) -> dataframe.DataFrame: + ... + + @overload + def read_gbq_query( + self, + query: str, + *, + index_col: Iterable[str] | str | bigframes.enums.DefaultIndexKind = ..., + columns: Iterable[str] = ..., + configuration: Optional[Dict] = ..., + max_results: Optional[int] = ..., + api_name: str = ..., + use_cache: Optional[bool] = ..., + filters: third_party_pandas_gbq.FiltersType = ..., + dry_run: Literal[True] = ..., + ) -> pandas.Series: + ... + def read_gbq_query( self, query: str, @@ -657,7 +745,8 @@ def read_gbq_query( api_name: str = "read_gbq_query", use_cache: Optional[bool] = None, filters: third_party_pandas_gbq.FiltersType = (), - ) -> dataframe.DataFrame: + dry_run: bool = False, + ) -> dataframe.DataFrame | pandas.Series: import bigframes.dataframe as dataframe configuration = _transform_read_gbq_configuration(configuration) @@ -703,6 +792,17 @@ def read_gbq_query( time_travel_timestamp=None, ) + if dry_run: + job_config = typing.cast( + bigquery.QueryJobConfig, + bigquery.QueryJobConfig.from_api_repr(configuration), + ) + job_config.dry_run = True + query_job = self._bqclient.query(query, job_config=job_config) + return dry_runs.get_query_stats_with_inferred_dtypes( + query_job, list(columns), index_cols + ) + # No cluster candidates as user query might not be clusterable (eg because of ORDER BY clause) destination, query_job = self._query_to_destination( query, diff --git a/bigframes/version.py b/bigframes/version.py index c6ca0ee57c..3058b5f7a3 100644 --- a/bigframes/version.py +++ b/bigframes/version.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "2.2.0" +__version__ = "2.3.0" # {x-release-please-start-date} -__release_date__ = "2025-04-30" +__release_date__ = "2025-05-06" # {x-release-please-end} diff --git a/mypy.ini b/mypy.ini index f0a005d2e5..fe1d3bc9c6 100644 --- a/mypy.ini +++ b/mypy.ini @@ -35,3 +35,9 @@ ignore_missing_imports = True [mypy-pyarrow.feather] ignore_missing_imports = True + +[mypy-google.cloud.pubsub] +ignore_missing_imports = True + +[mypy-google.cloud.bigtable] +ignore_missing_imports = True diff --git a/notebooks/visualization/bq_dataframes_covid_line_graphs.ipynb b/notebooks/visualization/bq_dataframes_covid_line_graphs.ipynb index b3ae35f013..b98589c2ae 100644 --- a/notebooks/visualization/bq_dataframes_covid_line_graphs.ipynb +++ b/notebooks/visualization/bq_dataframes_covid_line_graphs.ipynb @@ -39,13 +39,13 @@ " \n", " \n", " \n", - " \n", + " \n", " \"GitHub\n", " View on GitHub\n", " \n", " \n", " \n", - " \n", + " \n", " \"BQ\n", " Open in BQ Studio\n", " \n", diff --git a/notebooks/visualization/tutorial.ipynb b/notebooks/visualization/tutorial.ipynb new file mode 100644 index 0000000000..96aff12452 --- /dev/null +++ b/notebooks/visualization/tutorial.ipynb @@ -0,0 +1,1480 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b11d1db5", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2025 Google LLC\n", + "#\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "e661697d", + "metadata": {}, + "source": [ + "## BigQuery DataFrame Visualization Tutorials\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \"Colab Run in Colab\n", + " \n", + " \n", + " \n", + " \"GitHub\n", + " View on GitHub\n", + " \n", + " \n", + " \n", + " \"BQ\n", + " Open in BQ Studio\n", + " \n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "5e93c4c1", + "metadata": {}, + "source": [ + "This notebook provides tutorials for all plotting methods that BigQuery DataFrame offers. You will visualize different datasets with histograms, line charts, area charts, bar charts, and scatter plots." + ] + }, + { + "cell_type": "markdown", + "id": "f96c47f7", + "metadata": {}, + "source": [ + "# Before you begin" + ] + }, + { + "cell_type": "markdown", + "id": "a8dd598a", + "metadata": {}, + "source": [ + "## Set up your project ID and region" + ] + }, + { + "cell_type": "markdown", + "id": "d442ab74", + "metadata": {}, + "source": [ + "This step makes sure that you will access the target dataset with the correct auth profile." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7cc6237d", + "metadata": {}, + "outputs": [], + "source": [ + "PROJECT_ID = \"\" # @param {type:\"string\"}\n", + "REGION = \"US\" # @param {type: \"string\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bf96593a", + "metadata": {}, + "outputs": [], + "source": [ + "import bigframes.pandas as bpd\n", + "\n", + "bpd.options.bigquery.project = PROJECT_ID\n", + "bpd.options.bigquery.location = REGION" + ] + }, + { + "cell_type": "markdown", + "id": "165fedc6", + "metadata": {}, + "source": [ + "You can also turn on the partial ordering mode for faster data processing." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ac5a1722", + "metadata": {}, + "outputs": [], + "source": [ + "bpd.options.bigquery.ordering_mode = 'partial'" + ] + }, + { + "cell_type": "markdown", + "id": "2ed45ca7", + "metadata": {}, + "source": [ + "# Histogram" + ] + }, + { + "cell_type": "markdown", + "id": "88837be7", + "metadata": {}, + "source": [ + "You will use the penguins public dataset in this example. First, you take a look at the shape of this data:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb595a8f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Query job caa8554f-5d26-48d7-b8be-25689cd6e307 is DONE. 0 Bytes processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
speciesislandculmen_length_mmculmen_depth_mmflipper_length_mmbody_mass_gsex
0Adelie Penguin (Pygoscelis adeliae)Dream36.618.4184.03475.0FEMALE
1Adelie Penguin (Pygoscelis adeliae)Dream39.819.1184.04650.0MALE
2Adelie Penguin (Pygoscelis adeliae)Dream40.918.9184.03900.0MALE
3Chinstrap penguin (Pygoscelis antarctica)Dream46.517.9192.03500.0FEMALE
4Adelie Penguin (Pygoscelis adeliae)Dream37.316.8192.03000.0FEMALE
\n", + "
" + ], + "text/plain": [ + " species island culmen_length_mm \\\n", + "0 Adelie Penguin (Pygoscelis adeliae) Dream 36.6 \n", + "1 Adelie Penguin (Pygoscelis adeliae) Dream 39.8 \n", + "2 Adelie Penguin (Pygoscelis adeliae) Dream 40.9 \n", + "3 Chinstrap penguin (Pygoscelis antarctica) Dream 46.5 \n", + "4 Adelie Penguin (Pygoscelis adeliae) Dream 37.3 \n", + "\n", + " culmen_depth_mm flipper_length_mm body_mass_g sex \n", + "0 18.4 184.0 3475.0 FEMALE \n", + "1 19.1 184.0 4650.0 MALE \n", + "2 18.9 184.0 3900.0 MALE \n", + "3 17.9 192.0 3500.0 FEMALE \n", + "4 16.8 192.0 3000.0 FEMALE " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "penguins = bpd.read_gbq('bigquery-public-data.ml_datasets.penguins')\n", + "penguins.peek()" + ] + }, + { + "cell_type": "markdown", + "id": "176c12f8", + "metadata": {}, + "source": [ + "You want to draw a histogram about the distribution of culmen lengths:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "333e88a3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "penguins['culmen_depth_mm'].plot.hist(bins=40)" + ] + }, + { + "cell_type": "markdown", + "id": "9e0aa359", + "metadata": {}, + "source": [ + "# Line Chart" + ] + }, + { + "cell_type": "markdown", + "id": "b0f37913", + "metadata": {}, + "source": [ + "In this example you will use the NOAA public dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "49ed2417", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stnwbandateyearmodatempcount_tempdewpcount_dewp...flag_minprcpflag_prcpsndpfograin_drizzlesnow_ice_pelletshailthundertornado_funnel_cloud
0010014999992021-02-092021020923.943.24...*0.0I999.9000000
1010014999992021-03-192021031941.9431.14...*0.0I999.9000000
2010030999992021-02-232021022331.5430.14...<NA>0.19E999.9011000
3010070999992021-02-212021022124.7415.74...<NA>0.0I999.9000000
4010070999992021-01-28202101284.14-5.44...<NA>0.0I999.9000000
\n", + "

5 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " stn wban date year mo da temp count_temp dewp \\\n", + "0 010014 99999 2021-02-09 2021 02 09 23.9 4 3.2 \n", + "1 010014 99999 2021-03-19 2021 03 19 41.9 4 31.1 \n", + "2 010030 99999 2021-02-23 2021 02 23 31.5 4 30.1 \n", + "3 010070 99999 2021-02-21 2021 02 21 24.7 4 15.7 \n", + "4 010070 99999 2021-01-28 2021 01 28 4.1 4 -5.4 \n", + "\n", + " count_dewp ... flag_min prcp flag_prcp sndp fog rain_drizzle \\\n", + "0 4 ... * 0.0 I 999.9 0 0 \n", + "1 4 ... * 0.0 I 999.9 0 0 \n", + "2 4 ... 0.19 E 999.9 0 1 \n", + "3 4 ... 0.0 I 999.9 0 0 \n", + "4 4 ... 0.0 I 999.9 0 0 \n", + "\n", + " snow_ice_pellets hail thunder tornado_funnel_cloud \n", + "0 0 0 0 0 \n", + "1 0 0 0 0 \n", + "2 1 0 0 0 \n", + "3 0 0 0 0 \n", + "4 0 0 0 0 \n", + "\n", + "[5 rows x 33 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "noaa_surface = bpd.read_gbq(\"bigquery-public-data.noaa_gsod.gsod2021\")\n", + "noaa_surface.peek()" + ] + }, + { + "cell_type": "markdown", + "id": "239ec3d1", + "metadata": {}, + "source": [ + "You are going to plot a line chart of temperatures by date. The original dataset contains many rows for a single date, and you wan to coalesce them with their median values." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e06afd00", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Query job b4681e18-4185-4303-96a4-f0614223ee63 is DONE. 64.4 MB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
temp
date
2021-02-1224.6
2021-02-1125.9
2021-02-1330.4
2021-02-1432.1
2021-01-0932.9
\n", + "
" + ], + "text/plain": [ + " temp\n", + "date \n", + "2021-02-12 24.6\n", + "2021-02-11 25.9\n", + "2021-02-13 30.4\n", + "2021-02-14 32.1\n", + "2021-01-09 32.9" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "noaa_surface_median_temps=noaa_surface[['date', 'temp']].groupby('date').median()\n", + "noaa_surface_median_temps.peek()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "68324aaf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noaa_surface_median_temps.plot.line()" + ] + }, + { + "cell_type": "markdown", + "id": "5b1e75df", + "metadata": {}, + "source": [ + "# Area Chart" + ] + }, + { + "cell_type": "markdown", + "id": "544f5605", + "metadata": {}, + "source": [ + "In this example you will use the table that tracks the popularity of names in the USA." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0c8f9726", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stategenderyearnamenumber
0ALF1910Cora61
1ALF1910Anna74
2ARF1910Willie132
3COF1910Anna42
4FLF1910Louise70
\n", + "
" + ], + "text/plain": [ + " state gender year name number\n", + "0 AL F 1910 Cora 61\n", + "1 AL F 1910 Anna 74\n", + "2 AR F 1910 Willie 132\n", + "3 CO F 1910 Anna 42\n", + "4 FL F 1910 Louise 70" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "usa_names = bpd.read_gbq(\"bigquery-public-data.usa_names.usa_1910_2013\")\n", + "usa_names.peek()" + ] + }, + { + "cell_type": "markdown", + "id": "be525493", + "metadata": {}, + "source": [ + "You want to visualize the trends of the popularities of three names in US history: Mary, Emily and Lisa." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a12cd1f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Query job 225ac92a-78d2-4739-af6c-df7552dd2345 is DONE. 132.6 MB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameEmilyLisaMary
year
19232047071799
19131371036725
19152078058293
19251748070815
19162201061551
\n", + "
" + ], + "text/plain": [ + "name Emily Lisa Mary\n", + "year \n", + "1923 2047 0 71799\n", + "1913 1371 0 36725\n", + "1915 2078 0 58293\n", + "1925 1748 0 70815\n", + "1916 2201 0 61551" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "name_counts = usa_names[usa_names['name'].isin(('Mary', 'Emily', 'Lisa'))].groupby(('year', 'name'))['number'].sum()\n", + "name_counts = name_counts.unstack(level=1).fillna(0)\n", + "name_counts.peek()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4af287bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "name_counts.plot.area(stacked=False, alpha=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "26d14b7e", + "metadata": {}, + "source": [ + "You can also use set `subplots` to `True` to draw separate graphs for each column." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "531e20b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([, ,\n", + " ], dtype=object)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "name_counts.plot.area(subplots=True, alpha=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "89d576a9", + "metadata": {}, + "source": [ + "# Bar Chart" + ] + }, + { + "cell_type": "markdown", + "id": "9e4c6864", + "metadata": {}, + "source": [ + "Bar Charts are suitable for analyzing categorical data. For example, you are going to check the sex distribution of the penguin data:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e4aef1a1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "penguin_count_by_sex = penguins[penguins['sex'].isin((\"MALE\", \"FEMALE\"))].groupby('sex')['species'].count()\n", + "penguin_count_by_sex.plot.bar()" + ] + }, + { + "cell_type": "markdown", + "id": "41f5f621", + "metadata": {}, + "source": [ + "# Scatter Plot" + ] + }, + { + "cell_type": "markdown", + "id": "d79c527a", + "metadata": {}, + "source": [ + "In this example, you will explore the relationship between NYC taxi fares and trip distances." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b6bf3f2a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
vendor_idpickup_datetimedropoff_datetimepassenger_counttrip_distancerate_codestore_and_fwd_flagpayment_typefare_amountextramta_taxtip_amounttolls_amountimp_surchargeairport_feetotal_amountpickup_location_iddropoff_location_iddata_file_yeardata_file_month
012021-06-09 07:44:46+00:002021-06-09 07:45:24+00:0012.2000000001.0N40E-90E-90E-90E-90E-90E-90E-90E-926326320216
122021-06-07 11:59:46+00:002021-06-07 12:00:00+00:0020.0100000003.0N20E-90E-90E-90E-90E-90E-90E-90E-926326320216
222021-06-23 15:03:58+00:002021-06-23 15:04:34+00:0010E-91.0N10E-90E-90E-90E-90E-90E-90E-90E-919319320216
312021-06-12 14:26:55+00:002021-06-12 14:27:08+00:0001.0000000001.0N30E-90E-90E-90E-90E-90E-90E-90E-914314320216
422021-06-15 08:39:01+00:002021-06-15 08:40:36+00:0010E-91.0N10E-90E-90E-90E-90E-90E-90E-90E-919319320216
\n", + "
" + ], + "text/plain": [ + " vendor_id pickup_datetime dropoff_datetime \\\n", + "0 1 2021-06-09 07:44:46+00:00 2021-06-09 07:45:24+00:00 \n", + "1 2 2021-06-07 11:59:46+00:00 2021-06-07 12:00:00+00:00 \n", + "2 2 2021-06-23 15:03:58+00:00 2021-06-23 15:04:34+00:00 \n", + "3 1 2021-06-12 14:26:55+00:00 2021-06-12 14:27:08+00:00 \n", + "4 2 2021-06-15 08:39:01+00:00 2021-06-15 08:40:36+00:00 \n", + "\n", + " passenger_count trip_distance rate_code store_and_fwd_flag payment_type \\\n", + "0 1 2.200000000 1.0 N 4 \n", + "1 2 0.010000000 3.0 N 2 \n", + "2 1 0E-9 1.0 N 1 \n", + "3 0 1.000000000 1.0 N 3 \n", + "4 1 0E-9 1.0 N 1 \n", + "\n", + " fare_amount extra mta_tax tip_amount tolls_amount imp_surcharge \\\n", + "0 0E-9 0E-9 0E-9 0E-9 0E-9 0E-9 \n", + "1 0E-9 0E-9 0E-9 0E-9 0E-9 0E-9 \n", + "2 0E-9 0E-9 0E-9 0E-9 0E-9 0E-9 \n", + "3 0E-9 0E-9 0E-9 0E-9 0E-9 0E-9 \n", + "4 0E-9 0E-9 0E-9 0E-9 0E-9 0E-9 \n", + "\n", + " airport_fee total_amount pickup_location_id dropoff_location_id \\\n", + "0 0E-9 0E-9 263 263 \n", + "1 0E-9 0E-9 263 263 \n", + "2 0E-9 0E-9 193 193 \n", + "3 0E-9 0E-9 143 143 \n", + "4 0E-9 0E-9 193 193 \n", + "\n", + " data_file_year data_file_month \n", + "0 2021 6 \n", + "1 2021 6 \n", + "2 2021 6 \n", + "3 2021 6 \n", + "4 2021 6 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "taxi_trips = bpd.read_gbq('bigquery-public-data.new_york_taxi_trips.tlc_yellow_trips_2021').dropna()\n", + "taxi_trips.peek()" + ] + }, + { + "cell_type": "markdown", + "id": "413c0f91", + "metadata": {}, + "source": [ + "First, you santize the data a bit by remove outliers and pathological datapoints:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d4876b08", + "metadata": {}, + "outputs": [], + "source": [ + "taxi_trips = taxi_trips[taxi_trips['trip_distance'].between(0, 10, inclusive='right')]\n", + "taxi_trips = taxi_trips[taxi_trips['fare_amount'].between(0, 50, inclusive='right')]" + ] + }, + { + "cell_type": "markdown", + "id": "f1ed53f7", + "metadata": {}, + "source": [ + "You also need to sort the data before plotting if you have turned on the partial ordering mode during the setup stage." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e9ddad9b", + "metadata": {}, + "outputs": [], + "source": [ + "taxi_trips = taxi_trips.sort_values('pickup_datetime')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e34ab06d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/google/home/sycai/src/python-bigquery-dataframes/bigframes/core/array_value.py:273: AmbiguousWindowWarning: Window ordering may be ambiguous, this can cause unstable results.\n", + " warnings.warn(msg, category=bfe.AmbiguousWindowWarning)\n", + "/usr/local/google/home/sycai/src/python-bigquery-dataframes/bigframes/core/array_value.py:249: AmbiguousWindowWarning: Window ordering may be ambiguous, this can cause unstable results.\n", + " warnings.warn(msg, bfe.AmbiguousWindowWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "taxi_trips.plot.scatter(x='trip_distance', y='fare_amount', alpha=0.5)" + ] + }, + { + "cell_type": "markdown", + "id": "7ab4ded3", + "metadata": {}, + "source": [ + "# Advacned Plotting with Pandas/Matplotlib Parameters" + ] + }, + { + "cell_type": "markdown", + "id": "51e3b044", + "metadata": {}, + "source": [ + "Because BigQuery DataFrame's plotting library is powered by Matplotlib and Pandas, you are able to pass in more parameters to fine tune your graph like what you do with Pandas. \n", + "\n", + "In the following example, you will resuse the taxi trips dataset, except that you will rename the labels for X-axis and Y-axis, use `passenger_count` for point sizes, color points with `tip_amount`, and resize the figure. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "51c4dfc7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/google/home/sycai/src/python-bigquery-dataframes/bigframes/core/array_value.py:273: AmbiguousWindowWarning: Window ordering may be ambiguous, this can cause unstable results.\n", + " warnings.warn(msg, category=bfe.AmbiguousWindowWarning)\n", + "/usr/local/google/home/sycai/src/python-bigquery-dataframes/bigframes/core/array_value.py:249: AmbiguousWindowWarning: Window ordering may be ambiguous, this can cause unstable results.\n", + " warnings.warn(msg, bfe.AmbiguousWindowWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "taxi_trips['passenger_count_scaled'] = taxi_trips['passenger_count'] * 30\n", + "\n", + "taxi_trips.plot.scatter(\n", + " x='trip_distance', \n", + " xlabel='trip distance (miles)',\n", + " y='fare_amount', \n", + " ylabel ='fare amount (usd)',\n", + " alpha=0.5, \n", + " s='passenger_count_scaled', \n", + " label='passenger_count',\n", + " c='tip_amount',\n", + " cmap='jet',\n", + " colorbar=True,\n", + " legend=True,\n", + " figsize=(15,7),\n", + " sampling_n=1000)" + ] + }, + { + "cell_type": "markdown", + "id": "6356cdab", + "metadata": {}, + "source": [ + "# Visualize Large Dataset" + ] + }, + { + "cell_type": "markdown", + "id": "fce79ba0", + "metadata": {}, + "source": [ + "BigQuery DataFrame downloads data to your local machine for visualization. The amount of datapoints to be downloaded is capped at 1000 by default. If the amount of datapoints exceeds the cap, BigQuery DataFrame will randomly sample the amount of datapoints equal to the cap.\n", + "\n", + "You can override this cap by setting the `sampling_n` parameter when plotting graphs. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "3d0ef911", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noaa_surface_median_temps.plot.line(sampling_n=40)" + ] + }, + { + "cell_type": "markdown", + "id": "64d6f86d", + "metadata": {}, + "source": [ + "Note: `sampling_n` has no effect on histograms. This is because BigQuery DataFrame bucketizes the data on the server side for histograms. If your amount of bins is very large, you may encounter a \"Query too large\" error instead." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/samples/snippets/create_kmeans_model_test.py b/samples/snippets/create_kmeans_model_test.py index 32ebc60a69..7d9a43e86c 100644 --- a/samples/snippets/create_kmeans_model_test.py +++ b/samples/snippets/create_kmeans_model_test.py @@ -18,10 +18,14 @@ def test_kmeans_sample(project_id: str, random_model_id_eu: str) -> None: your_model_id = random_model_id_eu # [START bigquery_dataframes_bqml_kmeans] import datetime + import typing import pandas as pd + from shapely.geometry import Point import bigframes + import bigframes.bigquery as bbq + import bigframes.geopandas import bigframes.pandas as bpd bigframes.options.bigquery.project = your_gcp_project_id @@ -41,21 +45,20 @@ def test_kmeans_sample(project_id: str, random_model_id_eu: str) -> None: } ) - s = bpd.read_gbq( - # Use ST_GEOPOINT and ST_DISTANCE to analyze geographical - # data. These functions determine spatial relationships between - # geographical features. - """ - SELECT - id, - ST_DISTANCE( - ST_GEOGPOINT(s.longitude, s.latitude), - ST_GEOGPOINT(-0.1, 51.5) - ) / 1000 AS distance_from_city_center - FROM - `bigquery-public-data.london_bicycles.cycle_stations` s - """ + # Use GeoSeries.from_xy and BigQuery.st_distance to analyze geographical + # data. These functions determine spatial relationships between + # geographical features. + cycle_stations = bpd.read_gbq("bigquery-public-data.london_bicycles.cycle_stations") + s = bpd.DataFrame( + { + "id": cycle_stations["id"], + "xy": bigframes.geopandas.GeoSeries.from_xy( + cycle_stations["longitude"], cycle_stations["latitude"] + ), + } ) + s_distance = bbq.st_distance(s["xy"], Point(-0.1, 51.5), use_spheroid=False) / 1000 + s = bpd.DataFrame({"id": s["id"], "distance_from_city_center": s_distance}) # Define Python datetime objects in the UTC timezone for range comparison, # because BigQuery stores timestamp data in the UTC timezone. @@ -91,8 +94,11 @@ def test_kmeans_sample(project_id: str, random_model_id_eu: str) -> None: # Engineer features to cluster the stations. For each station, find the # average trip duration, number of trips, and distance from city center. - stationstats = merged_df.groupby(["station_name", "isweekday"]).agg( - {"duration": ["mean", "count"], "distance_from_city_center": "max"} + stationstats = typing.cast( + bpd.DataFrame, + merged_df.groupby(["station_name", "isweekday"]).agg( + {"duration": ["mean", "count"], "distance_from_city_center": "max"} + ), ) stationstats.columns = pd.Index( ["duration", "num_trips", "distance_from_city_center"] diff --git a/samples/snippets/multimodal_test.py b/samples/snippets/multimodal_test.py index 27a7998ff9..dc326b266e 100644 --- a/samples/snippets/multimodal_test.py +++ b/samples/snippets/multimodal_test.py @@ -77,7 +77,7 @@ def test_multimodal_dataframe(gcs_dst_bucket: str) -> None: df_image # [END bigquery_dataframes_multimodal_dataframe_image_transform] - # [START bigquery_dataframes_multimodal_dataframe_ai] + # [START bigquery_dataframes_multimodal_dataframe_ml_text] from bigframes.ml import llm gemini = llm.GeminiTextGenerator(model_name="gemini-1.5-flash-002") @@ -89,7 +89,9 @@ def test_multimodal_dataframe(gcs_dst_bucket: str) -> None: df_image = df_image.head(2) answer = gemini.predict(df_image, prompt=["what item is it?", df_image["image"]]) answer[["ml_generate_text_llm_result", "image"]] + # [END bigquery_dataframes_multimodal_dataframe_ml_text] + # [START bigquery_dataframes_multimodal_dataframe_ml_text_alt] # Ask different questions df_image["question"] = [ # type: ignore "what item is it?", @@ -99,12 +101,14 @@ def test_multimodal_dataframe(gcs_dst_bucket: str) -> None: df_image, prompt=[df_image["question"], df_image["image"]] ) answer_alt[["ml_generate_text_llm_result", "image"]] + # [END bigquery_dataframes_multimodal_dataframe_ml_text_alt] + # [START bigquery_dataframes_multimodal_dataframe_ml_embed] # Generate embeddings on images embed_model = llm.MultimodalEmbeddingGenerator() embeddings = embed_model.predict(df_image["image"]) embeddings - # [END bigquery_dataframes_multimodal_dataframe_ai] + # [END bigquery_dataframes_multimodal_dataframe_ml_embed] # [START bigquery_dataframes_multimodal_dataframe_pdf_chunk] # PDF chunking diff --git a/scripts/create_bigtable.py b/scripts/create_bigtable.py deleted file mode 100644 index da40e9063d..0000000000 --- a/scripts/create_bigtable.py +++ /dev/null @@ -1,77 +0,0 @@ -# Copyright 2024 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 -# -# https://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. - -# This script create the bigtable resources required for -# bigframes.streaming testing if they don't already exist - -import os -import sys - -from google.cloud.bigtable import column_family -import google.cloud.bigtable as bigtable - -PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT") - -if not PROJECT_ID: - print( - "Please set GOOGLE_CLOUD_PROJECT environment variable before running.", - file=sys.stderr, - ) - sys.exit(1) - - -def create_instance(client): - instance_name = "streaming-testing-instance" - instance = bigtable.instance.Instance( - instance_name, - client, - ) - cluster_id = "streaming-testing-instance-c1" - cluster = instance.cluster( - cluster_id, - location_id="us-west1-a", - serve_nodes=1, - ) - if not instance.exists(): - operation = instance.create( - clusters=[cluster], - ) - operation.result(timeout=480) - print(f"Created instance {instance_name}") - return instance - - -def create_table(instance): - table_id = "table-testing" - table = bigtable.table.Table( - table_id, - instance, - ) - max_versions_rule = column_family.MaxVersionsGCRule(1) - column_family_id = "body_mass_g" - column_families = {column_family_id: max_versions_rule} - if not table.exists(): - table.create(column_families=column_families) - print(f"Created table {table_id}") - - -def main(): - client = bigtable.Client(project=PROJECT_ID, admin=True) - - instance = create_instance(client) - create_table(instance) - - -if __name__ == "__main__": - main() diff --git a/scripts/create_pubsub.py b/scripts/create_pubsub.py deleted file mode 100644 index 5d25398983..0000000000 --- a/scripts/create_pubsub.py +++ /dev/null @@ -1,49 +0,0 @@ -# Copyright 2024 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 -# -# https://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. - -# This script create the bigtable resources required for -# bigframes.streaming testing if they don't already exist - -import os -import sys - -from google.cloud import pubsub_v1 - -PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT") - -if not PROJECT_ID: - print( - "Please set GOOGLE_CLOUD_PROJECT environment variable before running.", - file=sys.stderr, - ) - sys.exit(1) - - -def create_topic(topic_id): - # based on - # https://cloud.google.com/pubsub/docs/samples/pubsub-quickstart-create-topic?hl=en - - publisher = pubsub_v1.PublisherClient() - topic_path = publisher.topic_path(PROJECT_ID, topic_id) - - topic = publisher.create_topic(request={"name": topic_path}) - print(f"Created topic: {topic.name}") - - -def main(): - create_topic("penguins") - - -if __name__ == "__main__": - main() diff --git a/tests/system/large/test_streaming.py b/tests/system/large/test_streaming.py index e4992f8573..f80088cf69 100644 --- a/tests/system/large/test_streaming.py +++ b/tests/system/large/test_streaming.py @@ -12,16 +12,96 @@ # See the License for the specific language governing permissions and # limitations under the License. +from concurrent import futures import time +from typing import Generator +import uuid +from google.cloud import bigtable, pubsub # type: ignore +from google.cloud.bigtable import column_family, instance, table import pytest import bigframes -import bigframes.streaming + + +def resource_name_full(project_id: str, resource_type: str, resource_id: str): + return f"projects/{project_id}/{resource_type}/{resource_id}" + + +@pytest.fixture(scope="session") +def bigtable_instance(session_load: bigframes.Session) -> instance.Instance: + client = bigtable.Client(project=session_load._project, admin=True) + + instance_name = "streaming-testing-instance" + bt_instance = instance.Instance( + instance_name, + client, + ) + + if not bt_instance.exists(): + cluster_id = "streaming-testing-instance-c1" + cluster = bt_instance.cluster( + cluster_id, + location_id="us-west1-a", + serve_nodes=1, + ) + operation = bt_instance.create( + clusters=[cluster], + ) + operation.result(timeout=480) + return bt_instance + + +@pytest.fixture(scope="function") +def bigtable_table( + bigtable_instance: instance.Instance, +) -> Generator[table.Table, None, None]: + table_id = "bigframes_test_" + uuid.uuid4().hex + bt_table = table.Table( + table_id, + bigtable_instance, + ) + max_versions_rule = column_family.MaxVersionsGCRule(1) + column_family_id = "body_mass_g" + column_families = {column_family_id: max_versions_rule} + bt_table.create(column_families=column_families) + yield bt_table + bt_table.delete() + + +@pytest.fixture(scope="function") +def pubsub_topic_id(session_load: bigframes.Session) -> Generator[str, None, None]: + publisher = pubsub.PublisherClient() + topic_id = "bigframes_test_topic_" + uuid.uuid4().hex + + topic_name = resource_name_full(session_load._project, "topics", topic_id) + + publisher.create_topic(name=topic_name) + yield topic_id + publisher.delete_topic(topic=topic_name) + + +@pytest.fixture(scope="function") +def pubsub_topic_subscription_ids( + session_load: bigframes.Session, pubsub_topic_id: str +) -> Generator[tuple[str, str], None, None]: + subscriber = pubsub.SubscriberClient() + subscription_id = "bigframes_test_subscription_" + uuid.uuid4().hex + + subscription_name = resource_name_full( + session_load._project, "subscriptions", subscription_id + ) + topic_name = resource_name_full(session_load._project, "topics", pubsub_topic_id) + + subscriber.create_subscription(name=subscription_name, topic=topic_name) + yield (pubsub_topic_id, subscription_id) + subscriber.delete_subscription(subscription=subscription_name) @pytest.mark.flaky(retries=3, delay=10) -def test_streaming_df_to_bigtable(session_load: bigframes.Session): +def test_streaming_df_to_bigtable( + session_load: bigframes.Session, bigtable_table: table.Table +): # launch a continuous query job_id_prefix = "test_streaming_" sdf = session_load.read_gbq_table_streaming("birds.penguins_bigtable_streaming") @@ -30,32 +110,44 @@ def test_streaming_df_to_bigtable(session_load: bigframes.Session): sdf = sdf[sdf["body_mass_g"] < 4000] sdf = sdf.rename(columns={"island": "rowkey"}) - query_job = sdf.to_bigtable( - instance="streaming-testing-instance", - table="table-testing", - service_account_email="streaming-testing@bigframes-load-testing.iam.gserviceaccount.com", - app_profile=None, - truncate=True, - overwrite=True, - auto_create_column_families=True, - bigtable_options={}, - job_id=None, - job_id_prefix=job_id_prefix, - ) - try: + query_job = sdf.to_bigtable( + instance="streaming-testing-instance", + table=bigtable_table.table_id, + service_account_email="streaming-testing-admin@bigframes-load-testing.iam.gserviceaccount.com", + app_profile=None, + truncate=True, + overwrite=True, + auto_create_column_families=True, + bigtable_options={}, + job_id=None, + job_id_prefix=job_id_prefix, + ) + # wait 100 seconds in order to ensure the query doesn't stop # (i.e. it is continuous) time.sleep(100) assert query_job.running() assert query_job.error_result is None assert str(query_job.job_id).startswith(job_id_prefix) + assert len(list(bigtable_table.read_rows())) > 0 finally: query_job.cancel() @pytest.mark.flaky(retries=3, delay=10) -def test_streaming_df_to_pubsub(session_load: bigframes.Session): +def test_streaming_df_to_pubsub( + session_load: bigframes.Session, pubsub_topic_subscription_ids: tuple[str, str] +): + topic_id, subscription_id = pubsub_topic_subscription_ids + + subscriber = pubsub.SubscriberClient() + + subscription_name = "projects/{project_id}/subscriptions/{sub}".format( + project_id=session_load._project, + sub=subscription_id, + ) + # launch a continuous query job_id_prefix = "test_streaming_pubsub_" sdf = session_load.read_gbq_table_streaming("birds.penguins_bigtable_streaming") @@ -63,19 +155,37 @@ def test_streaming_df_to_pubsub(session_load: bigframes.Session): sdf = sdf[sdf["body_mass_g"] < 4000] sdf = sdf[["island"]] - query_job = sdf.to_pubsub( - topic="penguins", - service_account_email="streaming-testing@bigframes-load-testing.iam.gserviceaccount.com", - job_id=None, - job_id_prefix=job_id_prefix, - ) - try: - # wait 100 seconds in order to ensure the query doesn't stop - # (i.e. it is continuous) - time.sleep(100) + + def counter(func): + def wrapper(*args, **kwargs): + wrapper.count += 1 # type: ignore + return func(*args, **kwargs) + + wrapper.count = 0 # type: ignore + return wrapper + + @counter + def callback(message): + message.ack() + + future = subscriber.subscribe(subscription_name, callback) + + query_job = sdf.to_pubsub( + topic=topic_id, + service_account_email="streaming-testing@bigframes-load-testing.iam.gserviceaccount.com", + job_id=None, + job_id_prefix=job_id_prefix, + ) + try: + # wait 100 seconds in order to ensure the query doesn't stop + # (i.e. it is continuous) + future.result(timeout=100) + except futures.TimeoutError: + future.cancel() assert query_job.running() assert query_job.error_result is None assert str(query_job.job_id).startswith(job_id_prefix) + assert callback.count > 0 # type: ignore finally: query_job.cancel() diff --git a/tests/system/load/test_llm.py b/tests/system/load/test_llm.py index abb199b8ab..e3aead5425 100644 --- a/tests/system/load/test_llm.py +++ b/tests/system/load/test_llm.py @@ -41,7 +41,7 @@ def llm_remote_text_df(session, llm_remote_text_pandas_df): @pytest.mark.parametrize( "model_name", ( - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-002", ), ) diff --git a/tests/system/small/bigquery/test_array.py b/tests/system/small/bigquery/test_array.py index d6823a3a54..2ceb90e22c 100644 --- a/tests/system/small/bigquery/test_array.py +++ b/tests/system/small/bigquery/test_array.py @@ -17,17 +17,61 @@ import pytest import bigframes.bigquery as bbq +import bigframes.dtypes import bigframes.pandas as bpd -def test_array_length(): - series = bpd.Series([["A", "AA", "AAA"], ["BB", "B"], np.nan, [], ["C"]]) - # TODO(b/336880368): Allow for NULL values to be input for ARRAY columns. - # Once we actually store NULL values, this will be NULL where the input is NULL. - expected = bpd.Series([3, 2, 0, 0, 1]) +@pytest.mark.parametrize( + ["input_data", "expected"], + [ + pytest.param( + [["A", "AA", "AAA"], ["BB", "B"], np.nan, [], ["C"]], + [ + 3, + 2, + # TODO(b/336880368): Allow for NULL values to be input for ARRAY + # columns. Once we actually store NULL values, this will be + # NULL where the input is NULL. + 0, + 0, + 1, + ], + id="small-string", + ), + pytest.param( + [[1, 2, 3], [4, 5], [], [], [6]], [3, 2, 0, 0, 1], id="small-int64" + ), + pytest.param( + [ + # Regression test for b/414374215 where the Series constructor + # returns empty lists when the lists are too big to embed in + # SQL. + list(np.random.randint(-1_000_000, 1_000_000, size=1000)), + list(np.random.randint(-1_000_000, 1_000_000, size=967)), + list(np.random.randint(-1_000_000, 1_000_000, size=423)), + list(np.random.randint(-1_000_000, 1_000_000, size=5000)), + list(np.random.randint(-1_000_000, 1_000_000, size=1003)), + list(np.random.randint(-1_000_000, 1_000_000, size=9999)), + ], + [ + 1000, + 967, + 423, + 5000, + 1003, + 9999, + ], + id="larger-int64", + ), + ], +) +def test_array_length(input_data, expected): + series = bpd.Series(input_data) + expected = pd.Series(expected, dtype=bigframes.dtypes.INT_DTYPE) pd.testing.assert_series_equal( bbq.array_length(series).to_pandas(), - expected.to_pandas(), + expected, + check_index_type=False, ) diff --git a/tests/system/small/bigquery/test_datetime.py b/tests/system/small/bigquery/test_datetime.py index b839031263..dc68e7b892 100644 --- a/tests/system/small/bigquery/test_datetime.py +++ b/tests/system/small/bigquery/test_datetime.py @@ -15,10 +15,20 @@ import typing import pandas as pd +import pyarrow as pa import pytest from bigframes import bigquery +_TIMESTAMP_DTYPE = pd.ArrowDtype(pa.timestamp("us", tz="UTC")) + + +@pytest.fixture +def int_series(session): + pd_series = pd.Series([1, 2, 3, 4, 5]) + + return session.read_pandas(pd_series), pd_series + def test_unix_seconds(scalars_dfs): bigframes_df, pandas_df = scalars_dfs @@ -33,6 +43,19 @@ def test_unix_seconds(scalars_dfs): pd.testing.assert_series_equal(actual_res, expected_res) +def test_unix_seconds_after_type_casting(int_series): + bf_series, pd_series = int_series + + actual_res = bigquery.unix_seconds(bf_series.astype(_TIMESTAMP_DTYPE)).to_pandas() + + expected_res = ( + pd_series.astype(_TIMESTAMP_DTYPE) + .apply(lambda ts: _to_unix_epoch(ts, "s")) + .astype("Int64") + ) + pd.testing.assert_series_equal(actual_res, expected_res, check_index_type=False) + + def test_unix_seconds_incorrect_input_type_raise_error(scalars_dfs): df, _ = scalars_dfs @@ -53,6 +76,19 @@ def test_unix_millis(scalars_dfs): pd.testing.assert_series_equal(actual_res, expected_res) +def test_unix_millis_after_type_casting(int_series): + bf_series, pd_series = int_series + + actual_res = bigquery.unix_millis(bf_series.astype(_TIMESTAMP_DTYPE)).to_pandas() + + expected_res = ( + pd_series.astype(_TIMESTAMP_DTYPE) + .apply(lambda ts: _to_unix_epoch(ts, "ms")) + .astype("Int64") + ) + pd.testing.assert_series_equal(actual_res, expected_res, check_index_type=False) + + def test_unix_millis_incorrect_input_type_raise_error(scalars_dfs): df, _ = scalars_dfs @@ -73,6 +109,19 @@ def test_unix_micros(scalars_dfs): pd.testing.assert_series_equal(actual_res, expected_res) +def test_unix_micros_after_type_casting(int_series): + bf_series, pd_series = int_series + + actual_res = bigquery.unix_micros(bf_series.astype(_TIMESTAMP_DTYPE)).to_pandas() + + expected_res = ( + pd_series.astype(_TIMESTAMP_DTYPE) + .apply(lambda ts: _to_unix_epoch(ts, "us")) + .astype("Int64") + ) + pd.testing.assert_series_equal(actual_res, expected_res, check_index_type=False) + + def test_unix_micros_incorrect_input_type_raise_error(scalars_dfs): df, _ = scalars_dfs diff --git a/tests/system/small/ml/conftest.py b/tests/system/small/ml/conftest.py index d56874719e..8f05e7fe03 100644 --- a/tests/system/small/ml/conftest.py +++ b/tests/system/small/ml/conftest.py @@ -29,7 +29,6 @@ globals, imported, linear_model, - llm, remote, ) @@ -339,20 +338,3 @@ def imported_xgboost_model( output={"predicted_label": "float64"}, model_path=imported_xgboost_array_model_path, ) - - -@pytest.fixture(scope="session") -def bqml_gemini_text_generator(bq_connection, session) -> llm.GeminiTextGenerator: - return llm.GeminiTextGenerator( - model_name="gemini-1.5-flash-002", - connection_name=bq_connection, - session=session, - ) - - -@pytest.fixture(scope="session") -def bqml_claude3_text_generator(bq_connection, session) -> llm.Claude3TextGenerator: - return llm.Claude3TextGenerator( - connection_name=bq_connection, - session=session, - ) diff --git a/tests/system/small/ml/test_llm.py b/tests/system/small/ml/test_llm.py index 51e9d8ad6a..a74642aea3 100644 --- a/tests/system/small/ml/test_llm.py +++ b/tests/system/small/ml/test_llm.py @@ -16,6 +16,7 @@ from unittest import mock import pandas as pd +import pyarrow as pa import pytest import bigframes @@ -113,7 +114,7 @@ def test_create_load_multimodal_embedding_generator_model( "gemini-1.5-pro-preview-0514", "gemini-1.5-flash-preview-0514", "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -148,7 +149,7 @@ def test_create_load_gemini_text_generator_model( "gemini-1.5-pro-preview-0514", "gemini-1.5-flash-preview-0514", "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -175,7 +176,7 @@ def test_gemini_text_generator_predict_default_params_success( "gemini-1.5-pro-preview-0514", "gemini-1.5-flash-preview-0514", "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -204,7 +205,7 @@ def test_gemini_text_generator_predict_with_params_success( "gemini-1.5-pro-preview-0514", "gemini-1.5-flash-preview-0514", "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -235,7 +236,7 @@ def test_gemini_text_generator_multi_cols_predict_success( "gemini-1.5-pro-preview-0514", "gemini-1.5-flash-preview-0514", "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -253,22 +254,27 @@ def test_gemini_text_generator_predict_output_schema_success( "int_output": "int64", "float_output": "float64", "str_output": "string", + "array_output": "array", + "struct_output": "struct", } - df = gemini_text_generator_model.predict( - llm_text_df, output_schema=output_schema - ).to_pandas() + df = gemini_text_generator_model.predict(llm_text_df, output_schema=output_schema) + assert df["bool_output"].dtype == pd.BooleanDtype() + assert df["int_output"].dtype == pd.Int64Dtype() + assert df["float_output"].dtype == pd.Float64Dtype() + assert df["str_output"].dtype == pd.StringDtype(storage="pyarrow") + assert df["array_output"].dtype == pd.ArrowDtype(pa.list_(pa.int64())) + assert df["struct_output"].dtype == pd.ArrowDtype( + pa.struct([("number", pa.int64())]) + ) + + pd_df = df.to_pandas() utils.check_pandas_df_schema_and_index( - df, + pd_df, columns=list(output_schema.keys()) + ["prompt", "full_response", "status"], index=3, col_exact=False, ) - assert df["bool_output"].dtype == pd.BooleanDtype() - assert df["int_output"].dtype == pd.Int64Dtype() - assert df["float_output"].dtype == pd.Float64Dtype() - assert df["str_output"].dtype == pd.StringDtype(storage="pyarrow") - # Overrides __eq__ function for comparing as mock.call parameter class EqCmpAllDataFrame(bpd.DataFrame): @@ -305,8 +311,7 @@ def test_text_generator_retry_success( session, model_class, options, - bqml_gemini_text_generator: llm.GeminiTextGenerator, - bqml_claude3_text_generator: llm.Claude3TextGenerator, + bq_connection, ): # Requests. df0 = EqCmpAllDataFrame( @@ -387,11 +392,7 @@ def test_text_generator_retry_success( ), ] - text_generator_model = ( - bqml_gemini_text_generator - if (model_class == llm.GeminiTextGenerator) - else bqml_claude3_text_generator - ) + text_generator_model = model_class(connection_name=bq_connection, session=session) text_generator_model._bqml_model = mock_bqml_model with mock.patch.object(core.BqmlModel, "generate_text_tvf", generate_text_tvf): @@ -448,13 +449,7 @@ def test_text_generator_retry_success( ), ], ) -def test_text_generator_retry_no_progress( - session, - model_class, - options, - bqml_gemini_text_generator: llm.GeminiTextGenerator, - bqml_claude3_text_generator: llm.Claude3TextGenerator, -): +def test_text_generator_retry_no_progress(session, model_class, options, bq_connection): # Requests. df0 = EqCmpAllDataFrame( { @@ -514,11 +509,7 @@ def test_text_generator_retry_no_progress( ), ] - text_generator_model = ( - bqml_gemini_text_generator - if (model_class == llm.GeminiTextGenerator) - else bqml_claude3_text_generator - ) + text_generator_model = model_class(connection_name=bq_connection, session=session) text_generator_model._bqml_model = mock_bqml_model with mock.patch.object(core.BqmlModel, "generate_text_tvf", generate_text_tvf): @@ -768,7 +759,7 @@ def test_text_embedding_generator_retry_no_progress(session, bq_connection): @pytest.mark.parametrize( "model_name", ( - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-002", "gemini-2.0-flash-001", "gemini-2.0-flash-lite-001", @@ -798,7 +789,7 @@ def test_llm_gemini_score(llm_fine_tune_df_default_index, model_name): @pytest.mark.parametrize( "model_name", ( - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-002", "gemini-2.0-flash-001", "gemini-2.0-flash-lite-001", diff --git a/tests/system/small/ml/test_multimodal_llm.py b/tests/system/small/ml/test_multimodal_llm.py index 7c07d9ead2..efeadc76cf 100644 --- a/tests/system/small/ml/test_multimodal_llm.py +++ b/tests/system/small/ml/test_multimodal_llm.py @@ -12,6 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +import pandas as pd +import pyarrow as pa import pytest import bigframes @@ -43,7 +45,7 @@ def test_multimodal_embedding_generator_predict_default_params_success( "model_name", ( "gemini-1.5-pro-001", - "gemini-1.5-pro-002", + # "gemini-1.5-pro-002", "gemini-1.5-flash-001", "gemini-1.5-flash-002", "gemini-2.0-flash-exp", @@ -68,3 +70,55 @@ def test_gemini_text_generator_multimodal_input( index=2, col_exact=False, ) + + +@pytest.mark.parametrize( + "model_name", + ( + "gemini-1.5-pro-001", + # "gemini-1.5-pro-002", + "gemini-1.5-flash-001", + "gemini-1.5-flash-002", + "gemini-2.0-flash-exp", + "gemini-2.0-flash-001", + ), +) +@pytest.mark.flaky(retries=2) +def test_gemini_text_generator_multimodal_structured_output( + images_mm_df: bpd.DataFrame, model_name, test_session, bq_connection +): + bigframes.options.experiments.blob = True + + gemini_text_generator_model = llm.GeminiTextGenerator( + model_name=model_name, connection_name=bq_connection, session=test_session + ) + output_schema = { + "bool_output": "bool", + "int_output": "int64", + "float_output": "float64", + "str_output": "string", + "array_output": "array", + "struct_output": "struct", + } + df = gemini_text_generator_model.predict( + images_mm_df, + prompt=["Describe", images_mm_df["blob_col"]], + output_schema=output_schema, + ) + assert df["bool_output"].dtype == pd.BooleanDtype() + assert df["int_output"].dtype == pd.Int64Dtype() + assert df["float_output"].dtype == pd.Float64Dtype() + assert df["str_output"].dtype == pd.StringDtype(storage="pyarrow") + assert df["array_output"].dtype == pd.ArrowDtype(pa.list_(pa.int64())) + assert df["struct_output"].dtype == pd.ArrowDtype( + pa.struct([("number", pa.int64())]) + ) + + pd_df = df.to_pandas() + utils.check_pandas_df_schema_and_index( + pd_df, + columns=list(output_schema.keys()) + + ["blob_col", "prompt", "full_response", "status"], + index=2, + col_exact=False, + ) diff --git a/tests/system/small/operations/test_timedeltas.py b/tests/system/small/operations/test_timedeltas.py index 0cf394e454..d6b32a3508 100644 --- a/tests/system/small/operations/test_timedeltas.py +++ b/tests/system/small/operations/test_timedeltas.py @@ -60,6 +60,7 @@ def temporal_dfs(session): ], "float_col": [1.5, 2, -3], "int_col": [1, 2, -3], + "positive_int_col": [1, 2, 3], } ) @@ -607,3 +608,24 @@ def test_timedelta_agg__int_result(temporal_dfs, agg_func): expected_result = agg_func(pd_df["timedelta_col_1"]) assert actual_result == expected_result + + +def test_timestamp_diff_after_type_casting(temporal_dfs): + if version.Version(pd.__version__) <= version.Version("2.1.0"): + pytest.skip( + "Temporal type casting is not well-supported in older verions of Pandas." + ) + + bf_df, pd_df = temporal_dfs + dtype = pd.ArrowDtype(pa.timestamp("us", tz="UTC")) + + actual_result = ( + bf_df["timestamp_col"] - bf_df["positive_int_col"].astype(dtype) + ).to_pandas() + + expected_result = pd_df["timestamp_col"] - pd_df["positive_int_col"].astype( + "datetime64[us, UTC]" + ) + pandas.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False, check_dtype=False + ) diff --git a/tests/system/small/test_session.py b/tests/system/small/test_session.py index ced01c940f..ad01a95509 100644 --- a/tests/system/small/test_session.py +++ b/tests/system/small/test_session.py @@ -1831,3 +1831,100 @@ def test_read_gbq_duplicate_columns_xfail( index_col=index_col, columns=columns, ) + + +def test_read_gbq_with_table_ref_dry_run(scalars_table_id, session): + result = session.read_gbq(scalars_table_id, dry_run=True) + + assert isinstance(result, pd.Series) + _assert_table_dry_run_stats_are_valid(result) + + +def test_read_gbq_with_query_dry_run(scalars_table_id, session): + query = f"SELECT * FROM {scalars_table_id} LIMIT 10;" + result = session.read_gbq(query, dry_run=True) + + assert isinstance(result, pd.Series) + _assert_query_dry_run_stats_are_valid(result) + + +def test_read_gbq_dry_run_with_column_and_index(scalars_table_id, session): + query = f"SELECT * FROM {scalars_table_id} LIMIT 10;" + result = session.read_gbq( + query, dry_run=True, columns=["int64_col", "float64_col"], index_col="int64_too" + ) + + assert isinstance(result, pd.Series) + _assert_query_dry_run_stats_are_valid(result) + assert result["columnCount"] == 2 + assert result["columnDtypes"] == { + "int64_col": pd.Int64Dtype(), + "float64_col": pd.Float64Dtype(), + } + assert result["indexLevel"] == 1 + assert result["indexDtypes"] == [pd.Int64Dtype()] + + +def test_read_gbq_table_dry_run(scalars_table_id, session): + result = session.read_gbq_table(scalars_table_id, dry_run=True) + + assert isinstance(result, pd.Series) + _assert_table_dry_run_stats_are_valid(result) + + +def test_read_gbq_table_dry_run_with_max_results(scalars_table_id, session): + result = session.read_gbq_table(scalars_table_id, dry_run=True, max_results=100) + + assert isinstance(result, pd.Series) + _assert_query_dry_run_stats_are_valid(result) + + +def test_read_gbq_query_dry_run(scalars_table_id, session): + query = f"SELECT * FROM {scalars_table_id} LIMIT 10;" + result = session.read_gbq_query(query, dry_run=True) + + assert isinstance(result, pd.Series) + _assert_query_dry_run_stats_are_valid(result) + + +def _assert_query_dry_run_stats_are_valid(result: pd.Series): + expected_index = pd.Index( + [ + "columnCount", + "columnDtypes", + "indexLevel", + "indexDtypes", + "projectId", + "location", + "jobType", + "destinationTable", + "useLegacySql", + "referencedTables", + "totalBytesProcessed", + "cacheHit", + "statementType", + "creationTime", + ] + ) + + pd.testing.assert_index_equal(result.index, expected_index) + assert result["columnCount"] + result["indexLevel"] > 0 + + +def _assert_table_dry_run_stats_are_valid(result: pd.Series): + expected_index = pd.Index( + [ + "isQuery", + "columnCount", + "columnDtypes", + "numBytes", + "numRows", + "location", + "type", + "creationTime", + "lastModifiedTime", + ] + ) + + pd.testing.assert_index_equal(result.index, expected_index) + assert result["columnCount"] == len(result["columnDtypes"]) diff --git a/tests/unit/core/compile/sqlglot/compiler_session.py b/tests/unit/core/compile/sqlglot/compiler_session.py index eddae8f891..7309349681 100644 --- a/tests/unit/core/compile/sqlglot/compiler_session.py +++ b/tests/unit/core/compile/sqlglot/compiler_session.py @@ -27,7 +27,7 @@ class SQLCompilerExecutor(bigframes.session.executor.Executor): """Executor for SQL compilation using sqlglot.""" - compiler = sqlglot.SQLGlotCompiler() + compiler = sqlglot def to_sql( self, @@ -41,7 +41,9 @@ def to_sql( # Compared with BigQueryCachingExecutor, SQLCompilerExecutor skips # caching the subtree. - return self.compiler.compile(array_value.node, ordered=ordered) + return self.compiler.SQLGlotCompiler().compile( + array_value.node, ordered=ordered + ) class SQLCompilerSession(bigframes.session.Session): diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal/out.sql index 0ef80dc8b0..f04f9ed023 100644 --- a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal/out.sql +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal/out.sql @@ -1,3 +1,161 @@ +WITH `bfcte_0` AS ( + SELECT + * + FROM UNNEST(ARRAY>[STRUCT( + 0, + TRUE, + CAST(b'Hello, World!' AS BYTES), + CAST('2021-07-21' AS DATE), + CAST('2021-07-21T11:39:45' AS DATETIME), + ST_GEOGFROMTEXT('POINT (-122.0838511 37.3860517)'), + 123456789, + 0, + 1.234567890, + 1.25, + 0, + 0, + 'Hello, World!', + CAST('11:41:43.076160' AS TIME), + CAST('2021-07-21T17:43:43.945289+00:00' AS TIMESTAMP), + 0 + ), STRUCT( + 1, + FALSE, + CAST(b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf' AS BYTES), + CAST('1991-02-03' AS DATE), + CAST('1991-01-02T03:45:06' AS DATETIME), + ST_GEOGFROMTEXT('POINT (-71.104 42.315)'), + -987654321, + 1, + 1.234567890, + 2.51, + 1, + 1, + 'こんにちは', + CAST('11:14:34.701606' AS TIME), + CAST('2021-07-21T17:43:43.945289+00:00' AS TIMESTAMP), + 1 + ), STRUCT( + 2, + TRUE, + CAST(b'\xc2\xa1Hola Mundo!' AS BYTES), + CAST('2023-03-01' AS DATE), + CAST('2023-03-01T10:55:13' AS DATETIME), + ST_GEOGFROMTEXT('POINT (-0.124474760143016 51.5007826749545)'), + 314159, + 0, + 101.101010100, + 25000000000.0, + 2, + 2, + ' ¡Hola Mundo! ', + CAST('23:59:59.999999' AS TIME), + CAST('2023-03-01T10:55:13.250125+00:00' AS TIMESTAMP), + 2 + ), STRUCT( + 3, + CAST(NULL AS BOOLEAN), + CAST(NULL AS BYTES), + CAST(NULL AS DATE), + CAST(NULL AS DATETIME), + CAST(NULL AS GEOGRAPHY), + CAST(NULL AS INT64), + 1, + CAST(NULL AS NUMERIC), + CAST(NULL AS FLOAT64), + 3, + 3, + CAST(NULL AS STRING), + CAST(NULL AS TIME), + CAST(NULL AS TIMESTAMP), + 3 + ), STRUCT( + 4, + FALSE, + CAST(b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf' AS BYTES), + CAST('2021-07-21' AS DATE), + CAST(NULL AS DATETIME), + CAST(NULL AS GEOGRAPHY), + -234892, + -2345, + CAST(NULL AS NUMERIC), + CAST(NULL AS FLOAT64), + 4, + 4, + 'Hello, World!', + CAST(NULL AS TIME), + CAST(NULL AS TIMESTAMP), + 4 + ), STRUCT( + 5, + FALSE, + CAST(b'G\xc3\xbcten Tag' AS BYTES), + CAST('1980-03-14' AS DATE), + CAST('1980-03-14T15:16:17' AS DATETIME), + CAST(NULL AS GEOGRAPHY), + 55555, + 0, + 5.555555000, + 555.555, + 5, + 5, + 'Güten Tag!', + CAST('15:16:17.181921' AS TIME), + CAST('1980-03-14T15:16:17.181921+00:00' AS TIMESTAMP), + 5 + ), STRUCT( + 6, + TRUE, + CAST(b'Hello\tBigFrames!\x07' AS BYTES), + CAST('2023-05-23' AS DATE), + CAST('2023-05-23T11:37:01' AS DATETIME), + ST_GEOGFROMTEXT('LINESTRING (-0.127959 51.507728, -0.127026 51.507473)'), + 101202303, + 2, + -10.090807000, + -123.456, + 6, + 6, + 'capitalize, This ', + CAST('01:02:03.456789' AS TIME), + CAST('2023-05-23T11:42:55.000001+00:00' AS TIMESTAMP), + 6 + ), STRUCT( + 7, + TRUE, + CAST(NULL AS BYTES), + CAST('2038-01-20' AS DATE), + CAST('2038-01-19T03:14:08' AS DATETIME), + CAST(NULL AS GEOGRAPHY), + -214748367, + 2, + 11111111.100000000, + 42.42, + 7, + 7, + ' سلام', + CAST('12:00:00.000001' AS TIME), + CAST('2038-01-19T03:14:17.999999+00:00' AS TIMESTAMP), + 7 + ), STRUCT( + 8, + FALSE, + CAST(NULL AS BYTES), + CAST(NULL AS DATE), + CAST(NULL AS DATETIME), + CAST(NULL AS GEOGRAPHY), + 2, + 1, + CAST(NULL AS NUMERIC), + 6.87, + 8, + 8, + 'T', + CAST(NULL AS TIME), + CAST(NULL AS TIMESTAMP), + 8 + )]) +) SELECT `bfcol_0` AS `bfcol_16`, `bfcol_1` AS `bfcol_17`, @@ -15,157 +173,4 @@ SELECT `bfcol_13` AS `bfcol_29`, `bfcol_14` AS `bfcol_30`, `bfcol_15` AS `bfcol_31` -FROM UNNEST(ARRAY>[STRUCT( - 0, - TRUE, - CAST(b'Hello, World!' AS BYTES), - CAST('2021-07-21' AS DATE), - CAST('2021-07-21T11:39:45' AS DATETIME), - ST_GEOGFROMTEXT('POINT (-122.0838511 37.3860517)'), - 123456789, - 0, - 1.234567890, - 1.25, - 0, - 0, - 'Hello, World!', - CAST('11:41:43.076160' AS TIME), - CAST('2021-07-21T17:43:43.945289+00:00' AS TIMESTAMP), - 0 -), STRUCT( - 1, - FALSE, - CAST(b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf' AS BYTES), - CAST('1991-02-03' AS DATE), - CAST('1991-01-02T03:45:06' AS DATETIME), - ST_GEOGFROMTEXT('POINT (-71.104 42.315)'), - -987654321, - 1, - 1.234567890, - 2.51, - 1, - 1, - 'こんにちは', - CAST('11:14:34.701606' AS TIME), - CAST('2021-07-21T17:43:43.945289+00:00' AS TIMESTAMP), - 1 -), STRUCT( - 2, - TRUE, - CAST(b'\xc2\xa1Hola Mundo!' AS BYTES), - CAST('2023-03-01' AS DATE), - CAST('2023-03-01T10:55:13' AS DATETIME), - ST_GEOGFROMTEXT('POINT (-0.124474760143016 51.5007826749545)'), - 314159, - 0, - 101.101010100, - 25000000000.0, - 2, - 2, - ' ¡Hola Mundo! ', - CAST('23:59:59.999999' AS TIME), - CAST('2023-03-01T10:55:13.250125+00:00' AS TIMESTAMP), - 2 -), STRUCT( - 3, - CAST(NULL AS BOOLEAN), - CAST(NULL AS BYTES), - CAST(NULL AS DATE), - CAST(NULL AS DATETIME), - CAST(NULL AS GEOGRAPHY), - CAST(NULL AS INT64), - 1, - CAST(NULL AS NUMERIC), - CAST(NULL AS FLOAT64), - 3, - 3, - CAST(NULL AS STRING), - CAST(NULL AS TIME), - CAST(NULL AS TIMESTAMP), - 3 -), STRUCT( - 4, - FALSE, - CAST(b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf' AS BYTES), - CAST('2021-07-21' AS DATE), - CAST(NULL AS DATETIME), - CAST(NULL AS GEOGRAPHY), - -234892, - -2345, - CAST(NULL AS NUMERIC), - CAST(NULL AS FLOAT64), - 4, - 4, - 'Hello, World!', - CAST(NULL AS TIME), - CAST(NULL AS TIMESTAMP), - 4 -), STRUCT( - 5, - FALSE, - CAST(b'G\xc3\xbcten Tag' AS BYTES), - CAST('1980-03-14' AS DATE), - CAST('1980-03-14T15:16:17' AS DATETIME), - CAST(NULL AS GEOGRAPHY), - 55555, - 0, - 5.555555000, - 555.555, - 5, - 5, - 'Güten Tag!', - CAST('15:16:17.181921' AS TIME), - CAST('1980-03-14T15:16:17.181921+00:00' AS TIMESTAMP), - 5 -), STRUCT( - 6, - TRUE, - CAST(b'Hello\tBigFrames!\x07' AS BYTES), - CAST('2023-05-23' AS DATE), - CAST('2023-05-23T11:37:01' AS DATETIME), - ST_GEOGFROMTEXT('LINESTRING (-0.127959 51.507728, -0.127026 51.507473)'), - 101202303, - 2, - -10.090807000, - -123.456, - 6, - 6, - 'capitalize, This ', - CAST('01:02:03.456789' AS TIME), - CAST('2023-05-23T11:42:55.000001+00:00' AS TIMESTAMP), - 6 -), STRUCT( - 7, - TRUE, - CAST(NULL AS BYTES), - CAST('2038-01-20' AS DATE), - CAST('2038-01-19T03:14:08' AS DATETIME), - CAST(NULL AS GEOGRAPHY), - -214748367, - 2, - 11111111.100000000, - 42.42, - 7, - 7, - ' سلام', - CAST('12:00:00.000001' AS TIME), - CAST('2038-01-19T03:14:17.999999+00:00' AS TIMESTAMP), - 7 -), STRUCT( - 8, - FALSE, - CAST(NULL AS BYTES), - CAST(NULL AS DATE), - CAST(NULL AS DATETIME), - CAST(NULL AS GEOGRAPHY), - 2, - 1, - CAST(NULL AS NUMERIC), - 6.87, - 8, - 8, - 'T', - CAST(NULL AS TIME), - CAST(NULL AS TIMESTAMP), - 8 -)]) \ No newline at end of file +FROM `bfcte_0` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_json_df/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_json_df/out.sql index 3b780e6d8e..c0e5a0a476 100644 --- a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_json_df/out.sql +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_json_df/out.sql @@ -1,4 +1,9 @@ +WITH `bfcte_0` AS ( + SELECT + * + FROM UNNEST(ARRAY>[STRUCT(PARSE_JSON('null'), 0), STRUCT(PARSE_JSON('true'), 1), STRUCT(PARSE_JSON('100'), 2), STRUCT(PARSE_JSON('0.98'), 3), STRUCT(PARSE_JSON('"a string"'), 4), STRUCT(PARSE_JSON('[]'), 5), STRUCT(PARSE_JSON('[1,2,3]'), 6), STRUCT(PARSE_JSON('[{"a":1},{"a":2},{"a":null},{}]'), 7), STRUCT(PARSE_JSON('"100"'), 8), STRUCT(PARSE_JSON('{"date":"2024-07-16"}'), 9), STRUCT(PARSE_JSON('{"int_value":2,"null_filed":null}'), 10), STRUCT(PARSE_JSON('{"list_data":[10,20,30]}'), 11)]) +) SELECT `bfcol_0` AS `bfcol_2`, `bfcol_1` AS `bfcol_3` -FROM UNNEST(ARRAY>[STRUCT(PARSE_JSON('null'), 0), STRUCT(PARSE_JSON('true'), 1), STRUCT(PARSE_JSON('100'), 2), STRUCT(PARSE_JSON('0.98'), 3), STRUCT(PARSE_JSON('"a string"'), 4), STRUCT(PARSE_JSON('[]'), 5), STRUCT(PARSE_JSON('[1,2,3]'), 6), STRUCT(PARSE_JSON('[{"a":1},{"a":2},{"a":null},{}]'), 7), STRUCT(PARSE_JSON('"100"'), 8), STRUCT(PARSE_JSON('{"date":"2024-07-16"}'), 9), STRUCT(PARSE_JSON('{"int_value":2,"null_filed":null}'), 10), STRUCT(PARSE_JSON('{"list_data":[10,20,30]}'), 11)]) \ No newline at end of file +FROM `bfcte_0` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_lists_df/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_lists_df/out.sql index 6998b41b27..c97babdaef 100644 --- a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_lists_df/out.sql +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_lists_df/out.sql @@ -1,3 +1,38 @@ +WITH `bfcte_0` AS ( + SELECT + * + FROM UNNEST(ARRAY, `bfcol_2` ARRAY, `bfcol_3` ARRAY, `bfcol_4` ARRAY, `bfcol_5` ARRAY, `bfcol_6` ARRAY, `bfcol_7` ARRAY, `bfcol_8` INT64>>[STRUCT( + 0, + [1], + [TRUE], + [1.2, 2.3], + ['2021-07-21'], + ['2021-07-21 11:39:45'], + [1.2, 2.3, 3.4], + ['abc', 'de', 'f'], + 0 + ), STRUCT( + 1, + [1, 2], + [TRUE, FALSE], + [1.1], + ['2021-07-21', '1987-03-28'], + ['1999-03-14 17:22:00'], + [5.5, 2.3], + ['a', 'bc', 'de'], + 1 + ), STRUCT( + 2, + [1, 2, 3], + [TRUE], + [0.5, -1.9, 2.3], + ['2017-08-01', '2004-11-22'], + ['1979-06-03 03:20:45'], + [1.7000000000000002], + ['', 'a'], + 2 + )]) +) SELECT `bfcol_0` AS `bfcol_9`, `bfcol_1` AS `bfcol_10`, @@ -8,34 +43,4 @@ SELECT `bfcol_6` AS `bfcol_15`, `bfcol_7` AS `bfcol_16`, `bfcol_8` AS `bfcol_17` -FROM UNNEST(ARRAY, `bfcol_2` ARRAY, `bfcol_3` ARRAY, `bfcol_4` ARRAY, `bfcol_5` ARRAY, `bfcol_6` ARRAY, `bfcol_7` ARRAY, `bfcol_8` INT64>>[STRUCT( - 0, - [1], - [TRUE], - [1.2, 2.3], - ['2021-07-21'], - ['2021-07-21 11:39:45'], - [1.2, 2.3, 3.4], - ['abc', 'de', 'f'], - 0 -), STRUCT( - 1, - [1, 2], - [TRUE, FALSE], - [1.1], - ['2021-07-21', '1987-03-28'], - ['1999-03-14 17:22:00'], - [5.5, 2.3], - ['a', 'bc', 'de'], - 1 -), STRUCT( - 2, - [1, 2, 3], - [TRUE], - [0.5, -1.9, 2.3], - ['2017-08-01', '2004-11-22'], - ['1979-06-03 03:20:45'], - [1.7000000000000002], - ['', 'a'], - 2 -)]) \ No newline at end of file +FROM `bfcte_0` \ No newline at end of file diff --git a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_structs_df/out.sql b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_structs_df/out.sql index 99b94915bf..509e63e029 100644 --- a/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_structs_df/out.sql +++ b/tests/unit/core/compile/sqlglot/snapshots/test_compile_readlocal/test_compile_readlocal_w_structs_df/out.sql @@ -1,21 +1,26 @@ +WITH `bfcte_0` AS ( + SELECT + * + FROM UNNEST(ARRAY>, `bfcol_2` INT64>>[STRUCT( + 1, + STRUCT( + 'Alice' AS `name`, + 30 AS `age`, + STRUCT('New York' AS `city`, 'USA' AS `country`) AS `address` + ), + 0 + ), STRUCT( + 2, + STRUCT( + 'Bob' AS `name`, + 25 AS `age`, + STRUCT('London' AS `city`, 'UK' AS `country`) AS `address` + ), + 1 + )]) +) SELECT `bfcol_0` AS `bfcol_3`, `bfcol_1` AS `bfcol_4`, `bfcol_2` AS `bfcol_5` -FROM UNNEST(ARRAY>, `bfcol_2` INT64>>[STRUCT( - 1, - STRUCT( - 'Alice' AS `name`, - 30 AS `age`, - STRUCT('New York' AS `city`, 'USA' AS `country`) AS `address` - ), - 0 -), STRUCT( - 2, - STRUCT( - 'Bob' AS `name`, - 25 AS `age`, - STRUCT('London' AS `city`, 'UK' AS `country`) AS `address` - ), - 1 -)]) \ No newline at end of file +FROM `bfcte_0` \ No newline at end of file diff --git a/tests/unit/core/tools/__init__.py b/tests/unit/core/tools/__init__.py new file mode 100644 index 0000000000..0a2669d7a2 --- /dev/null +++ b/tests/unit/core/tools/__init__.py @@ -0,0 +1,13 @@ +# 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. diff --git a/tests/unit/core/tools/test_datetimes.py b/tests/unit/core/tools/test_datetimes.py new file mode 100644 index 0000000000..96a6b14ef8 --- /dev/null +++ b/tests/unit/core/tools/test_datetimes.py @@ -0,0 +1,43 @@ +# 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 typing import cast +from unittest import mock + +import bigframes.core.tools.datetimes +import bigframes.dtypes +import bigframes.pandas +import bigframes.testing.mocks + + +def test_to_datetime_with_series_and_format_doesnt_cache(monkeypatch): + df = bigframes.testing.mocks.create_dataframe(monkeypatch) + series = mock.Mock(spec=bigframes.pandas.Series, wraps=df["col"]) + dt_series = cast( + bigframes.pandas.Series, + bigframes.core.tools.datetimes.to_datetime(series, format="%Y%m%d"), + ) + series._cached.assert_not_called() + assert dt_series.dtype == bigframes.dtypes.DATETIME_DTYPE + + +def test_to_datetime_with_series_and_format_utc_doesnt_cache(monkeypatch): + df = bigframes.testing.mocks.create_dataframe(monkeypatch) + series = mock.Mock(spec=bigframes.pandas.Series, wraps=df["col"]) + dt_series = cast( + bigframes.pandas.Series, + bigframes.core.tools.datetimes.to_datetime(series, format="%Y%m%d", utc=True), + ) + series._cached.assert_not_called() + assert dt_series.dtype == bigframes.dtypes.TIMESTAMP_DTYPE diff --git a/third_party/bigframes_vendored/version.py b/third_party/bigframes_vendored/version.py index c6ca0ee57c..3058b5f7a3 100644 --- a/third_party/bigframes_vendored/version.py +++ b/third_party/bigframes_vendored/version.py @@ -12,8 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "2.2.0" +__version__ = "2.3.0" # {x-release-please-start-date} -__release_date__ = "2025-04-30" +__release_date__ = "2025-05-06" # {x-release-please-end}