From 1054405ce4eaad1d78a2991056b828363d5754d5 Mon Sep 17 00:00:00 2001 From: Shenyang Cai Date: Tue, 11 Feb 2025 13:33:39 -0800 Subject: [PATCH 01/18] refactor: resolve identifier package names in nodes.py (#1385) * fix: resolve identifier package names in nodes.py * fix format * revert table.num_rows change --- bigframes/core/nodes.py | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/bigframes/core/nodes.py b/bigframes/core/nodes.py index d5273e5c0a..f74ffabe96 100644 --- a/bigframes/core/nodes.py +++ b/bigframes/core/nodes.py @@ -800,7 +800,7 @@ class ReadLocalNode(LeafNode): # Mapping of local ids to bfet id. scan_list: ScanList # Offsets are generated only if this is non-null - offsets_col: Optional[bigframes.core.identifiers.ColumnId] = None + offsets_col: Optional[identifiers.ColumnId] = None session: typing.Optional[bigframes.session.Session] = None @property @@ -1039,7 +1039,7 @@ class CachedTableNode(ReadTableNode): # Unary nodes @dataclasses.dataclass(frozen=True, eq=False) class PromoteOffsetsNode(UnaryNode, AdditiveNode): - col_id: bigframes.core.identifiers.ColumnId + col_id: identifiers.ColumnId @property def non_local(self) -> bool: @@ -1317,9 +1317,7 @@ def remap_refs( class ProjectionNode(UnaryNode, AdditiveNode): """Assigns new variables (without modifying existing ones)""" - assignments: typing.Tuple[ - typing.Tuple[ex.Expression, bigframes.core.identifiers.ColumnId], ... - ] + assignments: typing.Tuple[typing.Tuple[ex.Expression, identifiers.ColumnId], ...] def _validate(self): input_types = self.child._dtype_lookup @@ -1445,9 +1443,7 @@ def remap_refs( @dataclasses.dataclass(frozen=True, eq=False) class AggregateNode(UnaryNode): - aggregations: typing.Tuple[ - typing.Tuple[ex.Aggregation, bigframes.core.identifiers.ColumnId], ... - ] + aggregations: typing.Tuple[typing.Tuple[ex.Aggregation, identifiers.ColumnId], ...] by_column_ids: typing.Tuple[ex.DerefOp, ...] = tuple([]) order_by: Tuple[OrderingExpression, ...] = () dropna: bool = True @@ -1539,7 +1535,7 @@ def remap_refs( class WindowOpNode(UnaryNode, AdditiveNode): expression: ex.Aggregation window_spec: window.WindowSpec - output_name: bigframes.core.identifiers.ColumnId + output_name: identifiers.ColumnId never_skip_nulls: bool = False skip_reproject_unsafe: bool = False @@ -1682,7 +1678,7 @@ def remap_refs( class ExplodeNode(UnaryNode): column_ids: typing.Tuple[ex.DerefOp, ...] # Offsets are generated only if this is non-null - offsets_col: Optional[bigframes.core.identifiers.ColumnId] = None + offsets_col: Optional[identifiers.ColumnId] = None @property def row_preserving(self) -> bool: From 4c8e6c3fbeb2baca5350d9060fe212cc1cb67c3b Mon Sep 17 00:00:00 2001 From: Garrett Wu <6505921+GarrettWu@users.noreply.github.com> Date: Tue, 11 Feb 2025 16:09:06 -0800 Subject: [PATCH 02/18] chore: add experimental blob.image_resize function (#1383) * chore: add experimental blob.image_resize function * refactor --- bigframes/blob/_functions.py | 44 +++++++++++++++++++++++++ bigframes/operations/blob.py | 62 ++++++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+) diff --git a/bigframes/blob/_functions.py b/bigframes/blob/_functions.py index a05030140e..d74ba54371 100644 --- a/bigframes/blob/_functions.py +++ b/bigframes/blob/_functions.py @@ -130,6 +130,50 @@ def image_blur_func( image_blur_def = FunctionDef(image_blur_func, ["opencv-python", "numpy", "requests"]) +def image_resize_func( + src_obj_ref_rt: str, + dst_obj_ref_rt: str, + dsize_x: int, + dsize_y: int, + fx: float, + fy: float, +) -> str: + import json + + import cv2 as cv # type: ignore + import numpy as np + import requests + + src_obj_ref_rt_json = json.loads(src_obj_ref_rt) + dst_obj_ref_rt_json = json.loads(dst_obj_ref_rt) + + src_url = src_obj_ref_rt_json["access_urls"]["read_url"] + dst_url = dst_obj_ref_rt_json["access_urls"]["write_url"] + + response = requests.get(src_url) + bts = response.content + + nparr = np.frombuffer(bts, np.uint8) + img = cv.imdecode(nparr, cv.IMREAD_UNCHANGED) + img_resized = cv.resize(img, dsize=(dsize_x, dsize_y), fx=fx, fy=fy) + bts = cv.imencode(".jpeg", img_resized)[1].tobytes() + + requests.put( + url=dst_url, + data=bts, + headers={ + "Content-Type": "image/jpeg", + }, + ) + + return dst_obj_ref_rt + + +image_resize_def = FunctionDef( + image_resize_func, ["opencv-python", "numpy", "requests"] +) + + # Extracts all text from a PDF url def pdf_extract_func(src_obj_ref_rt: str) -> str: import io diff --git a/bigframes/operations/blob.py b/bigframes/operations/blob.py index 7fa4dd9633..c2275a36e8 100644 --- a/bigframes/operations/blob.py +++ b/bigframes/operations/blob.py @@ -322,6 +322,68 @@ def image_blur( return dst + def image_resize( + self, + dsize: tuple[int, int] = (0, 0), + *, + fx: float = 0.0, + fy: float = 0.0, + dst: Union[str, bigframes.series.Series], + connection: Optional[str] = None, + ): + """Resize images. + + .. note:: + BigFrames Blob is still under experiments. It may not work and subject to change in the future. + + Args: + dsize (tuple(int, int), default (0, 0)): Destination size. If set to 0, fx and fy parameters determine the size. + fx (float, default 0.0): scale factor along the horizontal axis. If set to 0.0, dsize parameter determines the output size. + fy (float, defalut 0.0): scale factor along the vertical axis. If set to 0.0, dsize parameter determines the output size. + dst (str or bigframes.series.Series): Destination GCS folder str or blob series. + connection (str or None, default None): BQ connection used for function internet transactions, and the output blob if "dst" is str. If None, uses default connection of the session. + + Returns: + BigFrames Blob Series + """ + dsize_set = dsize[0] > 0 and dsize[1] > 0 + fsize_set = fx > 0.0 and fy > 0.0 + if not dsize_set ^ fsize_set: + raise ValueError( + "Only one of dsize or (fx, fy) parameters must be set. And the set values must be positive. " + ) + + import bigframes.blob._functions as blob_func + + connection = self._resolve_connection(connection) + + if isinstance(dst, str): + dst = os.path.join(dst, "") + src_uri = bigframes.series.Series(self._block).struct.explode()["uri"] + # Replace src folder with dst folder, keep the file names. + dst_uri = src_uri.str.replace(r"^.*\/(.*)$", rf"{dst}\1", regex=True) + dst = cast( + bigframes.series.Series, dst_uri.str.to_blob(connection=connection) + ) + + image_resize_udf = blob_func.TransformFunction( + blob_func.image_resize_def, + session=self._block.session, + connection=connection, + ).udf() + + src_rt = self._get_runtime_json_str(mode="R") + dst_rt = dst.blob._get_runtime_json_str(mode="RW") + + df = src_rt.to_frame().join(dst_rt.to_frame(), how="outer") + df["dsize_x"], df["dsizye_y"] = dsize + df["fx"], df["fy"] = fx, fy + + res = df.apply(image_resize_udf, axis=1) + res.cache() # to execute the udf + + return dst + def pdf_extract( self, *, connection: Optional[str] = None ) -> bigframes.series.Series: From 64b5ff135d17993091a25f5d634a2c0619bae885 Mon Sep 17 00:00:00 2001 From: TrevorBergeron Date: Tue, 11 Feb 2025 20:47:24 -0800 Subject: [PATCH 03/18] refactor: Tree traversals now non-recursive (#1386) --- bigframes/core/bigframe_node.py | 368 ++++++++++++++++++++++++++++++ bigframes/core/nodes.py | 283 +---------------------- bigframes/core/tree_properties.py | 2 +- bigframes/session/executor.py | 4 +- 4 files changed, 379 insertions(+), 278 deletions(-) create mode 100644 bigframes/core/bigframe_node.py diff --git a/bigframes/core/bigframe_node.py b/bigframes/core/bigframe_node.py new file mode 100644 index 0000000000..5012e99c9a --- /dev/null +++ b/bigframes/core/bigframe_node.py @@ -0,0 +1,368 @@ +# Copyright 2023 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 abc +import collections +import dataclasses +import functools +import itertools +import typing +from typing import Callable, Dict, Generator, Iterable, Mapping, Set, Tuple + +from bigframes.core import identifiers +import bigframes.core.guid +import bigframes.core.schema as schemata +import bigframes.dtypes + +if typing.TYPE_CHECKING: + import bigframes.session + +COLUMN_SET = frozenset[identifiers.ColumnId] + + +@dataclasses.dataclass(frozen=True) +class Field: + id: identifiers.ColumnId + dtype: bigframes.dtypes.Dtype + + +@dataclasses.dataclass(eq=False, frozen=True) +class BigFrameNode: + """ + Immutable node for representing 2D typed array as a tree of operators. + + All subclasses must be hashable so as to be usable as caching key. + """ + + @property + def deterministic(self) -> bool: + """Whether this node will evaluates deterministically.""" + return True + + @property + def row_preserving(self) -> bool: + """Whether this node preserves input rows.""" + return True + + @property + def non_local(self) -> bool: + """ + Whether this node combines information across multiple rows instead of processing rows independently. + Used as an approximation for whether the expression may require shuffling to execute (and therefore be expensive). + """ + return False + + @property + def child_nodes(self) -> typing.Sequence[BigFrameNode]: + """Direct children of this node""" + return tuple([]) + + @property + @abc.abstractmethod + def row_count(self) -> typing.Optional[int]: + return None + + @abc.abstractmethod + def remap_refs( + self, mappings: Mapping[identifiers.ColumnId, identifiers.ColumnId] + ) -> BigFrameNode: + """Remap variable references""" + ... + + @property + @abc.abstractmethod + def node_defined_ids(self) -> Tuple[identifiers.ColumnId, ...]: + """The variables defined in this node (as opposed to by child nodes).""" + ... + + @functools.cached_property + def session(self): + sessions = [] + for child in self.child_nodes: + if child.session is not None: + sessions.append(child.session) + unique_sessions = len(set(sessions)) + if unique_sessions > 1: + raise ValueError("Cannot use combine sources from multiple sessions.") + elif unique_sessions == 1: + return sessions[0] + return None + + def _validate(self): + """Validate the local data in the node.""" + return + + @functools.cache + def validate_tree(self) -> bool: + for child in self.child_nodes: + child.validate_tree() + self._validate() + field_list = list(self.fields) + if len(set(field_list)) != len(field_list): + raise ValueError(f"Non unique field ids {list(self.fields)}") + return True + + def _as_tuple(self) -> Tuple: + """Get all fields as tuple.""" + return tuple(getattr(self, field.name) for field in dataclasses.fields(self)) + + def __hash__(self) -> int: + # Custom hash that uses cache to avoid costly recomputation + return self._cached_hash + + def __eq__(self, other) -> bool: + # Custom eq that tries to short-circuit full structural comparison + if not isinstance(other, self.__class__): + return False + if self is other: + return True + if hash(self) != hash(other): + return False + return self._as_tuple() == other._as_tuple() + + # BigFrameNode trees can be very deep so its important avoid recalculating the hash from scratch + # Each subclass of BigFrameNode should use this property to implement __hash__ + # The default dataclass-generated __hash__ method is not cached + @functools.cached_property + def _cached_hash(self): + return hash(self._as_tuple()) + + @property + def roots(self) -> typing.Set[BigFrameNode]: + roots = itertools.chain.from_iterable( + map(lambda child: child.roots, self.child_nodes) + ) + return set(roots) + + # TODO: Store some local data lazily for select, aggregate nodes. + @property + @abc.abstractmethod + def fields(self) -> Iterable[Field]: + ... + + @property + def ids(self) -> Iterable[identifiers.ColumnId]: + """All output ids from the node.""" + return (field.id for field in self.fields) + + @property + @abc.abstractmethod + def variables_introduced(self) -> int: + """ + Defines number of values created by the current node. Helps represent the "width" of a query + """ + ... + + @property + def relation_ops_created(self) -> int: + """ + Defines the number of relational ops generated by the current node. Used to estimate query planning complexity. + """ + return 1 + + @property + def joins(self) -> bool: + """ + Defines whether the node joins data. + """ + return False + + @property + @abc.abstractmethod + def order_ambiguous(self) -> bool: + """ + Whether row ordering is potentially ambiguous. For example, ReadTable (without a primary key) could be ordered in different ways. + """ + ... + + @property + @abc.abstractmethod + def explicitly_ordered(self) -> bool: + """ + Whether row ordering is potentially ambiguous. For example, ReadTable (without a primary key) could be ordered in different ways. + """ + ... + + @functools.cached_property + def height(self) -> int: + if len(self.child_nodes) == 0: + return 0 + return max(child.height for child in self.child_nodes) + 1 + + @functools.cached_property + def total_variables(self) -> int: + return self.variables_introduced + sum( + map(lambda x: x.total_variables, self.child_nodes) + ) + + @functools.cached_property + def total_relational_ops(self) -> int: + return self.relation_ops_created + sum( + map(lambda x: x.total_relational_ops, self.child_nodes) + ) + + @functools.cached_property + def total_joins(self) -> int: + return int(self.joins) + sum(map(lambda x: x.total_joins, self.child_nodes)) + + @functools.cached_property + def schema(self) -> schemata.ArraySchema: + # TODO: Make schema just a view on fields + return schemata.ArraySchema( + tuple(schemata.SchemaItem(i.id.name, i.dtype) for i in self.fields) + ) + + @property + def planning_complexity(self) -> int: + """ + Empirical heuristic measure of planning complexity. + + Used to determine when to decompose overly complex computations. May require tuning. + """ + return self.total_variables * self.total_relational_ops * (1 + self.total_joins) + + @abc.abstractmethod + def transform_children( + self, t: Callable[[BigFrameNode], BigFrameNode] + ) -> BigFrameNode: + """Apply a function to each child node.""" + ... + + @abc.abstractmethod + def remap_vars( + self, mappings: Mapping[identifiers.ColumnId, identifiers.ColumnId] + ) -> BigFrameNode: + """Remap defined (in this node only) variables.""" + ... + + @property + def defines_namespace(self) -> bool: + """ + If true, this node establishes a new column id namespace. + + If false, this node consumes and produces ids in the namespace + """ + return False + + @property + def referenced_ids(self) -> COLUMN_SET: + return frozenset() + + @functools.cached_property + def defined_variables(self) -> set[str]: + """Full set of variables defined in the namespace, even if not selected.""" + self_defined_variables = set(self.schema.names) + if self.defines_namespace: + return self_defined_variables + return self_defined_variables.union( + *(child.defined_variables for child in self.child_nodes) + ) + + def get_type(self, id: identifiers.ColumnId) -> bigframes.dtypes.Dtype: + return self._dtype_lookup[id] + + @functools.cached_property + def _dtype_lookup(self): + return {field.id: field.dtype for field in self.fields} + + # Plan algorithms + def unique_nodes( + self: BigFrameNode, + ) -> Generator[BigFrameNode, None, None]: + """Walks the tree for unique nodes""" + seen = set() + stack: list[BigFrameNode] = [self] + while stack: + item = stack.pop() + if item not in seen: + yield item + seen.add(item) + stack.extend(item.child_nodes) + + def edges( + self: BigFrameNode, + ) -> Generator[Tuple[BigFrameNode, BigFrameNode], None, None]: + for item in self.unique_nodes(): + for child in item.child_nodes: + yield (item, child) + + def iter_nodes_topo(self: BigFrameNode) -> Generator[BigFrameNode, None, None]: + """Returns nodes from bottom up.""" + queue = collections.deque( + [node for node in self.unique_nodes() if not node.child_nodes] + ) + + child_to_parents: Dict[ + BigFrameNode, Set[BigFrameNode] + ] = collections.defaultdict(set) + for parent, child in self.edges(): + child_to_parents[child].add(parent) + + yielded = set() + + while queue: + item = queue.popleft() + yield item + yielded.add(item) + for parent in child_to_parents[item]: + if set(parent.child_nodes).issubset(yielded): + queue.append(parent) + + def top_down( + self: BigFrameNode, + transform: Callable[[BigFrameNode], BigFrameNode], + ) -> BigFrameNode: + """ + Perform a top-down transformation of the BigFrameNode tree. + """ + to_process = [self] + results: Dict[BigFrameNode, BigFrameNode] = {} + + while to_process: + item = to_process.pop() + if item not in results.keys(): + item_result = transform(item) + results[item] = item_result + to_process.extend(item_result.child_nodes) + + to_process = [self] + # for each processed item, replace its children + for item in reversed(list(results.keys())): + results[item] = results[item].transform_children(lambda x: results[x]) + + return results[self] + + def bottom_up( + self: BigFrameNode, + transform: Callable[[BigFrameNode], BigFrameNode], + ) -> BigFrameNode: + """ + Perform a bottom-up transformation of the BigFrameNode tree. + + The `transform` function is applied to each node *after* its children + have been transformed. This allows for transformations that depend + on the results of transforming subtrees. + + Returns the transformed root node. + """ + results: dict[BigFrameNode, BigFrameNode] = {} + for node in list(self.iter_nodes_topo()): + # child nodes have already been transformed + result = node.transform_children(lambda x: results[x]) + result = transform(result) + results[node] = result + + return results[self] diff --git a/bigframes/core/nodes.py b/bigframes/core/nodes.py index f74ffabe96..b786032a74 100644 --- a/bigframes/core/nodes.py +++ b/bigframes/core/nodes.py @@ -20,11 +20,12 @@ import functools import itertools import typing -from typing import Callable, cast, Iterable, Mapping, Optional, Sequence, Tuple, TypeVar +from typing import Callable, cast, Iterable, Mapping, Optional, Sequence, Tuple import google.cloud.bigquery as bq from bigframes.core import identifiers +from bigframes.core.bigframe_node import BigFrameNode, COLUMN_SET, Field import bigframes.core.expression as ex import bigframes.core.guid from bigframes.core.ordering import OrderingExpression @@ -41,246 +42,6 @@ # A fixed number of variable to assume for overhead on some operations OVERHEAD_VARIABLES = 5 -COLUMN_SET = frozenset[identifiers.ColumnId] - -Self = TypeVar("Self") - - -@dataclasses.dataclass(frozen=True) -class Field: - id: identifiers.ColumnId - dtype: bigframes.dtypes.Dtype - - -@dataclasses.dataclass(eq=False, frozen=True) -class BigFrameNode(abc.ABC): - """ - Immutable node for representing 2D typed array as a tree of operators. - - All subclasses must be hashable so as to be usable as caching key. - """ - - @property - def deterministic(self) -> bool: - """Whether this node will evaluates deterministically.""" - return True - - @property - def row_preserving(self) -> bool: - """Whether this node preserves input rows.""" - return True - - @property - def non_local(self) -> bool: - """ - Whether this node combines information across multiple rows instead of processing rows independently. - Used as an approximation for whether the expression may require shuffling to execute (and therefore be expensive). - """ - return False - - @property - def child_nodes(self) -> typing.Sequence[BigFrameNode]: - """Direct children of this node""" - return tuple([]) - - @property - @abc.abstractmethod - def row_count(self) -> typing.Optional[int]: - return None - - @abc.abstractmethod - def remap_vars( - self: Self, mappings: Mapping[identifiers.ColumnId, identifiers.ColumnId] - ) -> Self: - """Remap defined (in this node only) variables.""" - ... - - @abc.abstractmethod - def remap_refs( - self: Self, mappings: Mapping[identifiers.ColumnId, identifiers.ColumnId] - ) -> Self: - """Remap variable references""" - ... - - @property - @abc.abstractmethod - def node_defined_ids(self) -> Tuple[identifiers.ColumnId, ...]: - """The variables defined in this node (as opposed to by child nodes).""" - ... - - @property - def referenced_ids(self) -> COLUMN_SET: - return frozenset() - - @functools.cached_property - def session(self): - sessions = [] - for child in self.child_nodes: - if child.session is not None: - sessions.append(child.session) - unique_sessions = len(set(sessions)) - if unique_sessions > 1: - raise ValueError("Cannot use combine sources from multiple sessions.") - elif unique_sessions == 1: - return sessions[0] - return None - - def _validate(self): - """Validate the local data in the node.""" - return - - @functools.cache - def validate_tree(self) -> bool: - for child in self.child_nodes: - child.validate_tree() - self._validate() - field_list = list(self.fields) - if len(set(field_list)) != len(field_list): - raise ValueError(f"Non unique field ids {list(self.fields)}") - return True - - def _as_tuple(self) -> Tuple: - """Get all fields as tuple.""" - return tuple(getattr(self, field.name) for field in dataclasses.fields(self)) - - def __hash__(self) -> int: - # Custom hash that uses cache to avoid costly recomputation - return self._cached_hash - - def __eq__(self, other) -> bool: - # Custom eq that tries to short-circuit full structural comparison - if not isinstance(other, self.__class__): - return False - if self is other: - return True - if hash(self) != hash(other): - return False - return self._as_tuple() == other._as_tuple() - - # BigFrameNode trees can be very deep so its important avoid recalculating the hash from scratch - # Each subclass of BigFrameNode should use this property to implement __hash__ - # The default dataclass-generated __hash__ method is not cached - @functools.cached_property - def _cached_hash(self): - return hash(self._as_tuple()) - - @property - def roots(self) -> typing.Set[BigFrameNode]: - roots = itertools.chain.from_iterable( - map(lambda child: child.roots, self.child_nodes) - ) - return set(roots) - - # TODO: Store some local data lazily for select, aggregate nodes. - @property - @abc.abstractmethod - def fields(self) -> Iterable[Field]: - ... - - @property - def ids(self) -> Iterable[identifiers.ColumnId]: - """All output ids from the node.""" - return (field.id for field in self.fields) - - @property - @abc.abstractmethod - def variables_introduced(self) -> int: - """ - Defines number of values created by the current node. Helps represent the "width" of a query - """ - ... - - @property - def relation_ops_created(self) -> int: - """ - Defines the number of relational ops generated by the current node. Used to estimate query planning complexity. - """ - return 1 - - @property - def joins(self) -> bool: - """ - Defines whether the node joins data. - """ - return False - - @property - @abc.abstractmethod - def order_ambiguous(self) -> bool: - """ - Whether row ordering is potentially ambiguous. For example, ReadTable (without a primary key) could be ordered in different ways. - """ - ... - - @property - @abc.abstractmethod - def explicitly_ordered(self) -> bool: - """ - Whether row ordering is potentially ambiguous. For example, ReadTable (without a primary key) could be ordered in different ways. - """ - ... - - @functools.cached_property - def height(self) -> int: - if len(self.child_nodes) == 0: - return 0 - return max(child.height for child in self.child_nodes) + 1 - - @functools.cached_property - def total_variables(self) -> int: - return self.variables_introduced + sum( - map(lambda x: x.total_variables, self.child_nodes) - ) - - @functools.cached_property - def total_relational_ops(self) -> int: - return self.relation_ops_created + sum( - map(lambda x: x.total_relational_ops, self.child_nodes) - ) - - @functools.cached_property - def total_joins(self) -> int: - return int(self.joins) + sum(map(lambda x: x.total_joins, self.child_nodes)) - - @functools.cached_property - def schema(self) -> schemata.ArraySchema: - # TODO: Make schema just a view on fields - return schemata.ArraySchema( - tuple(schemata.SchemaItem(i.id.name, i.dtype) for i in self.fields) - ) - - @property - def planning_complexity(self) -> int: - """ - Empirical heuristic measure of planning complexity. - - Used to determine when to decompose overly complex computations. May require tuning. - """ - return self.total_variables * self.total_relational_ops * (1 + self.total_joins) - - @abc.abstractmethod - def transform_children( - self: Self, t: Callable[[BigFrameNode], BigFrameNode] - ) -> Self: - """Apply a function to each child node.""" - ... - - @property - def defines_namespace(self) -> bool: - """ - If true, this node establishes a new column id namespace. - - If false, this node consumes and produces ids in the namespace - """ - return False - - def get_type(self, id: identifiers.ColumnId) -> bigframes.dtypes.Dtype: - return self._dtype_lookup[id] - - @functools.cached_property - def _dtype_lookup(self): - return {field.id: field.dtype for field in self.fields} - class AdditiveNode: """Definition of additive - if you drop added_fields, you end up with the descendent. @@ -1741,50 +1502,24 @@ def remap_refs( def top_down( root: BigFrameNode, transform: Callable[[BigFrameNode], BigFrameNode], - *, - memoize=False, - validate=False, ) -> BigFrameNode: """ Perform a top-down transformation of the BigFrameNode tree. - - If memoize=True, recursive calls are memoized within the scope of the traversal only. """ - - def top_down_internal(root: BigFrameNode) -> BigFrameNode: - return transform(root).transform_children(top_down_internal) - - if memoize: - # MUST reassign to the same name or caching won't work recursively - top_down_internal = functools.cache(top_down_internal) - - result = top_down_internal(root) - if validate: - result.validate_tree() - return result + return root.top_down(transform) def bottom_up( root: BigFrameNode, transform: Callable[[BigFrameNode], BigFrameNode], - *, - memoize=False, - validate=False, ) -> BigFrameNode: """ Perform a bottom-up transformation of the BigFrameNode tree. - If memoize=True, recursive calls are memoized within the scope of the traversal only. - """ - - def bottom_up_internal(root: BigFrameNode) -> BigFrameNode: - return transform(root.transform_children(bottom_up_internal)) + The `transform` function is applied to each node *after* its children + have been transformed. This allows for transformations that depend + on the results of transforming subtrees. - if memoize: - # MUST reassign to the same name or caching won't work recursively - bottom_up_internal = functools.cache(bottom_up_internal) - - result = bottom_up_internal(root) - if validate: - result.validate_tree() - return result + Returns the transformed root node. + """ + return root.bottom_up(transform) diff --git a/bigframes/core/tree_properties.py b/bigframes/core/tree_properties.py index d893356207..82df53af82 100644 --- a/bigframes/core/tree_properties.py +++ b/bigframes/core/tree_properties.py @@ -88,7 +88,7 @@ def select_cache_target( @functools.cache def _with_caching(subtree: nodes.BigFrameNode) -> nodes.BigFrameNode: - return nodes.top_down(subtree, lambda x: cache.get(x, x), memoize=True) + return nodes.top_down(subtree, lambda x: cache.get(x, x)) def _combine_counts( left: Dict[nodes.BigFrameNode, int], right: Dict[nodes.BigFrameNode, int] diff --git a/bigframes/session/executor.py b/bigframes/session/executor.py index 553c3fd6e6..502692929d 100644 --- a/bigframes/session/executor.py +++ b/bigframes/session/executor.py @@ -513,9 +513,7 @@ def _run_execute_query( raise def replace_cached_subtrees(self, node: nodes.BigFrameNode) -> nodes.BigFrameNode: - return nodes.top_down( - node, lambda x: self._cached_executions.get(x, x), memoize=True - ) + return nodes.top_down(node, lambda x: self._cached_executions.get(x, x)) def _is_trivially_executable(self, array_value: bigframes.core.ArrayValue): """ From d6fbb5b6ccda879d91ab51ab5836f8ec34fe9f04 Mon Sep 17 00:00:00 2001 From: Garrett Wu <6505921+GarrettWu@users.noreply.github.com> Date: Wed, 12 Feb 2025 10:48:25 -0800 Subject: [PATCH 04/18] chore: add experimental blob.image_normalize function (#1388) --- bigframes/blob/_functions.py | 48 +++++++++++++++++++++++++++++++ bigframes/operations/blob.py | 56 ++++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+) diff --git a/bigframes/blob/_functions.py b/bigframes/blob/_functions.py index d74ba54371..a2578fe3e5 100644 --- a/bigframes/blob/_functions.py +++ b/bigframes/blob/_functions.py @@ -174,6 +174,54 @@ def image_resize_func( ) +def image_normalize_func( + src_obj_ref_rt: str, dst_obj_ref_rt: str, alpha: float, beta: float, norm_type: str +) -> str: + import json + + import cv2 as cv # type: ignore + import numpy as np + import requests + + norm_type_mapping = { + "inf": cv.NORM_INF, + "l1": cv.NORM_L1, + "l2": cv.NORM_L2, + "minmax": cv.NORM_MINMAX, + } + + src_obj_ref_rt_json = json.loads(src_obj_ref_rt) + dst_obj_ref_rt_json = json.loads(dst_obj_ref_rt) + + src_url = src_obj_ref_rt_json["access_urls"]["read_url"] + dst_url = dst_obj_ref_rt_json["access_urls"]["write_url"] + + response = requests.get(src_url) + bts = response.content + + nparr = np.frombuffer(bts, np.uint8) + img = cv.imdecode(nparr, cv.IMREAD_UNCHANGED) + img_normalized = cv.normalize( + img, None, alpha=alpha, beta=beta, norm_type=norm_type_mapping[norm_type] + ) + bts = cv.imencode(".jpeg", img_normalized)[1].tobytes() + + requests.put( + url=dst_url, + data=bts, + headers={ + "Content-Type": "image/jpeg", + }, + ) + + return dst_obj_ref_rt + + +image_normalize_def = FunctionDef( + image_normalize_func, ["opencv-python", "numpy", "requests"] +) + + # Extracts all text from a PDF url def pdf_extract_func(src_obj_ref_rt: str) -> str: import io diff --git a/bigframes/operations/blob.py b/bigframes/operations/blob.py index c2275a36e8..30e396656a 100644 --- a/bigframes/operations/blob.py +++ b/bigframes/operations/blob.py @@ -384,6 +384,62 @@ def image_resize( return dst + def image_normalize( + self, + *, + alpha: float = 1.0, + beta: float = 0.0, + norm_type: str = "l2", + dst: Union[str, bigframes.series.Series], + connection: Optional[str] = None, + ) -> bigframes.series.Series: + """Normalize images. + + .. note:: + BigFrames Blob is still under experiments. It may not work and subject to change in the future. + + Args: + alpha (float, default 1.0): Norm value to normalize to or the lower range boundary in case of the range normalization. + beta (float, default 0.0): Upper range boundary in case of the range normalization; it is not used for the norm normalization. + norm_type (str, default "l2"): Normalization type. Accepted values are "inf", "l1", "l2" and "minmax". + dst (str or bigframes.series.Series): Destination GCS folder str or blob series. + connection (str or None, default None): BQ connection used for function internet transactions, and the output blob if "dst" is str. If None, uses default connection of the session. + + Returns: + BigFrames Blob Series + """ + import bigframes.blob._functions as blob_func + + connection = self._resolve_connection(connection) + + if isinstance(dst, str): + dst = os.path.join(dst, "") + src_uri = bigframes.series.Series(self._block).struct.explode()["uri"] + # Replace src folder with dst folder, keep the file names. + dst_uri = src_uri.str.replace(r"^.*\/(.*)$", rf"{dst}\1", regex=True) + dst = cast( + bigframes.series.Series, dst_uri.str.to_blob(connection=connection) + ) + + image_normalize_udf = blob_func.TransformFunction( + blob_func.image_normalize_def, + session=self._block.session, + connection=connection, + ).udf() + + src_rt = self._get_runtime_json_str(mode="R") + dst_rt = dst.blob._get_runtime_json_str(mode="RW") + + df = src_rt.to_frame().join(dst_rt.to_frame(), how="outer") + df["alpha"] = alpha + df["beta"] = beta + df["norm_type"] = norm_type + + res = df.apply(image_normalize_udf, axis=1) + res.cache() # to execute the udf + + return dst + def pdf_extract( self, *, connection: Optional[str] = None ) -> bigframes.series.Series: From 00611d4d697a8b74451375f5a7700b92a4410295 Mon Sep 17 00:00:00 2001 From: TrevorBergeron Date: Wed, 12 Feb 2025 13:38:34 -0800 Subject: [PATCH 05/18] perf: Use simple null constraints to simplify queries (#1381) --- bigframes/core/bigframe_node.py | 18 ++- bigframes/core/blocks.py | 1 - bigframes/core/compile/compiled.py | 175 +++++++++++++++++++++-- bigframes/core/compile/compiler.py | 11 +- bigframes/core/compile/isin.py | 71 --------- bigframes/core/compile/single_column.py | 83 ----------- bigframes/core/expression.py | 21 +++ bigframes/core/nodes.py | 97 ++++++++++--- tests/system/small/core/test_indexers.py | 16 --- 9 files changed, 287 insertions(+), 206 deletions(-) delete mode 100644 bigframes/core/compile/isin.py delete mode 100644 bigframes/core/compile/single_column.py diff --git a/bigframes/core/bigframe_node.py b/bigframes/core/bigframe_node.py index 5012e99c9a..32c7f92912 100644 --- a/bigframes/core/bigframe_node.py +++ b/bigframes/core/bigframe_node.py @@ -37,6 +37,17 @@ class Field: id: identifiers.ColumnId dtype: bigframes.dtypes.Dtype + # Best effort, nullable=True if not certain + nullable: bool = True + + def with_nullable(self) -> Field: + return Field(self.id, self.dtype, nullable=True) + + def with_nonnull(self) -> Field: + return Field(self.id, self.dtype, nullable=False) + + def with_id(self, id: identifiers.ColumnId) -> Field: + return Field(id, self.dtype, nullable=self.nullable) @dataclasses.dataclass(eq=False, frozen=True) @@ -274,10 +285,15 @@ def defined_variables(self) -> set[str]: def get_type(self, id: identifiers.ColumnId) -> bigframes.dtypes.Dtype: return self._dtype_lookup[id] + # TODO: Deprecate in favor of field_by_id, and eventually, by rich references @functools.cached_property - def _dtype_lookup(self): + def _dtype_lookup(self) -> dict[identifiers.ColumnId, bigframes.dtypes.Dtype]: return {field.id: field.dtype for field in self.fields} + @functools.cached_property + def field_by_id(self) -> Mapping[identifiers.ColumnId, Field]: + return {field.id: field for field in self.fields} + # Plan algorithms def unique_nodes( self: BigFrameNode, diff --git a/bigframes/core/blocks.py b/bigframes/core/blocks.py index 8d3732f3fe..10970b24e8 100644 --- a/bigframes/core/blocks.py +++ b/bigframes/core/blocks.py @@ -2049,7 +2049,6 @@ def concat( def isin(self, other: Block): # TODO: Support multiple other columns and match on label - # TODO: Model as explicit "IN" subquery/join to better allow db to optimize assert len(other.value_columns) == 1 unique_other_values = other.expr.select_columns( [other.value_columns[0]] diff --git a/bigframes/core/compile/compiled.py b/bigframes/core/compile/compiled.py index 93be998b5b..6a2b583b28 100644 --- a/bigframes/core/compile/compiled.py +++ b/bigframes/core/compile/compiled.py @@ -16,7 +16,7 @@ import functools import itertools import typing -from typing import Optional, Sequence +from typing import Literal, Optional, Sequence import bigframes_vendored.ibis import bigframes_vendored.ibis.backends.bigquery.backend as ibis_bigquery @@ -94,7 +94,7 @@ def to_sql( return typing.cast(str, sql) @property - def columns(self) -> typing.Tuple[ibis_types.Value, ...]: + def columns(self) -> tuple[ibis_types.Value, ...]: return self._columns @property @@ -107,7 +107,7 @@ def _ibis_bindings(self) -> dict[str, ibis_types.Value]: def projection( self, - expression_id_pairs: typing.Tuple[typing.Tuple[ex.Expression, str], ...], + expression_id_pairs: tuple[tuple[ex.Expression, str], ...], ) -> UnorderedIR: """Apply an expression to the ArrayValue and assign the output to a column.""" cannot_inline = any(expr.expensive for expr, _ in expression_id_pairs) @@ -126,7 +126,7 @@ def projection( def selection( self, - input_output_pairs: typing.Tuple[typing.Tuple[ex.DerefOp, str], ...], + input_output_pairs: tuple[tuple[ex.DerefOp, str], ...], ) -> UnorderedIR: """Apply an expression to the ArrayValue and assign the output to a column.""" bindings = {col: self._get_ibis_column(col) for col in self.column_ids} @@ -203,7 +203,7 @@ def filter(self, predicate: ex.Expression) -> UnorderedIR: def aggregate( self, - aggregations: typing.Sequence[typing.Tuple[ex.Aggregation, str]], + aggregations: typing.Sequence[tuple[ex.Aggregation, str]], by_column_ids: typing.Sequence[ex.DerefOp] = (), dropna: bool = True, order_by: typing.Sequence[OrderingExpression] = (), @@ -323,7 +323,105 @@ def from_pandas( columns=columns, ) - ## Methods that only work with ordering + def join( + self: UnorderedIR, + right: UnorderedIR, + conditions: tuple[tuple[str, str], ...], + type: Literal["inner", "outer", "left", "right", "cross"], + *, + join_nulls: bool = True, + ) -> UnorderedIR: + """Join two expressions by column equality. + + Arguments: + left: Expression for left table to join. + left_column_ids: Column IDs (not label) to join by. + right: Expression for right table to join. + right_column_ids: Column IDs (not label) to join by. + how: The type of join to perform. + join_nulls (bool): + If True, will joins NULL keys to each other. + Returns: + The joined expression. The resulting columns will be, in order, + first the coalesced join keys, then, all the left columns, and + finally, all the right columns. + """ + # Shouldn't need to select the column ids explicitly, but it seems that ibis has some + # bug resolving column ids otherwise, potentially because of the "JoinChain" op + left_table = self._to_ibis_expr().select(self.column_ids) + right_table = right._to_ibis_expr().select(right.column_ids) + + join_conditions = [ + _join_condition( + left_table[left_index], right_table[right_index], nullsafe=join_nulls + ) + for left_index, right_index in conditions + ] + + combined_table = bigframes_vendored.ibis.join( + left_table, + right_table, + predicates=join_conditions, + how=type, # type: ignore + ) + columns = [combined_table[col.get_name()] for col in self.columns] + [ + combined_table[col.get_name()] for col in right.columns + ] + return UnorderedIR( + combined_table, + columns=columns, + ) + + def isin_join( + self: UnorderedIR, + right: UnorderedIR, + indicator_col: str, + conditions: tuple[str, str], + *, + join_nulls: bool = True, + ) -> UnorderedIR: + """Join two expressions by column equality. + + Arguments: + left: Expression for left table to join. + right: Expression for right table to join. + conditions: Id pairs to compare + Returns: + The joined expression. + """ + left_table = self._to_ibis_expr() + right_table = right._to_ibis_expr() + if join_nulls: # nullsafe isin join must actually use "exists" subquery + new_column = ( + ( + _join_condition( + left_table[conditions[0]], + right_table[conditions[1]], + nullsafe=True, + ) + ) + .any() + .name(indicator_col) + ) + + else: # Can do simpler "in" subquery + new_column = ( + (left_table[conditions[0]]) + .isin((right_table[conditions[1]])) + .name(indicator_col) + ) + + columns = tuple( + itertools.chain( + (left_table[col.get_name()] for col in self.columns), (new_column,) + ) + ) + + return UnorderedIR( + left_table, + columns=columns, + ) + def project_window_op( self, expression: ex.Aggregation, @@ -429,7 +527,7 @@ def _ibis_window_from_spec(self, window_spec: WindowSpec): group_by: typing.List[ibis_types.Value] = ( [ typing.cast( - ibis_types.Column, _as_identity(self._compile_expression(column)) + ibis_types.Column, _as_groupable(self._compile_expression(column)) ) for column in window_spec.grouping_keys ] @@ -514,7 +612,68 @@ def _convert_ordering_to_table_values( return ordering_values -def _as_identity(value: ibis_types.Value): +def _string_cast_join_cond( + lvalue: ibis_types.Column, rvalue: ibis_types.Column +) -> ibis_types.BooleanColumn: + result = ( + lvalue.cast(ibis_dtypes.str).fill_null(ibis_types.literal("0")) + == rvalue.cast(ibis_dtypes.str).fill_null(ibis_types.literal("0")) + ) & ( + lvalue.cast(ibis_dtypes.str).fill_null(ibis_types.literal("1")) + == rvalue.cast(ibis_dtypes.str).fill_null(ibis_types.literal("1")) + ) + return typing.cast(ibis_types.BooleanColumn, result) + + +def _numeric_join_cond( + lvalue: ibis_types.Column, rvalue: ibis_types.Column +) -> ibis_types.BooleanColumn: + lvalue1 = lvalue.fill_null(ibis_types.literal(0)) + lvalue2 = lvalue.fill_null(ibis_types.literal(1)) + rvalue1 = rvalue.fill_null(ibis_types.literal(0)) + rvalue2 = rvalue.fill_null(ibis_types.literal(1)) + if lvalue.type().is_floating() and rvalue.type().is_floating(): + # NaN aren't equal so need to coalesce as well with diff constants + lvalue1 = ( + typing.cast(ibis_types.FloatingColumn, lvalue) + .isnan() + .ifelse(ibis_types.literal(2), lvalue1) + ) + lvalue2 = ( + typing.cast(ibis_types.FloatingColumn, lvalue) + .isnan() + .ifelse(ibis_types.literal(3), lvalue2) + ) + rvalue1 = ( + typing.cast(ibis_types.FloatingColumn, rvalue) + .isnan() + .ifelse(ibis_types.literal(2), rvalue1) + ) + rvalue2 = ( + typing.cast(ibis_types.FloatingColumn, rvalue) + .isnan() + .ifelse(ibis_types.literal(3), rvalue2) + ) + result = (lvalue1 == rvalue1) & (lvalue2 == rvalue2) + return typing.cast(ibis_types.BooleanColumn, result) + + +def _join_condition( + lvalue: ibis_types.Column, rvalue: ibis_types.Column, nullsafe: bool +) -> ibis_types.BooleanColumn: + if (lvalue.type().is_floating()) and (lvalue.type().is_floating()): + # Need to always make safe join condition to handle nan, even if no nulls + return _numeric_join_cond(lvalue, rvalue) + if nullsafe: + # TODO: Define more coalesce constants for non-numeric types to avoid cast + if (lvalue.type().is_numeric()) and (lvalue.type().is_numeric()): + return _numeric_join_cond(lvalue, rvalue) + else: + return _string_cast_join_cond(lvalue, rvalue) + return typing.cast(ibis_types.BooleanColumn, lvalue == rvalue) + + +def _as_groupable(value: ibis_types.Value): # Some types need to be converted to string to enable groupby if value.type().is_float64() or value.type().is_geospatial(): return value.cast(ibis_dtypes.str) diff --git a/bigframes/core/compile/compiler.py b/bigframes/core/compile/compiler.py index 64a0ae265f..0b508b01ab 100644 --- a/bigframes/core/compile/compiler.py +++ b/bigframes/core/compile/compiler.py @@ -29,11 +29,9 @@ import bigframes.core.compile.concat as concat_impl import bigframes.core.compile.explode import bigframes.core.compile.ibis_types -import bigframes.core.compile.isin import bigframes.core.compile.scalar_op_compiler import bigframes.core.compile.scalar_op_compiler as compile_scalar import bigframes.core.compile.schema_translator -import bigframes.core.compile.single_column import bigframes.core.expression as ex import bigframes.core.identifiers as ids import bigframes.core.nodes as nodes @@ -130,24 +128,25 @@ def compile_join(self, node: nodes.JoinNode): condition_pairs = tuple( (left.id.sql, right.id.sql) for left, right in node.conditions ) + left_unordered = self.compile_node(node.left_child) right_unordered = self.compile_node(node.right_child) - return bigframes.core.compile.single_column.join_by_column_unordered( - left=left_unordered, + return left_unordered.join( right=right_unordered, type=node.type, conditions=condition_pairs, + join_nulls=node.joins_nulls, ) @_compile_node.register def compile_isin(self, node: nodes.InNode): left_unordered = self.compile_node(node.left_child) right_unordered = self.compile_node(node.right_child) - return bigframes.core.compile.isin.isin_unordered( - left=left_unordered, + return left_unordered.isin_join( right=right_unordered, indicator_col=node.indicator_col.sql, conditions=(node.left_col.id.sql, node.right_col.id.sql), + join_nulls=node.joins_nulls, ) @_compile_node.register diff --git a/bigframes/core/compile/isin.py b/bigframes/core/compile/isin.py deleted file mode 100644 index 29acf9e284..0000000000 --- a/bigframes/core/compile/isin.py +++ /dev/null @@ -1,71 +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 -# -# 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. - -"""Helpers to join ArrayValue objects.""" - -from __future__ import annotations - -import itertools -from typing import Tuple - -import bigframes_vendored.ibis.expr.datatypes as ibis_dtypes -import bigframes_vendored.ibis.expr.types as ibis_types - -import bigframes.core.compile.compiled as compiled - - -def isin_unordered( - left: compiled.UnorderedIR, - right: compiled.UnorderedIR, - indicator_col: str, - conditions: Tuple[str, str], -) -> compiled.UnorderedIR: - """Join two expressions by column equality. - - Arguments: - left: Expression for left table to join. - right: Expression for right table to join. - conditions: Id pairs to compare - Returns: - The joined expression. - """ - left_table = left._to_ibis_expr() - right_table = right._to_ibis_expr() - new_column = ( - value_to_join_key(left_table[conditions[0]]) - .isin(value_to_join_key(right_table[conditions[1]])) - .name(indicator_col) - ) - - columns = tuple( - itertools.chain( - (left_table[col.get_name()] for col in left.columns), (new_column,) - ) - ) - - return compiled.UnorderedIR( - left_table, - columns=columns, - ) - - -def value_to_join_key(value: ibis_types.Value): - """Converts nullable values to non-null string SQL will not match null keys together - but pandas does.""" - if not value.type().is_string(): - value = value.cast(ibis_dtypes.str) - return ( - value.fill_null(ibis_types.literal("$NULL_SENTINEL$")) - if hasattr(value, "fill_null") - else value.fillna(ibis_types.literal("$NULL_SENTINEL$")) - ) diff --git a/bigframes/core/compile/single_column.py b/bigframes/core/compile/single_column.py deleted file mode 100644 index 9216051d91..0000000000 --- a/bigframes/core/compile/single_column.py +++ /dev/null @@ -1,83 +0,0 @@ -# Copyright 2023 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. - -"""Helpers to join ArrayValue objects.""" - -from __future__ import annotations - -from typing import Literal, Tuple - -import bigframes_vendored.ibis.expr.api as ibis_api -import bigframes_vendored.ibis.expr.datatypes as ibis_dtypes -import bigframes_vendored.ibis.expr.types as ibis_types - -import bigframes.core.compile.compiled as compiled - - -def join_by_column_unordered( - left: compiled.UnorderedIR, - right: compiled.UnorderedIR, - conditions: Tuple[Tuple[str, str], ...], - type: Literal["inner", "outer", "left", "right", "cross"], -) -> compiled.UnorderedIR: - """Join two expressions by column equality. - - Arguments: - left: Expression for left table to join. - left_column_ids: Column IDs (not label) to join by. - right: Expression for right table to join. - right_column_ids: Column IDs (not label) to join by. - how: The type of join to perform. - allow_row_identity_join (bool): - If True, allow matching by row identity. Set to False to always - perform a true JOIN in generated SQL. - Returns: - The joined expression. The resulting columns will be, in order, - first the coalesced join keys, then, all the left columns, and - finally, all the right columns. - """ - # Shouldn't need to select the column ids explicitly, but it seems that ibis has some - # bug resolving column ids otherwise, potentially because of the "JoinChain" op - left_table = left._to_ibis_expr().select(left.column_ids) - right_table = right._to_ibis_expr().select(right.column_ids) - join_conditions = [ - value_to_join_key(left_table[left_index]) - == value_to_join_key(right_table[right_index]) - for left_index, right_index in conditions - ] - - combined_table = ibis_api.join( - left_table, - right_table, - predicates=join_conditions, - how=type, # type: ignore - ) - columns = [combined_table[col.get_name()] for col in left.columns] + [ - combined_table[col.get_name()] for col in right.columns - ] - return compiled.UnorderedIR( - combined_table, - columns=columns, - ) - - -def value_to_join_key(value: ibis_types.Value): - """Converts nullable values to non-null string SQL will not match null keys together - but pandas does.""" - if not value.type().is_string(): - value = value.cast(ibis_dtypes.str) - return ( - value.fill_null(ibis_types.literal("$NULL_SENTINEL$")) - if hasattr(value, "fill_null") - else value.fillna(ibis_types.literal("$NULL_SENTINEL$")) - ) diff --git a/bigframes/core/expression.py b/bigframes/core/expression.py index 8621d5d915..afd290827d 100644 --- a/bigframes/core/expression.py +++ b/bigframes/core/expression.py @@ -165,6 +165,10 @@ def expensive(self) -> bool: isinstance(ex, OpExpression) and ex.op.expensive for ex in self.walk() ) + @property + def nullable(self) -> bool: + return True + @property @abc.abstractmethod def column_references(self) -> typing.Tuple[ids.ColumnId, ...]: @@ -248,6 +252,10 @@ def is_const(self) -> bool: def column_references(self) -> typing.Tuple[ids.ColumnId, ...]: return () + @property + def nullable(self) -> bool: + return pd.isna(self.value) # type: ignore + def output_type( self, input_types: dict[ids.ColumnId, bigframes.dtypes.Dtype] ) -> dtypes.ExpressionType: @@ -344,6 +352,11 @@ def column_references(self) -> typing.Tuple[ids.ColumnId, ...]: def is_const(self) -> bool: return False + @property + def nullable(self) -> bool: + # Safe default, need to actually bind input schema to determine + return True + def output_type( self, input_types: dict[ids.ColumnId, bigframes.dtypes.Dtype] ) -> dtypes.ExpressionType: @@ -408,6 +421,14 @@ def is_const(self) -> bool: def children(self): return self.inputs + @property + def nullable(self) -> bool: + # This is very conservative, need to label null properties of individual ops to get more precise + null_free = self.is_identity and not any( + child.nullable for child in self.inputs + ) + return not null_free + def output_type( self, input_types: dict[ids.ColumnId, dtypes.ExpressionType] ) -> dtypes.ExpressionType: diff --git a/bigframes/core/nodes.py b/bigframes/core/nodes.py index b786032a74..e2093e57d9 100644 --- a/bigframes/core/nodes.py +++ b/bigframes/core/nodes.py @@ -216,7 +216,7 @@ def explicitly_ordered(self) -> bool: @property def added_fields(self) -> Tuple[Field, ...]: - return (Field(self.indicator_col, bigframes.dtypes.BOOL_DTYPE),) + return (Field(self.indicator_col, bigframes.dtypes.BOOL_DTYPE, nullable=False),) @property def fields(self) -> Iterable[Field]: @@ -250,6 +250,12 @@ def referenced_ids(self) -> COLUMN_SET: def additive_base(self) -> BigFrameNode: return self.left_child + @property + def joins_nulls(self) -> bool: + left_nullable = self.left_child.field_by_id[self.left_col.id].nullable + right_nullable = self.right_child.field_by_id[self.right_col.id].nullable + return left_nullable or right_nullable + def replace_additive_base(self, node: BigFrameNode): return dataclasses.replace(self, left_child=node) @@ -310,7 +316,23 @@ def explicitly_ordered(self) -> bool: @property def fields(self) -> Iterable[Field]: - return itertools.chain(self.left_child.fields, self.right_child.fields) + left_fields = self.left_child.fields + if self.type in ("right", "outer"): + left_fields = map(lambda x: x.with_nullable(), left_fields) + right_fields = self.right_child.fields + if self.type in ("left", "outer"): + right_fields = map(lambda x: x.with_nullable(), right_fields) + return itertools.chain(left_fields, right_fields) + + @property + def joins_nulls(self) -> bool: + for left_ref, right_ref in self.conditions: + if ( + self.left_child.field_by_id[left_ref.id].nullable + and self.right_child.field_by_id[right_ref.id].nullable + ): + return True + return False @functools.cached_property def variables_introduced(self) -> int: @@ -403,6 +425,7 @@ def explicitly_ordered(self) -> bool: @property def fields(self) -> Iterable[Field]: # TODO: Output names should probably be aligned beforehand or be part of concat definition + # TODO: Handle nullability return ( Field(id, field.dtype) for id, field in zip(self.output_ids, self.children[0].fields) @@ -476,7 +499,9 @@ def explicitly_ordered(self) -> bool: @functools.cached_property def fields(self) -> Iterable[Field]: - return (Field(self.output_id, next(iter(self.start.fields)).dtype),) + return ( + Field(self.output_id, next(iter(self.start.fields)).dtype, nullable=False), + ) @functools.cached_property def variables_introduced(self) -> int: @@ -555,6 +580,7 @@ class ScanList: @dataclasses.dataclass(frozen=True, eq=False) class ReadLocalNode(LeafNode): # TODO: Combine feather_bytes, data_schema, n_rows into a LocalDataDef struct + # TODO: Track nullability for local data feather_bytes: bytes data_schema: schemata.ArraySchema n_rows: int @@ -569,7 +595,8 @@ def fields(self) -> Iterable[Field]: fields = (Field(col_id, dtype) for col_id, dtype, _ in self.scan_list.items) if self.offsets_col is not None: return itertools.chain( - fields, (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE),) + fields, + (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE, nullable=False),), ) return fields @@ -655,6 +682,11 @@ def from_table(table: bq.Table, columns: Sequence[str] = ()) -> GbqTable: else tuple(table.clustering_fields), ) + @property + @functools.cache + def schema_by_id(self): + return {col.name: col for col in self.physical_schema} + @dataclasses.dataclass(frozen=True) class BigqueryDataSource: @@ -697,7 +729,10 @@ def session(self): @property def fields(self) -> Iterable[Field]: - return (Field(col_id, dtype) for col_id, dtype, _ in self.scan_list.items) + return ( + Field(col_id, dtype, self.source.table.schema_by_id[source_id].is_nullable) + for col_id, dtype, source_id in self.scan_list.items + ) @property def relation_ops_created(self) -> int: @@ -808,9 +843,7 @@ def non_local(self) -> bool: @property def fields(self) -> Iterable[Field]: - return itertools.chain( - self.child.fields, [Field(self.col_id, bigframes.dtypes.INT_DTYPE)] - ) + return itertools.chain(self.child.fields, self.added_fields) @property def relation_ops_created(self) -> int: @@ -834,7 +867,7 @@ def referenced_ids(self) -> COLUMN_SET: @property def added_fields(self) -> Tuple[Field, ...]: - return (Field(self.col_id, bigframes.dtypes.INT_DTYPE),) + return (Field(self.col_id, bigframes.dtypes.INT_DTYPE, nullable=False),) @property def additive_base(self) -> BigFrameNode: @@ -856,6 +889,7 @@ def remap_refs( @dataclasses.dataclass(frozen=True, eq=False) class FilterNode(UnaryNode): + # TODO: Infer null constraints from predicate predicate: ex.Expression @property @@ -1025,8 +1059,13 @@ def _validate(self): @functools.cached_property def fields(self) -> Iterable[Field]: + input_fields_by_id = {field.id: field for field in self.child.fields} return tuple( - Field(output, self.child.get_type(ref.id)) + Field( + output, + input_fields_by_id[ref.id].dtype, + input_fields_by_id[ref.id].nullable, + ) for ref, output in self.input_output_pairs ) @@ -1091,10 +1130,22 @@ def _validate(self): @functools.cached_property def added_fields(self) -> Tuple[Field, ...]: input_types = self.child._dtype_lookup - return tuple( - Field(id, bigframes.dtypes.dtype_for_etype(ex.output_type(input_types))) - for ex, id in self.assignments - ) + + fields = [] + for expr, id in self.assignments: + field = Field( + id, + bigframes.dtypes.dtype_for_etype(expr.output_type(input_types)), + nullable=expr.nullable, + ) + # Special case until we get better nullability inference in expression objects themselves + if expr.is_identity and not any( + self.child.field_by_id[id].nullable for id in expr.column_references + ): + field = field.with_nonnull() + fields.append(field) + + return tuple(fields) @property def fields(self) -> Iterable[Field]: @@ -1169,7 +1220,7 @@ def non_local(self) -> bool: @property def fields(self) -> Iterable[Field]: - return (Field(self.col_id, bigframes.dtypes.INT_DTYPE),) + return (Field(self.col_id, bigframes.dtypes.INT_DTYPE, nullable=False),) @property def variables_introduced(self) -> int: @@ -1219,19 +1270,22 @@ def non_local(self) -> bool: @functools.cached_property def fields(self) -> Iterable[Field]: - by_items = ( - Field(ref.id, self.child.get_type(ref.id)) for ref in self.by_column_ids - ) + # TODO: Use child nullability to infer grouping key nullability + by_fields = (self.child.field_by_id[ref.id] for ref in self.by_column_ids) + if self.dropna: + by_fields = (field.with_nonnull() for field in by_fields) + # TODO: Label aggregate ops to determine which are guaranteed non-null agg_items = ( Field( id, bigframes.dtypes.dtype_for_etype( agg.output_type(self.child._dtype_lookup) ), + nullable=True, ) for agg, id in self.aggregations ) - return tuple(itertools.chain(by_items, agg_items)) + return tuple(itertools.chain(by_fields, agg_items)) @property def variables_introduced(self) -> int: @@ -1336,6 +1390,7 @@ def row_count(self) -> Optional[int]: @functools.cached_property def added_field(self) -> Field: input_types = self.child._dtype_lookup + # TODO: Determine if output could be non-null return Field( self.output_name, bigframes.dtypes.dtype_for_etype(self.expression.output_type(input_types)), @@ -1453,6 +1508,7 @@ def fields(self) -> Iterable[Field]: bigframes.dtypes.arrow_dtype_to_bigframes_dtype( self.child.get_type(field.id).pyarrow_dtype.value_type # type: ignore ), + nullable=True, ) if field.id in set(map(lambda x: x.id, self.column_ids)) else field @@ -1460,7 +1516,8 @@ def fields(self) -> Iterable[Field]: ) if self.offsets_col is not None: return itertools.chain( - fields, (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE),) + fields, + (Field(self.offsets_col, bigframes.dtypes.INT_DTYPE, nullable=False),), ) return fields diff --git a/tests/system/small/core/test_indexers.py b/tests/system/small/core/test_indexers.py index 2c670f790d..20f1c56185 100644 --- a/tests/system/small/core/test_indexers.py +++ b/tests/system/small/core/test_indexers.py @@ -54,26 +54,10 @@ def string_indexed_number_series(session): ) -def test_non_string_indexed_struct_series_with_string_key_should_warn(session): - s = bpd.Series( - [ - {"project": "pandas", "version": 1}, - ], - dtype=bpd.ArrowDtype( - pa.struct([("project", pa.string()), ("version", pa.int64())]) - ), - session=session, - ) - - with pytest.warns(bigframes.exceptions.BadIndexerKeyWarning): - s["a"] - - @pytest.mark.parametrize( "series", [ "string_indexed_struct_series", - "number_series", "string_indexed_number_series", ], ) From 7e9e93aafd26cbfec9a1710caaf97937bcb6ee05 Mon Sep 17 00:00:00 2001 From: Chelsea Lin Date: Wed, 12 Feb 2025 14:08:13 -0800 Subject: [PATCH 06/18] docs: Add DataFrame.struct docs (#1348) * docs: Add DataFrame.struct docs * add other * autoclass for struct accessor --- .../reference/bigframes.geopandas/geoseries.rst | 4 ++-- docs/reference/bigframes.pandas/frame.rst | 16 ++++++++++++++++ docs/reference/bigframes.pandas/series.rst | 2 +- docs/templates/toc.yml | 17 +++++++++-------- 4 files changed, 28 insertions(+), 11 deletions(-) diff --git a/docs/reference/bigframes.geopandas/geoseries.rst b/docs/reference/bigframes.geopandas/geoseries.rst index 91e853b1f8..481eb73b9d 100644 --- a/docs/reference/bigframes.geopandas/geoseries.rst +++ b/docs/reference/bigframes.geopandas/geoseries.rst @@ -8,8 +8,8 @@ GeoSeries :local: :backlinks: none -Series ------- +GeoSeries +--------- .. autoclass:: bigframes.geopandas.GeoSeries :members: diff --git a/docs/reference/bigframes.pandas/frame.rst b/docs/reference/bigframes.pandas/frame.rst index d1610accdd..bc9f714416 100644 --- a/docs/reference/bigframes.pandas/frame.rst +++ b/docs/reference/bigframes.pandas/frame.rst @@ -3,6 +3,14 @@ DataFrame ========= +.. contents:: Table of Contents + :depth: 2 + :local: + :backlinks: none + +DataFrame +--------- + .. autoclass:: bigframes.dataframe.DataFrame :members: :inherited-members: @@ -18,3 +26,11 @@ Plotting handling :members: :inherited-members: :undoc-members: + +Struct handling +^^^^^^^^^^^^^^^ + +.. autoclass:: bigframes.operations.structs.StructFrameAccessor + :members: + :inherited-members: + :undoc-members: diff --git a/docs/reference/bigframes.pandas/series.rst b/docs/reference/bigframes.pandas/series.rst index 30cf851de7..547b262591 100644 --- a/docs/reference/bigframes.pandas/series.rst +++ b/docs/reference/bigframes.pandas/series.rst @@ -46,7 +46,7 @@ List handling Struct handling ^^^^^^^^^^^^^^^ -.. automodule:: bigframes.operations.structs +.. autoclass:: bigframes.operations.structs.StructAccessor :members: :inherited-members: :undoc-members: diff --git a/docs/templates/toc.yml b/docs/templates/toc.yml index d57ab1c8ac..b4f513b11d 100644 --- a/docs/templates/toc.yml +++ b/docs/templates/toc.yml @@ -38,8 +38,13 @@ uid: bigframes.exceptions name: Core Objects - items: - - name: DataFrame - uid: bigframes.dataframe.DataFrame + - items: + - name: DataFrame + uid: bigframes.dataframe.DataFrame + - name: PlotAccessor + uid: bigframes.operations.plotting.PlotAccessor + - name: StructAccessor + uid: bigframes.operations.structs.StructFrameAccessor - items: - name: DataFrameGroupBy uid: bigframes.core.groupby.DataFrameGroupBy @@ -68,12 +73,6 @@ name: Indexers - name: pandas uid: bigframes.pandas - - items: - - name: Plotting - uid: bigframes.operations.plotting - - name: PlotAccessor - uid: bigframes.operations.plotting.PlotAccessor - name: Plotting - items: - name: Series uid: bigframes.series.Series @@ -83,6 +82,8 @@ uid: bigframes.operations.strings.StringMethods - name: StructAccessor uid: bigframes.operations.structs.StructAccessor + - name: PlotAccessor + uid: bigframes.operations.plotting.PlotAccessor name: Series - name: Window uid: bigframes.core.window.Window From 44f4137adb02790e07c696f0641bc58390857210 Mon Sep 17 00:00:00 2001 From: Chelsea Lin Date: Wed, 12 Feb 2025 22:27:42 -0800 Subject: [PATCH 07/18] feat: JSON dtype support for read_pandas and Series constructor (#1391) * feat: JSON dtype support for read_pandas and Series constructor * add read_pandas tests * address comments --- bigframes/core/compile/compiler.py | 15 ++++- bigframes/core/utils.py | 22 ++++++++ bigframes/dtypes.py | 1 + bigframes/session/_io/pandas.py | 12 +++- bigframes/session/loader.py | 13 +---- tests/system/small/bigquery/test_json.py | 64 ++++++++++----------- tests/system/small/test_dataframe_io.py | 15 +++++ tests/system/small/test_series.py | 22 +++++++- tests/system/small/test_session.py | 72 ++++++++++++++++++++++++ 9 files changed, 187 insertions(+), 49 deletions(-) diff --git a/bigframes/core/compile/compiler.py b/bigframes/core/compile/compiler.py index 0b508b01ab..ed95dacf74 100644 --- a/bigframes/core/compile/compiler.py +++ b/bigframes/core/compile/compiler.py @@ -20,16 +20,17 @@ import bigframes_vendored.ibis.backends.bigquery as ibis_bigquery import bigframes_vendored.ibis.expr.api as ibis_api +import bigframes_vendored.ibis.expr.datatypes as ibis_dtypes import bigframes_vendored.ibis.expr.types as ibis_types import google.cloud.bigquery import pandas as pd +from bigframes import dtypes from bigframes.core import utils import bigframes.core.compile.compiled as compiled import bigframes.core.compile.concat as concat_impl import bigframes.core.compile.explode import bigframes.core.compile.ibis_types -import bigframes.core.compile.scalar_op_compiler import bigframes.core.compile.scalar_op_compiler as compile_scalar import bigframes.core.compile.schema_translator import bigframes.core.expression as ex @@ -224,6 +225,18 @@ def compile_read_table_unordered( ibis_table = self.read_table_as_unordered_ibis( source, scan_cols=[col.source_id for col in scan.items] ) + + # TODO(b/395912450): Remove workaround solution once b/374784249 got resolved. + for scan_item in scan.items: + if ( + scan_item.dtype == dtypes.JSON_DTYPE + and ibis_table[scan_item.source_id].type() == ibis_dtypes.string + ): + json_column = compile_scalar.parse_json( + ibis_table[scan_item.source_id] + ).name(scan_item.source_id) + ibis_table = ibis_table.mutate(json_column) + return compiled.UnorderedIR( ibis_table, tuple( diff --git a/bigframes/core/utils.py b/bigframes/core/utils.py index 0198f12537..502a40d92d 100644 --- a/bigframes/core/utils.py +++ b/bigframes/core/utils.py @@ -24,6 +24,7 @@ import pandas.api.types as pdtypes import typing_extensions +import bigframes.dtypes as dtypes import bigframes.exceptions as bfe UNNAMED_COLUMN_ID = "bigframes_unnamed_column" @@ -226,3 +227,24 @@ def replace_timedeltas_with_micros(dataframe: pd.DataFrame) -> List[str]: updated_columns.append(dataframe.index.name) return updated_columns + + +def replace_json_with_string(dataframe: pd.DataFrame) -> List[str]: + """ + Due to a BigQuery IO limitation with loading JSON from Parquet files (b/374784249), + we're using a workaround: storing JSON as strings and then parsing them into JSON + objects. + TODO(b/395912450): Remove workaround solution once b/374784249 got resolved. + """ + updated_columns = [] + + for col in dataframe.columns: + if dataframe[col].dtype == dtypes.JSON_DTYPE: + dataframe[col] = dataframe[col].astype(dtypes.STRING_DTYPE) + updated_columns.append(col) + + if dataframe.index.dtype == dtypes.JSON_DTYPE: + dataframe.index = dataframe.index.astype(dtypes.STRING_DTYPE) + updated_columns.append(dataframe.index.name) + + return updated_columns diff --git a/bigframes/dtypes.py b/bigframes/dtypes.py index eed45e1dde..9083e13bc8 100644 --- a/bigframes/dtypes.py +++ b/bigframes/dtypes.py @@ -301,6 +301,7 @@ def is_object_like(type_: Union[ExpressionType, str]) -> bool: return type_ in ("object", "O") or ( getattr(type_, "kind", None) == "O" and getattr(type_, "storage", None) != "pyarrow" + and getattr(type_, "name", None) != "dbjson" ) diff --git a/bigframes/session/_io/pandas.py b/bigframes/session/_io/pandas.py index 532a909430..a1549238b3 100644 --- a/bigframes/session/_io/pandas.py +++ b/bigframes/session/_io/pandas.py @@ -14,7 +14,8 @@ from __future__ import annotations import dataclasses -from typing import Collection, List, Union +import typing +from typing import Collection, Union import bigframes_vendored.constants as constants import db_dtypes # type: ignore @@ -38,7 +39,7 @@ class DataFrameAndLabels: column_labels: Collection index_labels: Collection ordering_col: str - timedelta_cols: List[str] + col_type_overrides: typing.Dict[str, bigframes.dtypes.Dtype] def _arrow_to_pandas_arrowdtype( @@ -165,11 +166,16 @@ def pandas_to_bq_compatible(pandas_dataframe: pandas.DataFrame) -> DataFrameAndL pandas_dataframe_copy[ordering_col] = np.arange(pandas_dataframe_copy.shape[0]) timedelta_cols = utils.replace_timedeltas_with_micros(pandas_dataframe_copy) + json_cols = utils.replace_json_with_string(pandas_dataframe_copy) + col_type_overrides: typing.Dict[str, bigframes.dtypes.Dtype] = { + **{col: bigframes.dtypes.TIMEDELTA_DTYPE for col in timedelta_cols}, + **{col: bigframes.dtypes.JSON_DTYPE for col in json_cols}, + } return DataFrameAndLabels( df=pandas_dataframe_copy, column_labels=col_labels, index_labels=idx_labels, ordering_col=ordering_col, - timedelta_cols=timedelta_cols, + col_type_overrides=col_type_overrides, ) diff --git a/bigframes/session/loader.py b/bigframes/session/loader.py index b7550583e5..7204a14870 100644 --- a/bigframes/session/loader.py +++ b/bigframes/session/loader.py @@ -176,15 +176,11 @@ def read_pandas_load_job( self._start_generic_job(load_job) destination_table = self._bqclient.get_table(load_table_destination) - col_type_overrides: typing.Dict[str, bigframes.dtypes.Dtype] = { - col: bigframes.dtypes.TIMEDELTA_DTYPE - for col in df_and_labels.timedelta_cols - } array_value = core.ArrayValue.from_table( table=destination_table, # TODO (b/394156190): Generate this directly from original pandas df. schema=schemata.ArraySchema.from_bq_table( - destination_table, col_type_overrides + destination_table, df_and_labels.col_type_overrides ), session=self._session, offsets_col=ordering_col, @@ -234,16 +230,11 @@ def read_pandas_streaming( raise ValueError( f"Problem loading at least one row from DataFrame: {errors}. {constants.FEEDBACK_LINK}" ) - - col_type_overrides: typing.Dict[str, bigframes.dtypes.Dtype] = { - col: bigframes.dtypes.TIMEDELTA_DTYPE - for col in df_and_labels.timedelta_cols - } array_value = ( core.ArrayValue.from_table( table=destination_table, schema=schemata.ArraySchema.from_bq_table( - destination_table, col_type_overrides + destination_table, df_and_labels.col_type_overrides ), session=self._session, # Don't set the offsets column because we want to group by it. diff --git a/tests/system/small/bigquery/test_json.py b/tests/system/small/bigquery/test_json.py index 8f97856eea..492c0cf9b6 100644 --- a/tests/system/small/bigquery/test_json.py +++ b/tests/system/small/bigquery/test_json.py @@ -12,8 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import json - +import db_dtypes # type: ignore import geopandas as gpd # type: ignore import pandas as pd import pyarrow as pa @@ -24,19 +23,6 @@ import bigframes.pandas as bpd -def _get_series_from_json(json_data): - # Note: converts None to sql "null" and not to json none. - values = [ - f"JSON '{json.dumps(data)}'" if data is not None else "NULL" - for data in json_data - ] - sql = " UNION ALL ".join( - [f"SELECT {id} AS id, {value} AS data" for id, value in enumerate(values)] - ) - df = bpd.read_gbq(sql).set_index("id").sort_index() - return df["data"] - - @pytest.mark.parametrize( ("json_path", "expected_json"), [ @@ -45,10 +31,11 @@ def _get_series_from_json(json_data): ], ) def test_json_set_at_json_path(json_path, expected_json): - s = _get_series_from_json([{"a": {"b": {"c": "tester", "d": []}}}]) + original_json = [{"a": {"b": {"c": "tester", "d": []}}}] + s = bpd.Series(original_json, dtype=db_dtypes.JSONDtype()) actual = bbq.json_set(s, json_path_value_pairs=[(json_path, 10)]) - expected = _get_series_from_json(expected_json) + expected = bpd.Series(expected_json, dtype=db_dtypes.JSONDtype()) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), @@ -65,10 +52,11 @@ def test_json_set_at_json_path(json_path, expected_json): ], ) def test_json_set_at_json_value_type(json_value, expected_json): - s = _get_series_from_json([{"a": {"b": "dev"}}, {"a": {"b": [1, 2]}}]) + original_json = [{"a": {"b": "dev"}}, {"a": {"b": [1, 2]}}] + s = bpd.Series(original_json, dtype=db_dtypes.JSONDtype()) actual = bbq.json_set(s, json_path_value_pairs=[("$.a.b", json_value)]) - expected = _get_series_from_json(expected_json) + expected = bpd.Series(expected_json, dtype=db_dtypes.JSONDtype()) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), @@ -76,13 +64,14 @@ def test_json_set_at_json_value_type(json_value, expected_json): def test_json_set_w_more_pairs(): - s = _get_series_from_json([{"a": 2}, {"b": 5}, {"c": 1}]) + original_json = [{"a": 2}, {"b": 5}, {"c": 1}] + s = bpd.Series(original_json, dtype=db_dtypes.JSONDtype()) actual = bbq.json_set( s, json_path_value_pairs=[("$.a", 1), ("$.b", 2), ("$.a", [3, 4, 5])] ) - expected = _get_series_from_json( - [{"a": 3, "b": 2}, {"a": 4, "b": 2}, {"a": 5, "b": 2, "c": 1}] - ) + + expected_json = [{"a": 3, "b": 2}, {"a": 4, "b": 2}, {"a": 5, "b": 2, "c": 1}] + expected = bpd.Series(expected_json, dtype=db_dtypes.JSONDtype()) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), @@ -90,16 +79,16 @@ def test_json_set_w_more_pairs(): def test_json_set_w_invalid_json_path_value_pairs(): + s = bpd.Series([{"a": 10}], dtype=db_dtypes.JSONDtype()) with pytest.raises(ValueError): - bbq.json_set( - _get_series_from_json([{"a": 10}]), json_path_value_pairs=[("$.a", 1, 100)] # type: ignore - ) + bbq.json_set(s, json_path_value_pairs=[("$.a", 1, 100)]) # type: ignore def test_json_set_w_invalid_value_type(): + s = bpd.Series([{"a": 10}], dtype=db_dtypes.JSONDtype()) with pytest.raises(TypeError): bbq.json_set( - _get_series_from_json([{"a": 10}]), + s, json_path_value_pairs=[ ( "$.a", @@ -117,9 +106,12 @@ def test_json_set_w_invalid_series_type(): def test_json_extract_from_json(): - s = _get_series_from_json([{"a": {"b": [1, 2]}}, {"a": {"c": 1}}, {"a": {"b": 0}}]) + s = bpd.Series( + [{"a": {"b": [1, 2]}}, {"a": {"c": 1}}, {"a": {"b": 0}}], + dtype=db_dtypes.JSONDtype(), + ) actual = bbq.json_extract(s, "$.a.b").to_pandas() - expected = _get_series_from_json([[1, 2], None, 0]).to_pandas() + expected = bpd.Series([[1, 2], None, 0], dtype=db_dtypes.JSONDtype()).to_pandas() pd.testing.assert_series_equal( actual, expected, @@ -127,9 +119,12 @@ def test_json_extract_from_json(): def test_json_extract_from_string(): - s = bpd.Series(['{"a": {"b": [1, 2]}}', '{"a": {"c": 1}}', '{"a": {"b": 0}}']) + s = bpd.Series( + ['{"a": {"b": [1, 2]}}', '{"a": {"c": 1}}', '{"a": {"b": 0}}'], + dtype=pd.StringDtype(storage="pyarrow"), + ) actual = bbq.json_extract(s, "$.a.b") - expected = bpd.Series(["[1,2]", None, "0"]) + expected = bpd.Series(["[1,2]", None, "0"], dtype=pd.StringDtype(storage="pyarrow")) pd.testing.assert_series_equal( actual.to_pandas(), expected.to_pandas(), @@ -142,8 +137,9 @@ def test_json_extract_w_invalid_series_type(): def test_json_extract_array_from_json(): - s = _get_series_from_json( - [{"a": ["ab", "2", "3 xy"]}, {"a": []}, {"a": ["4", "5"]}, {}] + s = bpd.Series( + [{"a": ["ab", "2", "3 xy"]}, {"a": []}, {"a": ["4", "5"]}, {}], + dtype=db_dtypes.JSONDtype(), ) actual = bbq.json_extract_array(s, "$.a") @@ -160,6 +156,8 @@ def test_json_extract_array_from_json(): """ df = bpd.read_gbq(sql).set_index("id").sort_index() expected = df["data"] + expected.index.name = None + expected.name = None pd.testing.assert_series_equal( actual.to_pandas(), diff --git a/tests/system/small/test_dataframe_io.py b/tests/system/small/test_dataframe_io.py index 10637b2395..f84ee811a3 100644 --- a/tests/system/small/test_dataframe_io.py +++ b/tests/system/small/test_dataframe_io.py @@ -658,6 +658,21 @@ def test_to_gbq_w_invalid_destination_table(scalars_df_index): scalars_df_index.to_gbq("table_id") +def test_to_gbq_w_json(bigquery_client): + """Test the `to_gbq` API can get a JSON column.""" + s1 = bpd.Series([1, 2, 3, 4]) + s2 = bpd.Series( + ["a", 1, False, ["a", {"b": 1}], {"c": [1, 2, 3]}], dtype=db_dtypes.JSONDtype() + ) + + df = bpd.DataFrame({"id": s1, "json_col": s2}) + destination_table = df.to_gbq() + table = bigquery_client.get_table(destination_table) + + assert table.schema[1].name == "json_col" + assert table.schema[1].field_type == "JSON" + + @pytest.mark.parametrize( ("index"), [True, False], diff --git a/tests/system/small/test_series.py b/tests/system/small/test_series.py index cdda7c753d..3d3baff21a 100644 --- a/tests/system/small/test_series.py +++ b/tests/system/small/test_series.py @@ -237,7 +237,7 @@ def test_series_construct_geodata(): pytest.param(pd.StringDtype(storage="pyarrow"), id="string"), ], ) -def test_series_construct_w_dtype_for_int(dtype): +def test_series_construct_w_dtype(dtype): data = [1, 2, 3] expected = pd.Series(data, dtype=dtype) expected.index = expected.index.astype("Int64") @@ -302,6 +302,26 @@ def test_series_construct_w_dtype_for_array_struct(): ) +def test_series_construct_w_dtype_for_json(): + data = [ + 1, + "str", + False, + ["a", {"b": 1}, None], + None, + {"a": {"b": [1, 2, 3], "c": True}}, + ] + s = bigframes.pandas.Series(data, dtype=db_dtypes.JSONDtype()) + + assert s[0] == 1 + assert s[1] == "str" + assert s[2] is False + assert s[3][0] == "a" + assert s[3][1]["b"] == 1 + assert pd.isna(s[4]) + assert s[5]["a"] == {"b": [1, 2, 3], "c": True} + + def test_series_keys(scalars_dfs): scalars_df, scalars_pandas_df = scalars_dfs bf_result = scalars_df["int64_col"].keys().to_pandas() diff --git a/tests/system/small/test_session.py b/tests/system/small/test_session.py index a4acb72117..0c8da52774 100644 --- a/tests/system/small/test_session.py +++ b/tests/system/small/test_session.py @@ -22,6 +22,7 @@ import warnings import bigframes_vendored.pandas.io.gbq as vendored_pandas_gbq +import db_dtypes # type: ignore import google import google.cloud.bigquery as bigquery import numpy as np @@ -747,6 +748,77 @@ def test_read_pandas_timedelta_index(session, write_engine): pd.testing.assert_index_equal(actual_result, expected_index) +@pytest.mark.parametrize( + ("write_engine"), + [ + pytest.param("default"), + pytest.param("bigquery_load"), + pytest.param("bigquery_streaming"), + pytest.param("bigquery_inline", marks=pytest.mark.xfail(raises=ValueError)), + ], +) +def test_read_pandas_json_dataframes(session, write_engine): + json_data = [ + 1, + None, + ["1", "3", "5"], + {"a": 1, "b": ["x", "y"], "c": {"z": False, "x": []}}, + ] + expected_df = pd.DataFrame( + {"my_col": pd.Series(json_data, dtype=db_dtypes.JSONDtype())} + ) + + actual_result = session.read_pandas( + expected_df, write_engine=write_engine + ).to_pandas() + + if write_engine == "bigquery_streaming": + expected_df.index = pd.Index([pd.NA] * 4, dtype="Int64") + pd.testing.assert_frame_equal(actual_result, expected_df, check_index_type=False) + + +@pytest.mark.parametrize( + "write_engine", + ["default", "bigquery_load"], +) +def test_read_pandas_json_series(session, write_engine): + json_data = [ + 1, + None, + ["1", "3", "5"], + {"a": 1, "b": ["x", "y"], "c": {"z": False, "x": []}}, + ] + expected_series = pd.Series(json_data, dtype=db_dtypes.JSONDtype()) + + actual_result = session.read_pandas( + expected_series, write_engine=write_engine + ).to_pandas() + pd.testing.assert_series_equal( + actual_result, expected_series, check_index_type=False + ) + + +@pytest.mark.parametrize( + ("write_engine"), + [ + pytest.param("default"), + pytest.param("bigquery_load"), + ], +) +def test_read_pandas_json_index(session, write_engine): + json_data = [ + 1, + None, + ["1", "3", "5"], + {"a": 1, "b": ["x", "y"], "c": {"z": False, "x": []}}, + ] + expected_index = pd.Index(json_data, dtype=db_dtypes.JSONDtype()) + actual_result = session.read_pandas( + expected_index, write_engine=write_engine + ).to_pandas() + pd.testing.assert_index_equal(actual_result, expected_index) + + @utils.skip_legacy_pandas @pytest.mark.parametrize( ("write_engine",), From 34d01b27f867abf10bddffdf4f88fa7052cd237c Mon Sep 17 00:00:00 2001 From: Shenyang Cai Date: Thu, 13 Feb 2025 09:38:23 -0800 Subject: [PATCH 08/18] chore: support comparison, ordering, and filtering for timedeltas (#1387) * [WIP] support timedelta ordering and filtering * chore: support comparison, ordering, and filtering for timedeltas * fix format * some cleanups * use operator package for testing * fix test error --- bigframes/core/rewrite/timedeltas.py | 55 +++++--- bigframes/dtypes.py | 2 +- .../small/operations/test_timedeltas.py | 132 ++++++++++++++++-- 3 files changed, 157 insertions(+), 32 deletions(-) diff --git a/bigframes/core/rewrite/timedeltas.py b/bigframes/core/rewrite/timedeltas.py index d740b28d7d..990aca1f18 100644 --- a/bigframes/core/rewrite/timedeltas.py +++ b/bigframes/core/rewrite/timedeltas.py @@ -12,6 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +from __future__ import annotations + import dataclasses import functools import typing @@ -27,6 +29,14 @@ class _TypedExpr: expr: ex.Expression dtype: dtypes.Dtype + @classmethod + def create_op_expr( + cls, op: typing.Union[ops.ScalarOp, ops.RowOp], *inputs: _TypedExpr + ) -> _TypedExpr: + expr = op.as_expr(*tuple(x.expr for x in inputs)) # type: ignore + dtype = op.output_type(*tuple(x.dtype for x in inputs)) + return cls(expr, dtype) + def rewrite_timedelta_expressions(root: nodes.BigFrameNode) -> nodes.BigFrameNode: """ @@ -38,12 +48,27 @@ def rewrite_timedelta_expressions(root: nodes.BigFrameNode) -> nodes.BigFrameNod (_rewrite_expressions(expr, root.schema).expr, column_id) for expr, column_id in root.assignments ) - root = nodes.ProjectionNode(root.child, updated_assignments) + return nodes.ProjectionNode(root.child, updated_assignments) + + if isinstance(root, nodes.FilterNode): + return nodes.FilterNode( + root.child, _rewrite_expressions(root.predicate, root.schema).expr + ) + + if isinstance(root, nodes.OrderByNode): + by = tuple(_rewrite_ordering_expr(x, root.schema) for x in root.by) + return nodes.OrderByNode(root.child, by) - # TODO(b/394354614): FilterByNode and OrderNode also contain expressions. Need to update them too. return root +def _rewrite_ordering_expr( + expr: nodes.OrderingExpression, schema: schema.ArraySchema +) -> nodes.OrderingExpression: + by = _rewrite_expressions(expr.scalar_expression, schema).expr + return nodes.OrderingExpression(by, expr.direction, expr.na_last) + + @functools.cache def _rewrite_expressions(expr: ex.Expression, schema: schema.ArraySchema) -> _TypedExpr: if isinstance(expr, ex.DerefOp): @@ -78,37 +103,23 @@ def _rewrite_op_expr( if isinstance(expr.op, ops.AddOp): return _rewrite_add_op(inputs[0], inputs[1]) - input_types = tuple(map(lambda x: x.dtype, inputs)) - return _TypedExpr(expr, expr.op.output_type(*input_types)) + return _TypedExpr.create_op_expr(expr.op, *inputs) def _rewrite_sub_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: - result_op: ops.BinaryOp = ops.sub_op if dtypes.is_datetime_like(left.dtype) and dtypes.is_datetime_like(right.dtype): - result_op = ops.timestamp_diff_op + return _TypedExpr.create_op_expr(ops.timestamp_diff_op, left, right) - return _TypedExpr( - result_op.as_expr(left.expr, right.expr), - result_op.output_type(left.dtype, right.dtype), - ) + return _TypedExpr.create_op_expr(ops.sub_op, left, right) def _rewrite_add_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: if dtypes.is_datetime_like(left.dtype) and right.dtype is dtypes.TIMEDELTA_DTYPE: - return _TypedExpr( - ops.timestamp_add_op.as_expr(left.expr, right.expr), - ops.timestamp_add_op.output_type(left.dtype, right.dtype), - ) + return _TypedExpr.create_op_expr(ops.timestamp_add_op, left, right) if left.dtype is dtypes.TIMEDELTA_DTYPE and dtypes.is_datetime_like(right.dtype): # Re-arrange operands such that timestamp is always on the left and timedelta is # always on the right. - return _TypedExpr( - ops.timestamp_add_op.as_expr(right.expr, left.expr), - ops.timestamp_add_op.output_type(right.dtype, left.dtype), - ) + return _TypedExpr.create_op_expr(ops.timestamp_add_op, right, left) - return _TypedExpr( - ops.add_op.as_expr(left.expr, right.expr), - ops.add_op.output_type(left.dtype, right.dtype), - ) + return _TypedExpr.create_op_expr(ops.add_op, left, right) diff --git a/bigframes/dtypes.py b/bigframes/dtypes.py index 9083e13bc8..e4db904210 100644 --- a/bigframes/dtypes.py +++ b/bigframes/dtypes.py @@ -358,7 +358,7 @@ def is_comparable(type_: ExpressionType) -> bool: def is_orderable(type_: ExpressionType) -> bool: # On BQ side, ARRAY, STRUCT, GEOGRAPHY, JSON are not orderable - return type_ in _ORDERABLE_SIMPLE_TYPES + return type_ in _ORDERABLE_SIMPLE_TYPES or type_ is TIMEDELTA_DTYPE _CLUSTERABLE_SIMPLE_TYPES = set( diff --git a/tests/system/small/operations/test_timedeltas.py b/tests/system/small/operations/test_timedeltas.py index 6c44a62686..fe779a8524 100644 --- a/tests/system/small/operations/test_timedeltas.py +++ b/tests/system/small/operations/test_timedeltas.py @@ -14,6 +14,7 @@ import datetime +import operator import numpy as np import pandas as pd @@ -28,12 +29,23 @@ def temporal_dfs(session): "datetime_col": [ pd.Timestamp("2025-02-01 01:00:01"), pd.Timestamp("2019-01-02 02:00:00"), + pd.Timestamp("1997-01-01 19:00:00"), ], "timestamp_col": [ pd.Timestamp("2023-01-01 01:00:01", tz="UTC"), pd.Timestamp("2024-01-02 02:00:00", tz="UTC"), + pd.Timestamp("2005-03-05 02:00:00", tz="UTC"), + ], + "timedelta_col_1": [ + pd.Timedelta(3, "s"), + pd.Timedelta(-4, "d"), + pd.Timedelta(5, "h"), + ], + "timedelta_col_2": [ + pd.Timedelta(2, "s"), + pd.Timedelta(-4, "d"), + pd.Timedelta(6, "h"), ], - "timedelta_col": [pd.Timedelta(3, "s"), pd.Timedelta(-4, "d")], } ) @@ -53,10 +65,10 @@ def test_timestamp_add__ts_series_plus_td_series(temporal_dfs, column, pd_dtype) bf_df, pd_df = temporal_dfs actual_result = ( - (bf_df[column] + bf_df["timedelta_col"]).to_pandas().astype(pd_dtype) + (bf_df[column] + bf_df["timedelta_col_1"]).to_pandas().astype(pd_dtype) ) - expected_result = pd_df[column] + pd_df["timedelta_col"] + expected_result = pd_df[column] + pd_df["timedelta_col_1"] pandas.testing.assert_series_equal( actual_result, expected_result, check_index_type=False ) @@ -94,10 +106,10 @@ def test_timestamp_add__td_series_plus_ts_series(temporal_dfs, column, pd_dtype) bf_df, pd_df = temporal_dfs actual_result = ( - (bf_df["timedelta_col"] + bf_df[column]).to_pandas().astype(pd_dtype) + (bf_df["timedelta_col_1"] + bf_df[column]).to_pandas().astype(pd_dtype) ) - expected_result = pd_df["timedelta_col"] + pd_df[column] + expected_result = pd_df["timedelta_col_1"] + pd_df[column] pandas.testing.assert_series_equal( actual_result, expected_result, check_index_type=False ) @@ -120,10 +132,10 @@ def test_timestamp_add__ts_literal_plus_td_series(temporal_dfs): timestamp = pd.Timestamp("2025-01-01", tz="UTC") actual_result = ( - (timestamp + bf_df["timedelta_col"]).to_pandas().astype("datetime64[ns, UTC]") + (timestamp + bf_df["timedelta_col_1"]).to_pandas().astype("datetime64[ns, UTC]") ) - expected_result = timestamp + pd_df["timedelta_col"] + expected_result = timestamp + pd_df["timedelta_col_1"] pandas.testing.assert_series_equal( actual_result, expected_result, check_index_type=False ) @@ -140,10 +152,10 @@ def test_timestamp_add_with_numpy_op(temporal_dfs, column, pd_dtype): bf_df, pd_df = temporal_dfs actual_result = ( - np.add(bf_df[column], bf_df["timedelta_col"]).to_pandas().astype(pd_dtype) + np.add(bf_df[column], bf_df["timedelta_col_1"]).to_pandas().astype(pd_dtype) ) - expected_result = np.add(pd_df[column], pd_df["timedelta_col"]) + expected_result = np.add(pd_df[column], pd_df["timedelta_col_1"]) pandas.testing.assert_series_equal( actual_result, expected_result, check_index_type=False ) @@ -164,3 +176,105 @@ def test_timestamp_add_dataframes(temporal_dfs): pandas.testing.assert_frame_equal( actual_result, expected_result, check_index_type=False ) + + +@pytest.mark.parametrize( + "compare_func", + [ + pytest.param(operator.gt, id="gt"), + pytest.param(operator.ge, id="ge"), + pytest.param(operator.eq, id="eq"), + pytest.param(operator.ne, id="ne"), + pytest.param(operator.lt, id="lt"), + pytest.param(operator.le, id="le"), + ], +) +def test_timedelta_series_comparison(temporal_dfs, compare_func): + bf_df, pd_df = temporal_dfs + + actual_result = compare_func( + bf_df["timedelta_col_1"], bf_df["timedelta_col_2"] + ).to_pandas() + + expected_result = compare_func( + pd_df["timedelta_col_1"], pd_df["timedelta_col_2"] + ).astype("boolean") + pandas.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False + ) + + +@pytest.mark.parametrize( + "compare_func", + [ + pytest.param(operator.gt, id="gt"), + pytest.param(operator.ge, id="ge"), + pytest.param(operator.eq, id="eq"), + pytest.param(operator.ne, id="ne"), + pytest.param(operator.lt, id="lt"), + pytest.param(operator.le, id="le"), + ], +) +def test_timedelta_series_and_literal_comparison(temporal_dfs, compare_func): + bf_df, pd_df = temporal_dfs + literal = pd.Timedelta(3, "s") + + actual_result = compare_func(literal, bf_df["timedelta_col_2"]).to_pandas() + + expected_result = compare_func(literal, pd_df["timedelta_col_2"]).astype("boolean") + pandas.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False + ) + + +def test_timedelta_filtering(session): + pd_series = pd.Series( + [ + pd.Timestamp("2025-01-01 01:00:00"), + pd.Timestamp("2025-01-01 02:00:00"), + pd.Timestamp("2025-01-01 03:00:00"), + ] + ) + bf_series = session.read_pandas(pd_series) + timestamp = pd.Timestamp("2025-01-01, 00:00:01") + + actual_result = ( + bf_series[((bf_series - timestamp) > pd.Timedelta(1, "h"))] + .to_pandas() + .astype(" pd.Timedelta(1, "h")] + pandas.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False + ) + + +def test_timedelta_ordering(session): + pd_df = pd.DataFrame( + { + "col_1": [ + pd.Timestamp("2025-01-01 01:00:00"), + pd.Timestamp("2025-01-01 02:00:00"), + pd.Timestamp("2025-01-01 03:00:00"), + ], + "col_2": [ + pd.Timestamp("2025-01-01 01:00:02"), + pd.Timestamp("2025-01-01 02:00:01"), + pd.Timestamp("2025-01-01 02:59:59"), + ], + } + ) + bf_df = session.read_pandas(pd_df) + + actual_result = ( + (bf_df["col_2"] - bf_df["col_1"]) + .sort_values() + .to_pandas() + .astype("timedelta64[ns]") + ) + + expected_result = (pd_df["col_2"] - pd_df["col_1"]).sort_values() + pandas.testing.assert_series_equal( + actual_result, expected_result, check_index_type=False + ) From 534f7b45f22db71d5aaf926a08036211d4966dec Mon Sep 17 00:00:00 2001 From: Huan Chen <142538604+Genesis929@users.noreply.github.com> Date: Thu, 13 Feb 2025 15:14:34 -0800 Subject: [PATCH 09/18] chore: update tpch code (#1389) * chore: update tpch code * update q5 * add 14, 17, 20 * add q22 * add q21 * reverse q7 q10 q21 --- .../bigframes_vendored/tpch/queries/q14.py | 2 +- .../bigframes_vendored/tpch/queries/q17.py | 2 +- .../bigframes_vendored/tpch/queries/q20.py | 6 ++-- .../bigframes_vendored/tpch/queries/q22.py | 31 ++++++------------- .../bigframes_vendored/tpch/queries/q3.py | 10 +++--- .../bigframes_vendored/tpch/queries/q5.py | 12 +++---- 6 files changed, 27 insertions(+), 36 deletions(-) diff --git a/third_party/bigframes_vendored/tpch/queries/q14.py b/third_party/bigframes_vendored/tpch/queries/q14.py index f3b747219b..a0260394b9 100644 --- a/third_party/bigframes_vendored/tpch/queries/q14.py +++ b/third_party/bigframes_vendored/tpch/queries/q14.py @@ -18,7 +18,7 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): var1 = date(1995, 9, 1) var2 = date(1995, 10, 1) - merged = lineitem.merge(part, left_on="L_PARTKEY", right_on="P_PARTKEY") + merged = part.merge(lineitem, left_on="P_PARTKEY", right_on="L_PARTKEY") filtered = merged[(merged["L_SHIPDATE"] >= var1) & (merged["L_SHIPDATE"] < var2)] diff --git a/third_party/bigframes_vendored/tpch/queries/q17.py b/third_party/bigframes_vendored/tpch/queries/q17.py index e6a87dc482..aa7f743602 100644 --- a/third_party/bigframes_vendored/tpch/queries/q17.py +++ b/third_party/bigframes_vendored/tpch/queries/q17.py @@ -19,7 +19,7 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): filtered_part = part[(part["P_BRAND"] == VAR1) & (part["P_CONTAINER"] == VAR2)] q1 = bpd.merge( - filtered_part, lineitem, how="left", left_on="P_PARTKEY", right_on="L_PARTKEY" + lineitem, filtered_part, how="right", left_on="L_PARTKEY", right_on="P_PARTKEY" ) grouped = ( diff --git a/third_party/bigframes_vendored/tpch/queries/q20.py b/third_party/bigframes_vendored/tpch/queries/q20.py index 5c2d8d391f..9fee3eb396 100644 --- a/third_party/bigframes_vendored/tpch/queries/q20.py +++ b/third_party/bigframes_vendored/tpch/queries/q20.py @@ -49,8 +49,10 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): partsupp, left_on="P_PARTKEY", right_on="PS_PARTKEY" ) - final_join = joined_parts.merge( - q1, left_on=["PS_SUPPKEY", "P_PARTKEY"], right_on=["L_SUPPKEY", "L_PARTKEY"] + final_join = q1.merge( + joined_parts, + left_on=["L_SUPPKEY", "L_PARTKEY"], + right_on=["PS_SUPPKEY", "P_PARTKEY"], ) final_filtered = final_join[final_join["PS_AVAILQTY"] > final_join["SUM_QUANTITY"]] diff --git a/third_party/bigframes_vendored/tpch/queries/q22.py b/third_party/bigframes_vendored/tpch/queries/q22.py index 153ef63c5d..381183fd1e 100644 --- a/third_party/bigframes_vendored/tpch/queries/q22.py +++ b/third_party/bigframes_vendored/tpch/queries/q22.py @@ -15,37 +15,24 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): ) country_codes = ["13", "31", "23", "29", "30", "18", "17"] - customer["CNTRYCODE"] = customer["C_PHONE"].str.slice(0, 2) + customer = customer[customer["CNTRYCODE"].isin(country_codes)] avg_acctbal = ( - customer[ - (customer["CNTRYCODE"].isin(country_codes)) & (customer["C_ACCTBAL"] > 0) - ][["C_ACCTBAL"]] + customer[customer["C_ACCTBAL"] > 0.0][["C_ACCTBAL"]] .mean() .rename("AVG_ACCTBAL") ) - - orders_unique = orders["O_CUSTKEY"].unique(keep_order=False).to_frame() - - matched_customers = customer.merge( - orders_unique, left_on="C_CUSTKEY", right_on="O_CUSTKEY" - ) - matched_customers["IS_IN_ORDERS"] = True - - customer = customer.merge( - matched_customers[["C_CUSTKEY", "IS_IN_ORDERS"]], on="C_CUSTKEY", how="left" - ) - customer["IS_IN_ORDERS"] = customer["IS_IN_ORDERS"].fillna(False) customer = customer.merge(avg_acctbal, how="cross") - filtered_customers = customer[ - (customer["CNTRYCODE"].isin(country_codes)) - & (customer["C_ACCTBAL"] > customer["AVG_ACCTBAL"]) - & (~customer["IS_IN_ORDERS"]) - ] + filtered_customer = customer[customer["C_ACCTBAL"] > customer["AVG_ACCTBAL"]] - result = filtered_customers.groupby("CNTRYCODE", as_index=False).agg( + orders_unique = orders["O_CUSTKEY"].unique(keep_order=False).to_frame() + filtered_customer = filtered_customer.merge( + orders_unique, left_on="C_CUSTKEY", right_on="O_CUSTKEY", how="left" + ) + filtered_customer = filtered_customer[filtered_customer["O_CUSTKEY"].isnull()] + result = filtered_customer.groupby("CNTRYCODE", as_index=False).agg( NUMCUST=bpd.NamedAgg(column="C_CUSTKEY", aggfunc="count"), TOTACCTBAL=bpd.NamedAgg(column="C_ACCTBAL", aggfunc="sum"), ) diff --git a/third_party/bigframes_vendored/tpch/queries/q3.py b/third_party/bigframes_vendored/tpch/queries/q3.py index 60d181a603..5a43f5fff7 100644 --- a/third_party/bigframes_vendored/tpch/queries/q3.py +++ b/third_party/bigframes_vendored/tpch/queries/q3.py @@ -23,11 +23,13 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): fcustomer = customer[customer["C_MKTSEGMENT"] == "BUILDING"] - jn1 = fcustomer.merge(orders, left_on="C_CUSTKEY", right_on="O_CUSTKEY") - jn2 = jn1.merge(lineitem, left_on="O_ORDERKEY", right_on="L_ORDERKEY") + filtered_orders = orders[orders["O_ORDERDATE"] < date_var] + filtered_lineitem = lineitem[lineitem["L_SHIPDATE"] > date_var] - jn2 = jn2[jn2["O_ORDERDATE"] < date_var] - jn2 = jn2[jn2["L_SHIPDATE"] > date_var] + jn1 = filtered_lineitem.merge( + filtered_orders, left_on="L_ORDERKEY", right_on="O_ORDERKEY" + ) + jn2 = fcustomer.merge(jn1, left_on="C_CUSTKEY", right_on="O_CUSTKEY") jn2["REVENUE"] = jn2["L_EXTENDEDPRICE"] * (1 - jn2["L_DISCOUNT"]) gb = jn2.groupby(["O_ORDERKEY", "O_ORDERDATE", "O_SHIPPRIORITY"], as_index=False) diff --git a/third_party/bigframes_vendored/tpch/queries/q5.py b/third_party/bigframes_vendored/tpch/queries/q5.py index 406df79a5a..1361c40901 100644 --- a/third_party/bigframes_vendored/tpch/queries/q5.py +++ b/third_party/bigframes_vendored/tpch/queries/q5.py @@ -35,20 +35,20 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): var2 = date(1994, 1, 1) var3 = date(1995, 1, 1) + region = region[region["R_NAME"] == var1] + orders = orders[(orders["O_ORDERDATE"] >= var2) & (orders["O_ORDERDATE"] < var3)] + lineitem["REVENUE"] = lineitem["L_EXTENDEDPRICE"] * (1.0 - lineitem["L_DISCOUNT"]) + jn1 = region.merge(nation, left_on="R_REGIONKEY", right_on="N_REGIONKEY") jn2 = jn1.merge(customer, left_on="N_NATIONKEY", right_on="C_NATIONKEY") - jn3 = jn2.merge(orders, left_on="C_CUSTKEY", right_on="O_CUSTKEY") - jn4 = jn3.merge(lineitem, left_on="O_ORDERKEY", right_on="L_ORDERKEY") + jn3 = orders.merge(jn2, left_on="O_CUSTKEY", right_on="C_CUSTKEY") + jn4 = lineitem.merge(jn3, left_on="L_ORDERKEY", right_on="O_ORDERKEY") jn5 = jn4.merge( supplier, left_on=["L_SUPPKEY", "N_NATIONKEY"], right_on=["S_SUPPKEY", "S_NATIONKEY"], ) - jn5 = jn5[jn5["R_NAME"] == var1] - jn5 = jn5[(jn5["O_ORDERDATE"] >= var2) & (jn5["O_ORDERDATE"] < var3)] - jn5["REVENUE"] = jn5["L_EXTENDEDPRICE"] * (1.0 - jn5["L_DISCOUNT"]) - gb = jn5.groupby("N_NAME", as_index=False)["REVENUE"].sum() result_df = gb.sort_values("REVENUE", ascending=False) From 26f351ad72f3615562caba470ad96b865aaccc02 Mon Sep 17 00:00:00 2001 From: Garrett Wu <6505921+GarrettWu@users.noreply.github.com> Date: Thu, 13 Feb 2025 15:48:11 -0800 Subject: [PATCH 10/18] chore: add experimental image transform functions to BQ bytes (#1397) * chore: add experimental image transform functions to BQ bytes * revert unrelated files --- bigframes/blob/_functions.py | 95 ++++++++++++++++++++++++++++++++++++ bigframes/operations/blob.py | 63 +++++++++++++++++++----- 2 files changed, 146 insertions(+), 12 deletions(-) diff --git a/bigframes/blob/_functions.py b/bigframes/blob/_functions.py index a2578fe3e5..14c7a72e78 100644 --- a/bigframes/blob/_functions.py +++ b/bigframes/blob/_functions.py @@ -130,6 +130,32 @@ def image_blur_func( image_blur_def = FunctionDef(image_blur_func, ["opencv-python", "numpy", "requests"]) +def image_blur_to_bytes_func(src_obj_ref_rt: str, ksize_x: int, ksize_y: int) -> bytes: + import json + + import cv2 as cv # type: ignore + import numpy as np + import requests + + src_obj_ref_rt_json = json.loads(src_obj_ref_rt) + src_url = src_obj_ref_rt_json["access_urls"]["read_url"] + + response = requests.get(src_url) + bts = response.content + + nparr = np.frombuffer(bts, np.uint8) + img = cv.imdecode(nparr, cv.IMREAD_UNCHANGED) + img_blurred = cv.blur(img, ksize=(ksize_x, ksize_y)) + bts = cv.imencode(".jpeg", img_blurred)[1].tobytes() + + return bts + + +image_blur_to_bytes_def = FunctionDef( + image_blur_to_bytes_func, ["opencv-python", "numpy", "requests"] +) + + def image_resize_func( src_obj_ref_rt: str, dst_obj_ref_rt: str, @@ -174,6 +200,38 @@ def image_resize_func( ) +def image_resize_to_bytes_func( + src_obj_ref_rt: str, + dsize_x: int, + dsize_y: int, + fx: float, + fy: float, +) -> bytes: + import json + + import cv2 as cv # type: ignore + import numpy as np + import requests + + src_obj_ref_rt_json = json.loads(src_obj_ref_rt) + src_url = src_obj_ref_rt_json["access_urls"]["read_url"] + + response = requests.get(src_url) + bts = response.content + + nparr = np.frombuffer(bts, np.uint8) + img = cv.imdecode(nparr, cv.IMREAD_UNCHANGED) + img_resized = cv.resize(img, dsize=(dsize_x, dsize_y), fx=fx, fy=fy) + bts = cv.imencode(".jpeg", img_resized)[1].tobytes() + + return bts + + +image_resize_to_bytes_def = FunctionDef( + image_resize_to_bytes_func, ["opencv-python", "numpy", "requests"] +) + + def image_normalize_func( src_obj_ref_rt: str, dst_obj_ref_rt: str, alpha: float, beta: float, norm_type: str ) -> str: @@ -222,6 +280,43 @@ def image_normalize_func( ) +def image_normalize_to_bytes_func( + src_obj_ref_rt: str, alpha: float, beta: float, norm_type: str +) -> bytes: + import json + + import cv2 as cv # type: ignore + import numpy as np + import requests + + norm_type_mapping = { + "inf": cv.NORM_INF, + "l1": cv.NORM_L1, + "l2": cv.NORM_L2, + "minmax": cv.NORM_MINMAX, + } + + src_obj_ref_rt_json = json.loads(src_obj_ref_rt) + src_url = src_obj_ref_rt_json["access_urls"]["read_url"] + + response = requests.get(src_url) + bts = response.content + + nparr = np.frombuffer(bts, np.uint8) + img = cv.imdecode(nparr, cv.IMREAD_UNCHANGED) + img_normalized = cv.normalize( + img, None, alpha=alpha, beta=beta, norm_type=norm_type_mapping[norm_type] + ) + bts = cv.imencode(".jpeg", img_normalized)[1].tobytes() + + return bts + + +image_normalize_to_bytes_def = FunctionDef( + image_normalize_to_bytes_func, ["opencv-python", "numpy", "requests"] +) + + # Extracts all text from a PDF url def pdf_extract_func(src_obj_ref_rt: str) -> str: import io diff --git a/bigframes/operations/blob.py b/bigframes/operations/blob.py index 30e396656a..e97515d42b 100644 --- a/bigframes/operations/blob.py +++ b/bigframes/operations/blob.py @@ -276,7 +276,7 @@ def image_blur( self, ksize: tuple[int, int], *, - dst: Union[str, bigframes.series.Series], + dst: Optional[Union[str, bigframes.series.Series]] = None, connection: Optional[str] = None, ) -> bigframes.series.Series: """Blurs images. @@ -286,7 +286,7 @@ def image_blur( Args: ksize (tuple(int, int)): Kernel size. - dst (str or bigframes.series.Series): Destination GCS folder str or blob series. + dst (str or bigframes.series.Series or None, default None): Destination GCS folder str or blob series. If None, output to BQ as bytes. connection (str or None, default None): BQ connection used for function internet transactions, and the output blob if "dst" is str. If None, uses default connection of the session. Returns: @@ -295,6 +295,19 @@ def image_blur( import bigframes.blob._functions as blob_func connection = self._resolve_connection(connection) + df = self._get_runtime_json_str(mode="R").to_frame() + + if dst is None: + image_blur_udf = blob_func.TransformFunction( + blob_func.image_blur_to_bytes_def, + session=self._block.session, + connection=connection, + ).udf() + + df["ksize_x"], df["ksize_y"] = ksize + res = df.apply(image_blur_udf, axis=1) + + return res if isinstance(dst, str): dst = os.path.join(dst, "") @@ -311,10 +324,9 @@ def image_blur( connection=connection, ).udf() - src_rt = self._get_runtime_json_str(mode="R") dst_rt = dst.blob._get_runtime_json_str(mode="RW") - df = src_rt.to_frame().join(dst_rt.to_frame(), how="outer") + df = df.join(dst_rt, how="outer") df["ksize_x"], df["ksize_y"] = ksize res = df.apply(image_blur_udf, axis=1) @@ -328,7 +340,7 @@ def image_resize( *, fx: float = 0.0, fy: float = 0.0, - dst: Union[str, bigframes.series.Series], + dst: Optional[Union[str, bigframes.series.Series]] = None, connection: Optional[str] = None, ): """Resize images. @@ -340,7 +352,7 @@ def image_resize( dsize (tuple(int, int), default (0, 0)): Destination size. If set to 0, fx and fy parameters determine the size. fx (float, default 0.0): scale factor along the horizontal axis. If set to 0.0, dsize parameter determines the output size. fy (float, defalut 0.0): scale factor along the vertical axis. If set to 0.0, dsize parameter determines the output size. - dst (str or bigframes.series.Series): Destination GCS folder str or blob series. + dst (str or bigframes.series.Series or None, default None): Destination GCS folder str or blob series. If None, output to BQ as bytes. connection (str or None, default None): BQ connection used for function internet transactions, and the output blob if "dst" is str. If None, uses default connection of the session. Returns: @@ -356,6 +368,20 @@ def image_resize( import bigframes.blob._functions as blob_func connection = self._resolve_connection(connection) + df = self._get_runtime_json_str(mode="R").to_frame() + + if dst is None: + image_resize_udf = blob_func.TransformFunction( + blob_func.image_resize_to_bytes_def, + session=self._block.session, + connection=connection, + ).udf() + + df["dsize_x"], df["dsizye_y"] = dsize + df["fx"], df["fy"] = fx, fy + res = df.apply(image_resize_udf, axis=1) + + return res if isinstance(dst, str): dst = os.path.join(dst, "") @@ -372,10 +398,9 @@ def image_resize( connection=connection, ).udf() - src_rt = self._get_runtime_json_str(mode="R") dst_rt = dst.blob._get_runtime_json_str(mode="RW") - df = src_rt.to_frame().join(dst_rt.to_frame(), how="outer") + df = df.join(dst_rt, how="outer") df["dsize_x"], df["dsizye_y"] = dsize df["fx"], df["fy"] = fx, fy @@ -390,7 +415,7 @@ def image_normalize( alpha: float = 1.0, beta: float = 0.0, norm_type: str = "l2", - dst: Union[str, bigframes.series.Series], + dst: Optional[Union[str, bigframes.series.Series]] = None, connection: Optional[str] = None, ) -> bigframes.series.Series: """Normalize images. @@ -402,7 +427,7 @@ def image_normalize( alpha (float, default 1.0): Norm value to normalize to or the lower range boundary in case of the range normalization. beta (float, default 0.0): Upper range boundary in case of the range normalization; it is not used for the norm normalization. norm_type (str, default "l2"): Normalization type. Accepted values are "inf", "l1", "l2" and "minmax". - dst (str or bigframes.series.Series): Destination GCS folder str or blob series. + dst (str or bigframes.series.Series or None, default None): Destination GCS folder str or blob series. If None, output to BQ as bytes. connection (str or None, default None): BQ connection used for function internet transactions, and the output blob if "dst" is str. If None, uses default connection of the session. Returns: @@ -411,6 +436,21 @@ def image_normalize( import bigframes.blob._functions as blob_func connection = self._resolve_connection(connection) + df = self._get_runtime_json_str(mode="R").to_frame() + + if dst is None: + image_normalize_udf = blob_func.TransformFunction( + blob_func.image_normalize_to_bytes_def, + session=self._block.session, + connection=connection, + ).udf() + + df["alpha"] = alpha + df["beta"] = beta + df["norm_type"] = norm_type + res = df.apply(image_normalize_udf, axis=1) + + return res if isinstance(dst, str): dst = os.path.join(dst, "") @@ -427,10 +467,9 @@ def image_normalize( connection=connection, ).udf() - src_rt = self._get_runtime_json_str(mode="R") dst_rt = dst.blob._get_runtime_json_str(mode="RW") - df = src_rt.to_frame().join(dst_rt.to_frame(), how="outer") + df = df.join(dst_rt, how="outer") df["alpha"] = alpha df["beta"] = beta df["norm_type"] = norm_type From 50ad3a56e9bd77bb77d60d7d5ec497e3335a7177 Mon Sep 17 00:00:00 2001 From: Shenyang Cai Date: Thu, 13 Feb 2025 16:51:44 -0800 Subject: [PATCH 11/18] chore: support timestamp_sub (#1390) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * [WIP] support timestamp_sub * add timestamp_sub tests * fix format * fix format * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * fix error message --------- Co-authored-by: Owl Bot --- bigframes/core/compile/scalar_op_compiler.py | 5 ++ bigframes/core/rewrite/timedeltas.py | 3 + bigframes/operations/__init__.py | 7 +- bigframes/operations/numeric_ops.py | 3 + bigframes/operations/timedelta_ops.py | 20 +++++ .../small/operations/test_timedeltas.py | 90 +++++++++++++++++++ 6 files changed, 127 insertions(+), 1 deletion(-) diff --git a/bigframes/core/compile/scalar_op_compiler.py b/bigframes/core/compile/scalar_op_compiler.py index 3e5f10eca4..d5ce6e9e09 100644 --- a/bigframes/core/compile/scalar_op_compiler.py +++ b/bigframes/core/compile/scalar_op_compiler.py @@ -747,6 +747,11 @@ def timestamp_add_op_impl(x: ibis_types.TimestampValue, y: ibis_types.IntegerVal return x + y.to_interval("us") +@scalar_op_compiler.register_binary_op(ops.timestamp_sub_op) +def timestamp_sub_op_impl(x: ibis_types.TimestampValue, y: ibis_types.IntegerValue): + return x - y.to_interval("us") + + @scalar_op_compiler.register_unary_op(ops.FloorDtOp, pass_op=True) def floor_dt_op_impl(x: ibis_types.Value, op: ops.FloorDtOp): supported_freqs = ["Y", "Q", "M", "W", "D", "h", "min", "s", "ms", "us", "ns"] diff --git a/bigframes/core/rewrite/timedeltas.py b/bigframes/core/rewrite/timedeltas.py index 990aca1f18..db3a426635 100644 --- a/bigframes/core/rewrite/timedeltas.py +++ b/bigframes/core/rewrite/timedeltas.py @@ -110,6 +110,9 @@ def _rewrite_sub_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: if dtypes.is_datetime_like(left.dtype) and dtypes.is_datetime_like(right.dtype): return _TypedExpr.create_op_expr(ops.timestamp_diff_op, left, right) + if dtypes.is_datetime_like(left.dtype) and right.dtype is dtypes.TIMEDELTA_DTYPE: + return _TypedExpr.create_op_expr(ops.timestamp_sub_op, left, right) + return _TypedExpr.create_op_expr(ops.sub_op, left, right) diff --git a/bigframes/operations/__init__.py b/bigframes/operations/__init__.py index 88406317fe..21a1171ddc 100644 --- a/bigframes/operations/__init__.py +++ b/bigframes/operations/__init__.py @@ -178,7 +178,11 @@ ) from bigframes.operations.struct_ops import StructFieldOp, StructOp from bigframes.operations.time_ops import hour_op, minute_op, normalize_op, second_op -from bigframes.operations.timedelta_ops import timestamp_add_op, ToTimedeltaOp +from bigframes.operations.timedelta_ops import ( + timestamp_add_op, + timestamp_sub_op, + ToTimedeltaOp, +) __all__ = [ # Base ops @@ -251,6 +255,7 @@ "normalize_op", # Timedelta ops "timestamp_add_op", + "timestamp_sub_op", "ToTimedeltaOp", # Datetime ops "date_op", diff --git a/bigframes/operations/numeric_ops.py b/bigframes/operations/numeric_ops.py index 5183e5c4c5..61544984fb 100644 --- a/bigframes/operations/numeric_ops.py +++ b/bigframes/operations/numeric_ops.py @@ -151,6 +151,9 @@ def output_type(self, *input_types): if dtypes.is_datetime_like(left_type) and dtypes.is_datetime_like(right_type): return dtypes.TIMEDELTA_DTYPE + if dtypes.is_datetime_like(left_type) and right_type is dtypes.TIMEDELTA_DTYPE: + return left_type + raise TypeError(f"Cannot subtract dtypes {left_type} and {right_type}") diff --git a/bigframes/operations/timedelta_ops.py b/bigframes/operations/timedelta_ops.py index 69e054fa5c..3d3c3bfeeb 100644 --- a/bigframes/operations/timedelta_ops.py +++ b/bigframes/operations/timedelta_ops.py @@ -54,3 +54,23 @@ def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionT timestamp_add_op = TimestampAdd() + + +@dataclasses.dataclass(frozen=True) +class TimestampSub(base_ops.BinaryOp): + name: typing.ClassVar[str] = "timestamp_sub" + + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + # timestamp - timedelta => timestamp + if ( + dtypes.is_datetime_like(input_types[0]) + and input_types[1] is dtypes.TIMEDELTA_DTYPE + ): + return input_types[0] + + raise TypeError( + f"unsupported types for timestamp_sub. left: {input_types[0]} right: {input_types[1]}" + ) + + +timestamp_sub_op = TimestampSub() diff --git a/tests/system/small/operations/test_timedeltas.py b/tests/system/small/operations/test_timedeltas.py index fe779a8524..9dc889f619 100644 --- a/tests/system/small/operations/test_timedeltas.py +++ b/tests/system/small/operations/test_timedeltas.py @@ -178,6 +178,96 @@ def test_timestamp_add_dataframes(temporal_dfs): ) +@pytest.mark.parametrize( + ("column", "pd_dtype"), + [ + ("datetime_col", " Date: Fri, 14 Feb 2025 14:07:15 -0800 Subject: [PATCH 12/18] chore: Use isin() in tpch benchmarks (#1400) --- .../bigframes_vendored/tpch/queries/q16.py | 14 ++++---------- .../bigframes_vendored/tpch/queries/q18.py | 5 ++--- .../bigframes_vendored/tpch/queries/q20.py | 16 +++++++--------- .../bigframes_vendored/tpch/queries/q22.py | 8 +++----- 4 files changed, 16 insertions(+), 27 deletions(-) diff --git a/third_party/bigframes_vendored/tpch/queries/q16.py b/third_party/bigframes_vendored/tpch/queries/q16.py index a02dcef5dc..f55939b03c 100644 --- a/third_party/bigframes_vendored/tpch/queries/q16.py +++ b/third_party/bigframes_vendored/tpch/queries/q16.py @@ -20,22 +20,16 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): var1 = "Brand#45" - supplier = ( - supplier[ - ~supplier["S_COMMENT"].str.contains("Customer.*Complaints", regex=True) - ]["S_SUPPKEY"] - .unique(keep_order=False) - .to_frame() - ) + supplier = supplier[ + ~supplier["S_COMMENT"].str.contains("Customer.*Complaints", regex=True) + ]["S_SUPPKEY"] q_filtered = part.merge(partsupp, left_on="P_PARTKEY", right_on="PS_PARTKEY") q_filtered = q_filtered[q_filtered["P_BRAND"] != var1] q_filtered = q_filtered[~q_filtered["P_TYPE"].str.contains("MEDIUM POLISHED")] q_filtered = q_filtered[q_filtered["P_SIZE"].isin([49, 14, 23, 45, 19, 3, 36, 9])] - final_df = q_filtered.merge( - supplier, left_on=["PS_SUPPKEY"], right_on=["S_SUPPKEY"] - ) + final_df = q_filtered[q_filtered["PS_SUPPKEY"].isin(supplier)] grouped = final_df.groupby(["P_BRAND", "P_TYPE", "P_SIZE"], as_index=False) result = grouped.agg( diff --git a/third_party/bigframes_vendored/tpch/queries/q18.py b/third_party/bigframes_vendored/tpch/queries/q18.py index c6802e6808..576ce58d5c 100644 --- a/third_party/bigframes_vendored/tpch/queries/q18.py +++ b/third_party/bigframes_vendored/tpch/queries/q18.py @@ -22,14 +22,13 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): var1 = 300 + # order with over 300 items q1 = lineitem.groupby("L_ORDERKEY", as_index=False).agg( SUM_QUANTITY=bpd.NamedAgg(column="L_QUANTITY", aggfunc="sum") ) q1 = q1[q1["SUM_QUANTITY"] > var1] - filtered_orders = orders.merge( - q1, left_on="O_ORDERKEY", right_on="L_ORDERKEY", how="inner" - ) + filtered_orders = orders[orders["O_ORDERKEY"].isin(q1["L_ORDERKEY"])] result = filtered_orders.merge( lineitem, left_on="O_ORDERKEY", right_on="L_ORDERKEY" diff --git a/third_party/bigframes_vendored/tpch/queries/q20.py b/third_party/bigframes_vendored/tpch/queries/q20.py index 9fee3eb396..7c434eba03 100644 --- a/third_party/bigframes_vendored/tpch/queries/q20.py +++ b/third_party/bigframes_vendored/tpch/queries/q20.py @@ -44,21 +44,19 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): filtered_parts = part[part["P_NAME"].str.startswith(var4)] - filtered_parts = filtered_parts["P_PARTKEY"].unique(keep_order=False).to_frame() - joined_parts = filtered_parts.merge( - partsupp, left_on="P_PARTKEY", right_on="PS_PARTKEY" - ) + filtered_parts = filtered_parts["P_PARTKEY"] + joined_parts = partsupp[partsupp["PS_PARTKEY"].isin(filtered_parts)] final_join = q1.merge( joined_parts, left_on=["L_SUPPKEY", "L_PARTKEY"], - right_on=["PS_SUPPKEY", "P_PARTKEY"], + right_on=["PS_SUPPKEY", "PS_PARTKEY"], ) - final_filtered = final_join[final_join["PS_AVAILQTY"] > final_join["SUM_QUANTITY"]] - - final_filtered = final_filtered["PS_SUPPKEY"].unique(keep_order=False).to_frame() + final_filtered = final_join[final_join["PS_AVAILQTY"] > final_join["SUM_QUANTITY"]][ + "PS_SUPPKEY" + ] - final_result = final_filtered.merge(q3, left_on="PS_SUPPKEY", right_on="S_SUPPKEY") + final_result = q3[q3["S_SUPPKEY"].isin(final_filtered)] final_result = final_result[["S_NAME", "S_ADDRESS"]].sort_values(by="S_NAME") next(final_result.to_pandas_batches(max_results=1500)) diff --git a/third_party/bigframes_vendored/tpch/queries/q22.py b/third_party/bigframes_vendored/tpch/queries/q22.py index 381183fd1e..a8d147eae4 100644 --- a/third_party/bigframes_vendored/tpch/queries/q22.py +++ b/third_party/bigframes_vendored/tpch/queries/q22.py @@ -27,11 +27,9 @@ def q(project_id: str, dataset_id: str, session: bigframes.Session): filtered_customer = customer[customer["C_ACCTBAL"] > customer["AVG_ACCTBAL"]] - orders_unique = orders["O_CUSTKEY"].unique(keep_order=False).to_frame() - filtered_customer = filtered_customer.merge( - orders_unique, left_on="C_CUSTKEY", right_on="O_CUSTKEY", how="left" - ) - filtered_customer = filtered_customer[filtered_customer["O_CUSTKEY"].isnull()] + filtered_customer = filtered_customer[ + ~filtered_customer["C_CUSTKEY"].isin(orders["O_CUSTKEY"]) + ] result = filtered_customer.groupby("CNTRYCODE", as_index=False).agg( NUMCUST=bpd.NamedAgg(column="C_CUSTKEY", aggfunc="count"), TOTACCTBAL=bpd.NamedAgg(column="C_ACCTBAL", aggfunc="sum"), From 7990262cf09e97c0739be922ede151d616655726 Mon Sep 17 00:00:00 2001 From: TrevorBergeron Date: Fri, 14 Feb 2025 14:40:50 -0800 Subject: [PATCH 13/18] perf: Prune projections more aggressively (#1398) --- bigframes/core/rewrite/pruning.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/bigframes/core/rewrite/pruning.py b/bigframes/core/rewrite/pruning.py index 7e40137f3e..5a94f2aa40 100644 --- a/bigframes/core/rewrite/pruning.py +++ b/bigframes/core/rewrite/pruning.py @@ -79,12 +79,17 @@ def prune_selection_child( elif isinstance(child, bigframes.core.nodes.AdditiveNode): if not set(field.id for field in child.added_fields) & selection.consumed_ids: return selection.replace_child(child.additive_base) - return selection.replace_child( - child.replace_additive_base( - prune_node( - child.additive_base, selection.consumed_ids | child.referenced_ids - ) + needed_ids = selection.consumed_ids | child.referenced_ids + if isinstance(child, bigframes.core.nodes.ProjectionNode): + # Projection expressions are independent, so can be individually removed from the node + child = dataclasses.replace( + child, + assignments=tuple( + (ex, id) for (ex, id) in child.assignments if id in needed_ids + ), ) + return selection.replace_child( + child.replace_additive_base(prune_node(child.additive_base, needed_ids)) ) elif isinstance(child, bigframes.core.nodes.ConcatNode): indices = [ From 0145656e5e378442f2f38f9f04e87e33ddf345f5 Mon Sep 17 00:00:00 2001 From: TrevorBergeron Date: Fri, 14 Feb 2025 15:41:59 -0800 Subject: [PATCH 14/18] perf: Simplify sum aggregate SQL text (#1395) --- bigframes/core/compile/aggregate_compiler.py | 4 +--- bigframes/core/compile/compiled.py | 5 ----- bigframes/core/compile/compiler.py | 9 +++++++-- 3 files changed, 8 insertions(+), 10 deletions(-) diff --git a/bigframes/core/compile/aggregate_compiler.py b/bigframes/core/compile/aggregate_compiler.py index 02c7ae128b..91a96febe0 100644 --- a/bigframes/core/compile/aggregate_compiler.py +++ b/bigframes/core/compile/aggregate_compiler.py @@ -164,9 +164,7 @@ def _( ) -> ibis_types.NumericValue: # Will be null if all inputs are null. Pandas defaults to zero sum though. bq_sum = _apply_window_if_present(column.sum(), window) - return ( - ibis_api.case().when(bq_sum.isnull(), ibis_types.literal(0)).else_(bq_sum).end() # type: ignore - ) + return bq_sum.fillna(ibis_types.literal(0)) @compile_unary_agg.register diff --git a/bigframes/core/compile/compiled.py b/bigframes/core/compile/compiled.py index 6a2b583b28..b0cf30269e 100644 --- a/bigframes/core/compile/compiled.py +++ b/bigframes/core/compile/compiled.py @@ -205,7 +205,6 @@ def aggregate( self, aggregations: typing.Sequence[tuple[ex.Aggregation, str]], by_column_ids: typing.Sequence[ex.DerefOp] = (), - dropna: bool = True, order_by: typing.Sequence[OrderingExpression] = (), ) -> UnorderedIR: """ @@ -230,10 +229,6 @@ def aggregate( for aggregate, col_out in aggregations } if by_column_ids: - if dropna: - table = table.filter( - [table[ref.id.sql].notnull() for ref in by_column_ids] - ) result = table.group_by((ref.id.sql for ref in by_column_ids)).aggregate( **stats ) diff --git a/bigframes/core/compile/compiler.py b/bigframes/core/compile/compiler.py index ed95dacf74..9b271bf67b 100644 --- a/bigframes/core/compile/compiler.py +++ b/bigframes/core/compile/compiler.py @@ -25,7 +25,7 @@ import google.cloud.bigquery import pandas as pd -from bigframes import dtypes +from bigframes import dtypes, operations from bigframes.core import utils import bigframes.core.compile.compiled as compiled import bigframes.core.compile.concat as concat_impl @@ -278,8 +278,13 @@ def compile_rowcount(self, node: nodes.RowCountNode): def compile_aggregate(self, node: nodes.AggregateNode): aggs = tuple((agg, id.sql) for agg, id in node.aggregations) result = self.compile_node(node.child).aggregate( - aggs, node.by_column_ids, node.dropna, order_by=node.order_by + aggs, node.by_column_ids, order_by=node.order_by ) + # TODO: Remove dropna field and use filter node instead + if node.dropna: + for key in node.by_column_ids: + if node.child.field_by_id[key.id].nullable: + result = result.filter(operations.notnull_op.as_expr(key)) return result @_compile_node.register From 5dae01ac11ca04825137c96c0afa356817da26f7 Mon Sep 17 00:00:00 2001 From: Garrett Wu <6505921+GarrettWu@users.noreply.github.com> Date: Fri, 14 Feb 2025 16:32:28 -0800 Subject: [PATCH 15/18] chore: kickstart tests for experimental blob creation (#1402) --- scripts/create_gcs.py | 96 +++++++++++++++++++++++++++++ scripts/data/images/img0.jpg | Bin 0 -> 338390 bytes scripts/data/images/img1.jpg | Bin 0 -> 43333 bytes tests/system/small/blob/test_io.py | 33 ++++++++++ 4 files changed, 129 insertions(+) create mode 100644 scripts/create_gcs.py create mode 100644 scripts/data/images/img0.jpg create mode 100644 scripts/data/images/img1.jpg create mode 100644 tests/system/small/blob/test_io.py diff --git a/scripts/create_gcs.py b/scripts/create_gcs.py new file mode 100644 index 0000000000..8a94bfd886 --- /dev/null +++ b/scripts/create_gcs.py @@ -0,0 +1,96 @@ +# 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 +# +# 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 +from pathlib import Path +import sys + +import google.cloud.exceptions as exceptions +from google.cloud.storage import transfer_manager +import google.cloud.storage as gcs + +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_bucket(client: gcs.Client) -> gcs.Bucket: + bucket_name = "bigframes_blob_test" + + print(f"Creating bucket: {bucket_name}") + try: + bucket = client.create_bucket(bucket_name) + print(f"Bucket {bucket_name} created. ") + + except exceptions.Conflict: + print(f"Bucket {bucket_name} already exists.") + bucket = client.bucket(bucket_name) + + return bucket + + +def upload_data(bucket: gcs.Bucket): + # from https://cloud.google.com/storage/docs/samples/storage-transfer-manager-upload-directory + source_directory = "scripts/data/" + workers = 8 + + # First, recursively get all files in `directory` as Path objects. + directory_as_path_obj = Path(source_directory) + paths = directory_as_path_obj.rglob("*") + + # Filter so the list only includes files, not directories themselves. + file_paths = [path for path in paths if path.is_file()] + + # These paths are relative to the current working directory. Next, make them + # relative to `directory` + relative_paths = [path.relative_to(source_directory) for path in file_paths] + + # Finally, convert them all to strings. + string_paths = [str(path) for path in relative_paths] + + print("Found {} files.".format(len(string_paths))) + + # Start the upload. + results = transfer_manager.upload_many_from_filenames( + bucket, string_paths, source_directory=source_directory, max_workers=workers + ) + + for name, result in zip(string_paths, results): + # The results list is either `None` or an exception for each filename in + # the input list, in order. + + if isinstance(result, Exception): + print("Failed to upload {} due to exception: {}".format(name, result)) + else: + print("Uploaded {} to {}.".format(name, bucket.name)) + + +def main(): + client = gcs.Client(project=PROJECT_ID) + + bucket = create_bucket(client) + + upload_data(bucket) + + +if __name__ == "__main__": + main() diff --git a/scripts/data/images/img0.jpg b/scripts/data/images/img0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f9114402b4989d1374833c747b9e0f936b61e2e GIT binary patch literal 338390 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 `q~!RdQ)!BaXu=aEx%-?1f3PSqmvPtTB& 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℞qZ!R?O{k&@9YA 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�1S3E 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 literal 0 HcmV?d00001 diff --git a/scripts/data/images/img1.jpg b/scripts/data/images/img1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..15c881bd1afd2e001ae1d57f5c702535fd0ac786 GIT binary patch literal 43333 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 Z?T(MAJpXU6}I-$=*Q)^8iVRLymK_R*uV9i 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 AtN;K2 literal 0 HcmV?d00001 diff --git a/tests/system/small/blob/test_io.py b/tests/system/small/blob/test_io.py new file mode 100644 index 0000000000..effadd3b22 --- /dev/null +++ b/tests/system/small/blob/test_io.py @@ -0,0 +1,33 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import bigframes +import bigframes.pandas as bpd + + +def test_blob_create_from_uri_str(): + bigframes.options.experiments.blob = True + + uri_series = bpd.Series( + [ + "gs://bigframes_blob_test/images/img0.jpg", + "gs://bigframes_blob_test/images/img1.jpg", + ] + ) + # TODO: use bq_connection fixture when MMD location capitalization fix is in prod + blob_series = uri_series.str.to_blob(connection="us.bigframes-default-connection") + + pd_blob_series = blob_series.to_pandas() + + assert len(pd_blob_series) == 2 From 3cee24bae1d352015a5b6a8c18d5c394293d08fd Mon Sep 17 00:00:00 2001 From: TrevorBergeron Date: Tue, 18 Feb 2025 17:05:32 -0800 Subject: [PATCH 16/18] fix: Ensure binops with pandas objects returns bigquery dataframes (#1404) --- bigframes/core/indexes/base.py | 2 ++ bigframes/dataframe.py | 2 ++ bigframes/series.py | 3 +++ tests/system/small/test_dataframe.py | 14 ++++++++++++++ tests/system/small/test_series.py | 21 +++++++++++++++++++++ 5 files changed, 42 insertions(+) diff --git a/bigframes/core/indexes/base.py b/bigframes/core/indexes/base.py index 6ad0973262..b3a07d33bc 100644 --- a/bigframes/core/indexes/base.py +++ b/bigframes/core/indexes/base.py @@ -48,6 +48,8 @@ class Index(vendored_pandas_index.Index): _linked_frame: Union[ bigframes.dataframe.DataFrame, bigframes.series.Series, None ] = None + # Must be above 5000 for pandas to delegate to bigframes for binops + __pandas_priority__ = 12000 # Overrided on __new__ to create subclasses like pandas does def __new__( diff --git a/bigframes/dataframe.py b/bigframes/dataframe.py index 4ffa56c2e5..c02b182ee3 100644 --- a/bigframes/dataframe.py +++ b/bigframes/dataframe.py @@ -103,6 +103,8 @@ class DataFrame(vendored_pandas_frame.DataFrame): __doc__ = vendored_pandas_frame.DataFrame.__doc__ # internal flag to disable cache at all _disable_cache_override: bool = False + # Must be above 5000 for pandas to delegate to bigframes for binops + __pandas_priority__ = 15000 def __init__( self, diff --git a/bigframes/series.py b/bigframes/series.py index af9fce6e20..54dd6e7f21 100644 --- a/bigframes/series.py +++ b/bigframes/series.py @@ -78,6 +78,9 @@ @log_adapter.class_logger class Series(bigframes.operations.base.SeriesMethods, vendored_pandas_series.Series): + # Must be above 5000 for pandas to delegate to bigframes for binops + __pandas_priority__ = 13000 + def __init__(self, *args, **kwargs): self._query_job: Optional[bigquery.QueryJob] = None super().__init__(*args, **kwargs) diff --git a/tests/system/small/test_dataframe.py b/tests/system/small/test_dataframe.py index 1db89a074a..26b941a596 100644 --- a/tests/system/small/test_dataframe.py +++ b/tests/system/small/test_dataframe.py @@ -2471,6 +2471,20 @@ def test_listlike_binop_axis_1_in_memory_data(scalars_dfs, input): assert_pandas_df_equal(bf_result, pd_result, check_dtype=False) +@skip_legacy_pandas +def test_df_reverse_binop_pandas(scalars_dfs): + scalars_df, scalars_pandas_df = scalars_dfs + + pd_series = pd.Series([100, 200, 300]) + + df_columns = ["int64_col", "float64_col", "int64_too"] + + bf_result = pd_series + scalars_df[df_columns].to_pandas() + pd_result = pd_series + scalars_pandas_df[df_columns] + + assert_pandas_df_equal(bf_result, pd_result, check_dtype=False) + + def test_listlike_binop_axis_1_bf_index(scalars_dfs): scalars_df, scalars_pandas_df = scalars_dfs diff --git a/tests/system/small/test_series.py b/tests/system/small/test_series.py index 3d3baff21a..00f47c754e 100644 --- a/tests/system/small/test_series.py +++ b/tests/system/small/test_series.py @@ -1656,6 +1656,27 @@ def test_series_binop_w_other_types(scalars_dfs, other): ) +@pytest.mark.parametrize( + ("other",), + [ + ([-1.4, 2.3, None],), + (pd.Index([-1.4, 2.3, None]),), + (pd.Series([-1.4, 2.3, None], index=[44, 2, 1]),), + ], +) +@skip_legacy_pandas +def test_series_reverse_binop_w_other_types(scalars_dfs, other): + scalars_df, scalars_pandas_df = scalars_dfs + + bf_result = (other + scalars_df["int64_col"].head(3)).to_pandas() + pd_result = other + scalars_pandas_df["int64_col"].head(3) + + assert_series_equal( + bf_result, + pd_result, + ) + + @skip_legacy_pandas def test_series_combine_first(scalars_dfs): scalars_df, scalars_pandas_df = scalars_dfs From ffa63d47ca1dd1a18617f44d9b3bc33419656a20 Mon Sep 17 00:00:00 2001 From: Shenyang Cai Date: Tue, 18 Feb 2025 18:17:50 -0800 Subject: [PATCH 17/18] chore: support operators between timedeltas (#1396) * support operators within timedeltas * fix mypy * fix tests * fix format * add even more operators to stay away from floats * Make code slimmer. --- bigframes/core/rewrite/timedeltas.py | 40 +++++++ bigframes/operations/__init__.py | 6 + bigframes/operations/numeric_ops.py | 109 +++++++++++++++--- bigframes/operations/timedelta_ops.py | 7 +- bigframes/operations/type.py | 4 + bigframes/series.py | 3 + .../small/operations/test_timedeltas.py | 101 +++++++++++++++- 7 files changed, 251 insertions(+), 19 deletions(-) diff --git a/bigframes/core/rewrite/timedeltas.py b/bigframes/core/rewrite/timedeltas.py index db3a426635..9d52eae77d 100644 --- a/bigframes/core/rewrite/timedeltas.py +++ b/bigframes/core/rewrite/timedeltas.py @@ -103,6 +103,17 @@ def _rewrite_op_expr( if isinstance(expr.op, ops.AddOp): return _rewrite_add_op(inputs[0], inputs[1]) + if isinstance(expr.op, ops.MulOp): + return _rewrite_mul_op(inputs[0], inputs[1]) + + if isinstance(expr.op, ops.DivOp): + return _rewrite_div_op(inputs[0], inputs[1]) + + if isinstance(expr.op, ops.FloorDivOp): + # We need to re-write floor div because for numerics: int // float => float + # but for timedeltas: int(timedelta) // float => int(timedelta) + return _rewrite_floordiv_op(inputs[0], inputs[1]) + return _TypedExpr.create_op_expr(expr.op, *inputs) @@ -126,3 +137,32 @@ def _rewrite_add_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: return _TypedExpr.create_op_expr(ops.timestamp_add_op, right, left) return _TypedExpr.create_op_expr(ops.add_op, left, right) + + +def _rewrite_mul_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: + result = _TypedExpr.create_op_expr(ops.mul_op, left, right) + + if left.dtype is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right.dtype): + return _TypedExpr.create_op_expr(ops.ToTimedeltaOp("us"), result) + if dtypes.is_numeric(left.dtype) and right.dtype is dtypes.TIMEDELTA_DTYPE: + return _TypedExpr.create_op_expr(ops.ToTimedeltaOp("us"), result) + + return result + + +def _rewrite_div_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: + result = _TypedExpr.create_op_expr(ops.div_op, left, right) + + if left.dtype is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right.dtype): + return _TypedExpr.create_op_expr(ops.ToTimedeltaOp("us"), result) + + return result + + +def _rewrite_floordiv_op(left: _TypedExpr, right: _TypedExpr) -> _TypedExpr: + result = _TypedExpr.create_op_expr(ops.floordiv_op, left, right) + + if left.dtype is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right.dtype): + return _TypedExpr.create_op_expr(ops.ToTimedeltaOp("us"), result) + + return result diff --git a/bigframes/operations/__init__.py b/bigframes/operations/__init__.py index 21a1171ddc..f2bc1ecf85 100644 --- a/bigframes/operations/__init__.py +++ b/bigframes/operations/__init__.py @@ -115,15 +115,18 @@ cos_op, cosh_op, div_op, + DivOp, exp_op, expm1_op, floor_op, floordiv_op, + FloorDivOp, ln_op, log1p_op, log10_op, mod_op, mul_op, + MulOp, neg_op, pos_op, pow_op, @@ -282,15 +285,18 @@ "cos_op", "cosh_op", "div_op", + "DivOp", "exp_op", "expm1_op", "floor_op", "floordiv_op", + "FloorDivOp", "ln_op", "log1p_op", "log10_op", "mod_op", "mul_op", + "MulOp", "neg_op", "pos_op", "pow_op", diff --git a/bigframes/operations/numeric_ops.py b/bigframes/operations/numeric_ops.py index 61544984fb..f5a290bde5 100644 --- a/bigframes/operations/numeric_ops.py +++ b/bigframes/operations/numeric_ops.py @@ -75,11 +75,17 @@ name="ceil", type_signature=op_typing.UNARY_REAL_NUMERIC ) -abs_op = base_ops.create_unary_op(name="abs", type_signature=op_typing.UNARY_NUMERIC) +abs_op = base_ops.create_unary_op( + name="abs", type_signature=op_typing.UNARY_NUMERIC_AND_TIMEDELTA +) -pos_op = base_ops.create_unary_op(name="pos", type_signature=op_typing.UNARY_NUMERIC) +pos_op = base_ops.create_unary_op( + name="pos", type_signature=op_typing.UNARY_NUMERIC_AND_TIMEDELTA +) -neg_op = base_ops.create_unary_op(name="neg", type_signature=op_typing.UNARY_NUMERIC) +neg_op = base_ops.create_unary_op( + name="neg", type_signature=op_typing.UNARY_NUMERIC_AND_TIMEDELTA +) exp_op = base_ops.create_unary_op( name="exp", type_signature=op_typing.UNARY_REAL_NUMERIC @@ -123,6 +129,9 @@ def output_type(self, *input_types): if left_type is dtypes.TIMEDELTA_DTYPE and dtypes.is_datetime_like(right_type): return right_type + if left_type is dtypes.TIMEDELTA_DTYPE and right_type is dtypes.TIMEDELTA_DTYPE: + return dtypes.TIMEDELTA_DTYPE + if (left_type is None or dtypes.is_numeric(left_type)) and ( right_type is None or dtypes.is_numeric(right_type) ): @@ -142,11 +151,6 @@ class SubOp(base_ops.BinaryOp): def output_type(self, *input_types): left_type = input_types[0] right_type = input_types[1] - if (left_type is None or dtypes.is_numeric(left_type)) and ( - right_type is None or dtypes.is_numeric(right_type) - ): - # Numeric subtraction - return dtypes.coerce_to_common(left_type, right_type) if dtypes.is_datetime_like(left_type) and dtypes.is_datetime_like(right_type): return dtypes.TIMEDELTA_DTYPE @@ -154,20 +158,95 @@ def output_type(self, *input_types): if dtypes.is_datetime_like(left_type) and right_type is dtypes.TIMEDELTA_DTYPE: return left_type + if left_type is dtypes.TIMEDELTA_DTYPE and right_type is dtypes.TIMEDELTA_DTYPE: + return dtypes.TIMEDELTA_DTYPE + + if (left_type is None or dtypes.is_numeric(left_type)) and ( + right_type is None or dtypes.is_numeric(right_type) + ): + # Numeric subtraction + return dtypes.coerce_to_common(left_type, right_type) + raise TypeError(f"Cannot subtract dtypes {left_type} and {right_type}") sub_op = SubOp() -mul_op = base_ops.create_binary_op(name="mul", type_signature=op_typing.BINARY_NUMERIC) -div_op = base_ops.create_binary_op( - name="div", type_signature=op_typing.BINARY_REAL_NUMERIC -) +@dataclasses.dataclass(frozen=True) +class MulOp(base_ops.BinaryOp): + name: typing.ClassVar[str] = "mul" -floordiv_op = base_ops.create_binary_op( - name="floordiv", type_signature=op_typing.BINARY_NUMERIC -) + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + left_type = input_types[0] + right_type = input_types[1] + + if left_type is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right_type): + return dtypes.TIMEDELTA_DTYPE + if dtypes.is_numeric(left_type) and right_type is dtypes.TIMEDELTA_DTYPE: + return dtypes.TIMEDELTA_DTYPE + + if (left_type is None or dtypes.is_numeric(left_type)) and ( + right_type is None or dtypes.is_numeric(right_type) + ): + return dtypes.coerce_to_common(left_type, right_type) + + raise TypeError(f"Cannot multiply dtypes {left_type} and {right_type}") + + +mul_op = MulOp() + + +@dataclasses.dataclass(frozen=True) +class DivOp(base_ops.BinaryOp): + name: typing.ClassVar[str] = "div" + + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + left_type = input_types[0] + right_type = input_types[1] + + if left_type is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right_type): + return dtypes.TIMEDELTA_DTYPE + + if left_type is dtypes.TIMEDELTA_DTYPE and right_type is dtypes.TIMEDELTA_DTYPE: + return dtypes.FLOAT_DTYPE + + if (left_type is None or dtypes.is_numeric(left_type)) and ( + right_type is None or dtypes.is_numeric(right_type) + ): + lcd_type = dtypes.coerce_to_common(left_type, right_type) + # Real numeric ops produce floats on int input + return dtypes.FLOAT_DTYPE if lcd_type == dtypes.INT_DTYPE else lcd_type + + raise TypeError(f"Cannot divide dtypes {left_type} and {right_type}") + + +div_op = DivOp() + + +@dataclasses.dataclass(frozen=True) +class FloorDivOp(base_ops.BinaryOp): + name: typing.ClassVar[str] = "floordiv" + + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + left_type = input_types[0] + right_type = input_types[1] + + if left_type is dtypes.TIMEDELTA_DTYPE and dtypes.is_numeric(right_type): + return dtypes.TIMEDELTA_DTYPE + + if left_type is dtypes.TIMEDELTA_DTYPE and right_type is dtypes.TIMEDELTA_DTYPE: + return dtypes.INT_DTYPE + + if (left_type is None or dtypes.is_numeric(left_type)) and ( + right_type is None or dtypes.is_numeric(right_type) + ): + return dtypes.coerce_to_common(left_type, right_type) + + raise TypeError(f"Cannot floor divide dtypes {left_type} and {right_type}") + + +floordiv_op = FloorDivOp() pow_op = base_ops.create_binary_op(name="pow", type_signature=op_typing.BINARY_NUMERIC) diff --git a/bigframes/operations/timedelta_ops.py b/bigframes/operations/timedelta_ops.py index 3d3c3bfeeb..689966e21b 100644 --- a/bigframes/operations/timedelta_ops.py +++ b/bigframes/operations/timedelta_ops.py @@ -26,7 +26,11 @@ class ToTimedeltaOp(base_ops.UnaryOp): unit: typing.Literal["us", "ms", "s", "m", "h", "d", "W"] def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: - if input_types[0] in (dtypes.INT_DTYPE, dtypes.FLOAT_DTYPE): + if input_types[0] in ( + dtypes.INT_DTYPE, + dtypes.FLOAT_DTYPE, + dtypes.TIMEDELTA_DTYPE, + ): return dtypes.TIMEDELTA_DTYPE raise TypeError("expected integer or float input") @@ -56,7 +60,6 @@ def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionT timestamp_add_op = TimestampAdd() -@dataclasses.dataclass(frozen=True) class TimestampSub(base_ops.BinaryOp): name: typing.ClassVar[str] = "timestamp_sub" diff --git a/bigframes/operations/type.py b/bigframes/operations/type.py index 86bb56fc39..0a47cd91f0 100644 --- a/bigframes/operations/type.py +++ b/bigframes/operations/type.py @@ -224,6 +224,10 @@ def output_type( # Common type signatures UNARY_NUMERIC = TypePreserving(bigframes.dtypes.is_numeric, description="numeric") +UNARY_NUMERIC_AND_TIMEDELTA = TypePreserving( + lambda x: bigframes.dtypes.is_numeric(x) or x is bigframes.dtypes.TIMEDELTA_DTYPE, + description="numeric_and_timedelta", +) UNARY_REAL_NUMERIC = UnaryRealNumeric() BINARY_NUMERIC = BinaryNumeric() BINARY_REAL_NUMERIC = BinaryRealNumeric() diff --git a/bigframes/series.py b/bigframes/series.py index 54dd6e7f21..fe2d1aae0e 100644 --- a/bigframes/series.py +++ b/bigframes/series.py @@ -964,6 +964,9 @@ def update(self, other: Union[Series, Sequence, Mapping]) -> None: ) self._set_block(result._get_block()) + def __abs__(self) -> Series: + return self.abs() + def abs(self) -> Series: return self._apply_unary_op(ops.abs_op) diff --git a/tests/system/small/operations/test_timedeltas.py b/tests/system/small/operations/test_timedeltas.py index 9dc889f619..356000b3f6 100644 --- a/tests/system/small/operations/test_timedeltas.py +++ b/tests/system/small/operations/test_timedeltas.py @@ -21,6 +21,8 @@ import pandas.testing import pytest +from bigframes import dtypes + @pytest.fixture(scope="module") def temporal_dfs(session): @@ -37,15 +39,16 @@ def temporal_dfs(session): pd.Timestamp("2005-03-05 02:00:00", tz="UTC"), ], "timedelta_col_1": [ - pd.Timedelta(3, "s"), + pd.Timedelta(5, "s"), pd.Timedelta(-4, "d"), pd.Timedelta(5, "h"), ], "timedelta_col_2": [ - pd.Timedelta(2, "s"), + pd.Timedelta(3, "s"), pd.Timedelta(-4, "d"), pd.Timedelta(6, "h"), ], + "numeric_col": [1.5, 2, -3], } ) @@ -54,6 +57,100 @@ def temporal_dfs(session): return bigframes_df, pandas_df +def _assert_series_equal(actual: pd.Series, expected: pd.Series): + """Helper function specifically for timedelta testsing. Don't use it outside of this module.""" + if actual.dtype == dtypes.FLOAT_DTYPE: + pandas.testing.assert_series_equal( + actual, expected.astype("Float64"), check_index_type=False + ) + elif actual.dtype == dtypes.INT_DTYPE: + pandas.testing.assert_series_equal( + actual, expected.astype("Int64"), check_index_type=False + ) + else: + pandas.testing.assert_series_equal( + actual.astype("timedelta64[ns]"), + expected.dt.floor("us"), # in BF the precision is microsecond + check_index_type=False, + ) + + +@pytest.mark.parametrize( + ("op", "col_1", "col_2"), + [ + (operator.add, "timedelta_col_1", "timedelta_col_2"), + (operator.sub, "timedelta_col_1", "timedelta_col_2"), + (operator.truediv, "timedelta_col_1", "timedelta_col_2"), + (operator.floordiv, "timedelta_col_1", "timedelta_col_2"), + (operator.truediv, "timedelta_col_1", "numeric_col"), + (operator.floordiv, "timedelta_col_1", "numeric_col"), + (operator.mul, "timedelta_col_1", "numeric_col"), + (operator.mul, "numeric_col", "timedelta_col_1"), + ], +) +def test_timedelta_binary_ops_between_series(temporal_dfs, op, col_1, col_2): + bf_df, pd_df = temporal_dfs + + actual_result = op(bf_df[col_1], bf_df[col_2]).to_pandas() + + expected_result = op(pd_df[col_1], pd_df[col_2]) + _assert_series_equal(actual_result, expected_result) + + +@pytest.mark.parametrize( + ("op", "col", "literal"), + [ + (operator.add, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.sub, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.truediv, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.floordiv, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.truediv, "timedelta_col_1", 3), + (operator.floordiv, "timedelta_col_1", 3), + (operator.mul, "timedelta_col_1", 3), + (operator.mul, "numeric_col", pd.Timedelta(1, "s")), + ], +) +def test_timedelta_binary_ops_series_and_literal(temporal_dfs, op, col, literal): + bf_df, pd_df = temporal_dfs + + actual_result = op(bf_df[col], literal).to_pandas() + + expected_result = op(pd_df[col], literal) + _assert_series_equal(actual_result, expected_result) + + +@pytest.mark.parametrize( + ("op", "col", "literal"), + [ + (operator.add, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.sub, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.truediv, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.floordiv, "timedelta_col_1", pd.Timedelta(2, "s")), + (operator.truediv, "numeric_col", pd.Timedelta(2, "s")), + (operator.floordiv, "numeric_col", pd.Timedelta(2, "s")), + (operator.mul, "timedelta_col_1", 3), + (operator.mul, "numeric_col", pd.Timedelta(1, "s")), + ], +) +def test_timedelta_binary_ops_literal_and_series(temporal_dfs, op, col, literal): + bf_df, pd_df = temporal_dfs + + actual_result = op(literal, bf_df[col]).to_pandas() + + expected_result = op(literal, pd_df[col]) + _assert_series_equal(actual_result, expected_result) + + +@pytest.mark.parametrize("op", [operator.pos, operator.neg, operator.abs]) +def test_timedelta_unary_ops(temporal_dfs, op): + bf_df, pd_df = temporal_dfs + + actual_result = op(bf_df["timedelta_col_1"]).to_pandas() + + expected_result = op(pd_df["timedelta_col_1"]) + _assert_series_equal(actual_result, expected_result) + + @pytest.mark.parametrize( ("column", "pd_dtype"), [ From 4df61b47d10f5d0aecabef23b65deaf491e63865 Mon Sep 17 00:00:00 2001 From: "release-please[bot]" <55107282+release-please[bot]@users.noreply.github.com> Date: Wed, 19 Feb 2025 10:18:29 -0600 Subject: [PATCH 18/18] chore(main): release 1.37.0 (#1392) Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com> --- CHANGELOG.md | 27 +++++++++++++++++++++++ bigframes/version.py | 2 +- third_party/bigframes_vendored/version.py | 2 +- 3 files changed, 29 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a8ebb7a417..bee4ecf095 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,33 @@ [1]: https://pypi.org/project/bigframes/#history +## [1.37.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.36.0...v1.37.0) (2025-02-19) + + +### Features + +* JSON dtype support for read_pandas and Series constructor ([#1391](https://github.com/googleapis/python-bigquery-dataframes/issues/1391)) ([44f4137](https://github.com/googleapis/python-bigquery-dataframes/commit/44f4137adb02790e07c696f0641bc58390857210)) +* Support add, sub, mult, div, and more between timedeltas ([#1396](https://github.com/googleapis/python-bigquery-dataframes/issues/1396)) ([ffa63d4](https://github.com/googleapis/python-bigquery-dataframes/commit/ffa63d47ca1dd1a18617f44d9b3bc33419656a20)) +* Support comparison, ordering, and filtering for timedeltas ([#1387](https://github.com/googleapis/python-bigquery-dataframes/issues/1387)) ([34d01b2](https://github.com/googleapis/python-bigquery-dataframes/commit/34d01b27f867abf10bddffdf4f88fa7052cd237c)) +* Support subtraction in DATETIME/TIMESTAMP columns with timedelta columns ([#1390](https://github.com/googleapis/python-bigquery-dataframes/issues/1390)) ([50ad3a5](https://github.com/googleapis/python-bigquery-dataframes/commit/50ad3a56e9bd77bb77d60d7d5ec497e3335a7177)) + + +### Bug Fixes + +* Ensure binops with pandas objects returns bigquery dataframes ([#1404](https://github.com/googleapis/python-bigquery-dataframes/issues/1404)) ([3cee24b](https://github.com/googleapis/python-bigquery-dataframes/commit/3cee24bae1d352015a5b6a8c18d5c394293d08fd)) + + +### Performance Improvements + +* Prune projections more aggressively ([#1398](https://github.com/googleapis/python-bigquery-dataframes/issues/1398)) ([7990262](https://github.com/googleapis/python-bigquery-dataframes/commit/7990262cf09e97c0739be922ede151d616655726)) +* Simplify sum aggregate SQL text ([#1395](https://github.com/googleapis/python-bigquery-dataframes/issues/1395)) ([0145656](https://github.com/googleapis/python-bigquery-dataframes/commit/0145656e5e378442f2f38f9f04e87e33ddf345f5)) +* Use simple null constraints to simplify queries ([#1381](https://github.com/googleapis/python-bigquery-dataframes/issues/1381)) ([00611d4](https://github.com/googleapis/python-bigquery-dataframes/commit/00611d4d697a8b74451375f5a7700b92a4410295)) + + +### Documentation + +* Add DataFrame.struct docs ([#1348](https://github.com/googleapis/python-bigquery-dataframes/issues/1348)) ([7e9e93a](https://github.com/googleapis/python-bigquery-dataframes/commit/7e9e93aafd26cbfec9a1710caaf97937bcb6ee05)) + ## [1.36.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.35.0...v1.36.0) (2025-02-11) diff --git a/bigframes/version.py b/bigframes/version.py index e92072bea8..27dfb23603 100644 --- a/bigframes/version.py +++ b/bigframes/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.36.0" +__version__ = "1.37.0" diff --git a/third_party/bigframes_vendored/version.py b/third_party/bigframes_vendored/version.py index e92072bea8..27dfb23603 100644 --- a/third_party/bigframes_vendored/version.py +++ b/third_party/bigframes_vendored/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.36.0" +__version__ = "1.37.0"