bigframes 2.1.0__tar.gz → 2.2.0__tar.gz

{bigframes-2.1.0/bigframes.egg-info → bigframes-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bigframes
-Version: 2.1.0
+Version: 2.2.0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://github.com/googleapis/python-bigquery-dataframes
 Author: Google LLC
@@ -26,10 +26,11 @@ Requires-Dist: cloudpickle>=2.0.0
 Requires-Dist: fsspec>=2023.3.0
 Requires-Dist: gcsfs>=2023.3.0
 Requires-Dist: geopandas>=0.12.2
-Requires-Dist: google-auth<3.0dev,>=2.15.0
+Requires-Dist: google-auth<3.0,>=2.15.0
 Requires-Dist: google-cloud-bigtable>=2.24.0
 Requires-Dist: google-cloud-pubsub>=2.21.4
 Requires-Dist: google-cloud-bigquery[bqstorage,pandas]>=3.31.0
+Requires-Dist: google-cloud-bigquery-storage<3.0.0,>=2.30.0
 Requires-Dist: google-cloud-functions>=1.12.0
 Requires-Dist: google-cloud-bigquery-connection>=1.12.0
 Requires-Dist: google-cloud-iam>=2.12.1
@@ -41,7 +42,7 @@ Requires-Dist: pandas-gbq>=0.26.1
 Requires-Dist: pyarrow>=15.0.2
 Requires-Dist: pydata-google-auth>=1.8.2
 Requires-Dist: requests>=2.27.1
-Requires-Dist: shapely>=2.0.0
+Requires-Dist: shapely>=1.8.5
 Requires-Dist: sqlglot>=23.6.3
 Requires-Dist: tabulate>=0.9
 Requires-Dist: ipywidgets>=7.7.1
@@ -55,6 +56,8 @@ Requires-Dist: toolz<2,>=0.11
 Requires-Dist: typing-extensions<5,>=4.5.0
 Requires-Dist: rich<14,>=12.4.4
 Provides-Extra: tests
+Requires-Dist: freezegun; extra == "tests"
+Requires-Dist: pytest-snapshot; extra == "tests"
 Provides-Extra: polars
 Requires-Dist: polars>=1.7.0; extra == "polars"
 Provides-Extra: scikit-learn
@@ -64,7 +67,6 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: nox; extra == "dev"
 Requires-Dist: google-cloud-testutils; extra == "dev"
-Requires-Dist: freezegun; extra == "dev"
 Provides-Extra: all
 Requires-Dist: freezegun; extra == "all"
 Requires-Dist: google-cloud-testutils; extra == "all"
@@ -72,6 +74,7 @@ Requires-Dist: nox; extra == "all"
 Requires-Dist: polars>=1.7.0; extra == "all"
 Requires-Dist: pre-commit; extra == "all"
 Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-snapshot; extra == "all"
 Requires-Dist: scikit-learn>=1.2.2; extra == "all"
 
 BigQuery DataFrames

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/_config/experiment_options.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Optional
 import warnings
 
 import bigframes.exceptions as bfe
@@ -26,6 +27,9 @@ class ExperimentOptions:
         self._semantic_operators: bool = False
         self._ai_operators: bool = False
         self._blob: bool = False
+        self._blob_display: bool = True
+        self._blob_display_width: Optional[int] = None
+        self._blob_display_height: Optional[int] = None
 
     @property
     def semantic_operators(self) -> bool:
@@ -67,3 +71,30 @@ class ExperimentOptions:
             )
             warnings.warn(msg, category=bfe.PreviewWarning)
         self._blob = value
+
+    @property
+    def blob_display(self) -> bool:
+        """Whether to display the blob content in notebook DataFrame preview. Default True."""
+        return self._blob_display
+
+    @blob_display.setter
+    def blob_display(self, value: bool):
+        self._blob_display = value
+
+    @property
+    def blob_display_width(self) -> Optional[int]:
+        """Width in pixels that the blob constrained to."""
+        return self._blob_display_width
+
+    @blob_display_width.setter
+    def blob_display_width(self, value: Optional[int]):
+        self._blob_display_width = value
+
+    @property
+    def blob_display_height(self) -> Optional[int]:
+        """Height in pixels that the blob constrained to."""
+        return self._blob_display_height
+
+    @blob_display_height.setter
+    def blob_display_height(self, value: Optional[int]):
+        self._blob_display_height = value

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/bigquery/_operations/geo.py

@@ -106,7 +106,9 @@ def st_area(
 def st_difference(
     series: Union[bigframes.series.Series, bigframes.geopandas.GeoSeries],
     other: Union[
-        bigframes.series.Series, bigframes.geopandas.GeoSeries, shapely.Geometry
+        bigframes.series.Series,
+        bigframes.geopandas.GeoSeries,
+        shapely.geometry.base.BaseGeometry,
     ],
 ) -> bigframes.series.Series:
     """
@@ -207,7 +209,9 @@ def st_difference(
 def st_distance(
     series: Union[bigframes.series.Series, bigframes.geopandas.GeoSeries],
     other: Union[
-        bigframes.series.Series, bigframes.geopandas.GeoSeries, shapely.Geometry
+        bigframes.series.Series,
+        bigframes.geopandas.GeoSeries,
+        shapely.geometry.base.BaseGeometry,
     ],
     *,
     use_spheroid: bool = False,
@@ -260,7 +264,7 @@ def st_distance(
             A series containing geography objects.
         other (bigframes.pandas.Series | bigframes.geopandas.GeoSeries | shapely.Geometry):
             The series or geometric object to calculate the distance in meters
-            to from the geography objects in ``series``.
+            to form the geography objects in ``series``.
         use_spheroid (optional, default ``False``):
             Determines how this function measures distance. If ``use_spheroid``
             is False, the function measures distance on the surface of a perfect
@@ -282,7 +286,9 @@ def st_distance(
 def st_intersection(
     series: Union[bigframes.series.Series, bigframes.geopandas.GeoSeries],
     other: Union[
-        bigframes.series.Series, bigframes.geopandas.GeoSeries, shapely.Geometry
+        bigframes.series.Series,
+        bigframes.geopandas.GeoSeries,
+        shapely.geometry.base.BaseGeometry,
     ],
 ) -> bigframes.series.Series:
     """

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/array_value.py

@@ -204,7 +204,17 @@ class ArrayValue:
 
     def row_count(self) -> ArrayValue:
         """Get number of rows in ArrayValue as a single-entry ArrayValue."""
-        return ArrayValue(nodes.RowCountNode(child=self.node))
+        return ArrayValue(
+            nodes.AggregateNode(
+                child=self.node,
+                aggregations=(
+                    (
+                        ex.NullaryAggregation(agg_ops.size_op),
+                        ids.ColumnId(bigframes.core.guid.generate_guid()),
+                    ),
+                ),
+            )
+        )
 
     # Operations
     def filter_by_id(self, predicate_id: str, keep_null: bool = False) -> ArrayValue:

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/bigframe_node.py

@@ -20,10 +20,9 @@ import dataclasses
 import functools
 import itertools
 import typing
-from typing import Callable, Dict, Generator, Iterable, Mapping, Set, Tuple
+from typing import Callable, Dict, Generator, Iterable, Mapping, Sequence, Set, Tuple
 
 from bigframes.core import identifiers
-import bigframes.core.guid
 import bigframes.core.schema as schemata
 import bigframes.dtypes
 
@@ -163,7 +162,7 @@ class BigFrameNode:
     # TODO: Store some local data lazily for select, aggregate nodes.
     @property
     @abc.abstractmethod
-    def fields(self) -> Iterable[Field]:
+    def fields(self) -> Sequence[Field]:
         ...
 
     @property

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/blocks.py

@@ -39,7 +39,6 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
-    TYPE_CHECKING,
     Union,
 )
 import warnings
@@ -68,13 +67,8 @@ import bigframes.core.utils as utils
 import bigframes.core.window_spec as windows
 import bigframes.dtypes
 import bigframes.exceptions as bfe
-import bigframes.features
 import bigframes.operations as ops
 import bigframes.operations.aggregations as agg_ops
-import bigframes.session._io.pandas as io_pandas
-
-if TYPE_CHECKING:
-    import bigframes.session.executor
 
 # Type constraint for wherever column labels are used
 Label = typing.Hashable
@@ -221,7 +215,7 @@ class Block:
             except Exception:
                 pass
 
-        row_count = self.session._executor.get_row_count(self.expr)
+        row_count = self.session._executor.execute(self.expr.row_count()).to_py_scalar()
         return (row_count, len(self.value_columns))
 
     @property
@@ -485,7 +479,7 @@ class Block:
         *,
         ordered: bool = True,
         allow_large_results: Optional[bool] = None,
-    ) -> Tuple[pa.Table, bigquery.QueryJob]:
+    ) -> Tuple[pa.Table, Optional[bigquery.QueryJob]]:
         """Run query and download results as a pyarrow Table."""
         execute_result = self.session._executor.execute(
             self.expr, ordered=ordered, use_explicit_destination=allow_large_results
@@ -580,7 +574,7 @@ class Block:
             result = self.session._executor.peek(
                 self.expr, n, use_explicit_destination=allow_large_results
             )
-            df = io_pandas.arrow_to_pandas(result.to_arrow_table(), self.expr.schema)
+            df = result.to_pandas()
             self._copy_index_to_pandas(df)
             return df
         else:
@@ -604,8 +598,7 @@ class Block:
             page_size=page_size,
             max_results=max_results,
         )
-        for record_batch in execute_result.arrow_batches():
-            df = io_pandas.arrow_to_pandas(record_batch, self.expr.schema)
+        for df in execute_result.to_pandas_batches():
             self._copy_index_to_pandas(df)
             if squeeze:
                 yield df.squeeze(axis=1)
@@ -659,7 +652,7 @@ class Block:
 
         # TODO: Maybe materialize before downsampling
         # Some downsampling methods
-        if fraction < 1:
+        if fraction < 1 and (execute_result.total_rows is not None):
             if not sample_config.enable_downsampling:
                 raise RuntimeError(
                     f"The data size ({table_mb:.2f} MB) exceeds the maximum download limit of "
@@ -690,9 +683,7 @@ class Block:
                 MaterializationOptions(ordered=materialize_options.ordered)
             )
         else:
-            total_rows = execute_result.total_rows
-            arrow = execute_result.to_arrow_table()
-            df = io_pandas.arrow_to_pandas(arrow, schema=self.expr.schema)
+            df = execute_result.to_pandas()
             self._copy_index_to_pandas(df)
 
         return df, execute_result.query_job
@@ -1570,12 +1561,11 @@ class Block:
 
         # head caches full underlying expression, so row_count will be free after
         head_result = self.session._executor.head(self.expr, max_results)
-        count = self.session._executor.get_row_count(self.expr)
+        row_count = self.session._executor.execute(self.expr.row_count()).to_py_scalar()
 
-        arrow = head_result.to_arrow_table()
-        df = io_pandas.arrow_to_pandas(arrow, schema=self.expr.schema)
+        df = head_result.to_pandas()
         self._copy_index_to_pandas(df)
-        return df, count, head_result.query_job
+        return df, row_count, head_result.query_job
 
     def promote_offsets(self, label: Label = None) -> typing.Tuple[Block, str]:
         expr, result_id = self._expr.promote_offsets()

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/compile/api.py

@@ -18,7 +18,7 @@ from typing import Optional, Sequence, Tuple, TYPE_CHECKING
 import google.cloud.bigquery as bigquery
 
 from bigframes.core import rewrite
-from bigframes.core.compile import compiler
+from bigframes.core.compile import compiler, configs
 
 if TYPE_CHECKING:
     import bigframes.core.nodes
@@ -34,7 +34,7 @@ class SQLCompiler:
         limit: Optional[int] = None,
     ) -> str:
         """Compile node into sql where rows are sorted with ORDER BY."""
-        request = compiler.CompileRequest(node, sort_rows=ordered, peek_count=limit)
+        request = configs.CompileRequest(node, sort_rows=ordered, peek_count=limit)
         return compiler.compile_sql(request).sql
 
     def compile_raw(
@@ -44,7 +44,7 @@ class SQLCompiler:
         str, Sequence[bigquery.SchemaField], bigframes.core.ordering.RowOrdering
     ]:
         """Compile node into sql that exposes all columns, including hidden ordering-only columns."""
-        request = compiler.CompileRequest(
+        request = configs.CompileRequest(
             node, sort_rows=False, materialize_all_order_keys=True
         )
         result = compiler.compile_sql(request)

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/compile/compiled.py

@@ -288,13 +288,7 @@ class UnorderedIR:
     def from_polars(
         cls, pa_table: pa.Table, schema: Sequence[bigquery.SchemaField]
     ) -> UnorderedIR:
-        # TODO: add offsets
-        """
-        Builds an in-memory only (SQL only) expr from a pandas dataframe.
-
-        Assumed that the dataframe has unique string column names and bigframes-suppported
-        dtypes.
-        """
+        """Builds an in-memory only (SQL only) expr from a pyarrow table."""
         import bigframes_vendored.ibis.backends.bigquery.datatypes as third_party_ibis_bqtypes
 
         # derive the ibis schema from the original pandas schema

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/compile/compiler.py

@@ -22,13 +22,13 @@ 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 pyarrow as pa
 
 from bigframes import dtypes, operations
 from bigframes.core import expression
 import bigframes.core.compile.compiled as compiled
 import bigframes.core.compile.concat as concat_impl
+import bigframes.core.compile.configs as configs
 import bigframes.core.compile.explode
 import bigframes.core.compile.scalar_op_compiler as compile_scalar
 import bigframes.core.nodes as nodes
@@ -39,22 +39,7 @@ if typing.TYPE_CHECKING:
     import bigframes.core
 
 
-@dataclasses.dataclass(frozen=True)
-class CompileRequest:
-    node: nodes.BigFrameNode
-    sort_rows: bool
-    materialize_all_order_keys: bool = False
-    peek_count: typing.Optional[int] = None
-
-
-@dataclasses.dataclass(frozen=True)
-class CompileResult:
-    sql: str
-    sql_schema: typing.Sequence[google.cloud.bigquery.SchemaField]
-    row_order: Optional[bf_ordering.RowOrdering]
-
-
-def compile_sql(request: CompileRequest) -> CompileResult:
+def compile_sql(request: configs.CompileRequest) -> configs.CompileResult:
     output_names = tuple((expression.DerefOp(id), id.sql) for id in request.node.ids)
     result_node = nodes.ResultNode(
         request.node,
@@ -74,7 +59,7 @@ def compile_sql(request: CompileRequest) -> CompileResult:
     if request.sort_rows:
         result_node = cast(nodes.ResultNode, rewrites.column_pruning(result_node))
         sql = compile_result_node(result_node)
-        return CompileResult(
+        return configs.CompileResult(
             sql, result_node.schema.to_bigquery(), result_node.order_by
         )
 
@@ -88,7 +73,7 @@ def compile_sql(request: CompileRequest) -> CompileResult:
             ordering if ordering.referenced_columns.issubset(result_node.ids) else None
         )
     assert (not request.materialize_all_order_keys) or (output_order is not None)
-    return CompileResult(sql, result_node.schema.to_bigquery(), output_order)
+    return configs.CompileResult(sql, result_node.schema.to_bigquery(), output_order)
 
 
 def _replace_unsupported_ops(node: nodes.BigFrameNode):
@@ -183,16 +168,13 @@ def compile_readlocal(node: nodes.ReadLocalNode, *args):
     pa_table = node.local_data_source.data
     bq_schema = node.schema.to_bigquery()
 
-    pa_table = pa_table.select(list(item.source_id for item in node.scan_list.items))
-    pa_table = pa_table.rename_columns(
-        {item.source_id: item.id.sql for item in node.scan_list.items}
-    )
+    pa_table = pa_table.select([item.source_id for item in node.scan_list.items])
+    pa_table = pa_table.rename_columns([item.id.sql for item in node.scan_list.items])
 
     if offsets:
         pa_table = pa_table.append_column(
             offsets, pa.array(range(pa_table.num_rows), type=pa.int64())
         )
-        bq_schema = (*bq_schema, google.cloud.bigquery.SchemaField(offsets, "INT64"))
     return compiled.UnorderedIR.from_polars(pa_table, bq_schema)
 
 
@@ -270,11 +252,6 @@ def compile_concat(node: nodes.ConcatNode, *children: compiled.UnorderedIR):
     return concat_impl.concat_unordered(children, output_ids)
 
 
-@_compile_node.register
-def compile_rowcount(node: nodes.RowCountNode, child: compiled.UnorderedIR):
-    return child.row_count(name=node.col_id.sql)
-
-
 @_compile_node.register
 def compile_aggregate(node: nodes.AggregateNode, child: compiled.UnorderedIR):
     aggs = tuple((agg, id.sql) for agg, id in node.aggregations)

bigframes-2.2.0/bigframes/core/compile/configs.py

@@ -0,0 +1,36 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import dataclasses
+import typing
+
+import google.cloud.bigquery
+
+from bigframes.core import nodes, ordering
+
+
+@dataclasses.dataclass(frozen=True)
+class CompileRequest:
+    node: nodes.BigFrameNode
+    sort_rows: bool
+    materialize_all_order_keys: bool = False
+    peek_count: typing.Optional[int] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class CompileResult:
+    sql: str
+    sql_schema: typing.Sequence[google.cloud.bigquery.SchemaField]
+    row_order: typing.Optional[ordering.RowOrdering]

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/compile/googlesql/expression.py

@@ -25,7 +25,7 @@ Core class:
 * `expression`: Models basic SQL expressions.
 
 Extended classes (not part of standard GoogleSQL syntax, but added for convenience):
-i
+
 * `ColumnExpression`:  Represents column references.
 * `TableExpression`:   Represents table references.
 * `AliasExpression`:   Represents aliased expressions.

{bigframes-2.1.0 → bigframes-2.2.0}/bigframes/core/compile/polars/compiler.py

@@ -252,11 +252,6 @@ class PolarsCompiler:
         ]
         return self.compile_node(node.child).with_columns(new_cols)
 
-    @compile_node.register
-    def compile_rowcount(self, node: nodes.RowCountNode):
-        df = cast(pl.LazyFrame, self.compile_node(node.child))
-        return df.select(pl.len().alias(node.col_id.sql))
-
     @compile_node.register
     def compile_offsets(self, node: nodes.PromoteOffsetsNode):
         return self.compile_node(node.child).with_columns(

bigframes-2.2.0/bigframes/core/compile/sqlglot/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from bigframes.core.compile.sqlglot.compiler import SQLGlotCompiler
+
+__all__ = ["SQLGlotCompiler"]

bigframes-2.2.0/bigframes/core/compile/sqlglot/compiler.py

@@ -0,0 +1,168 @@
+# 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 dataclasses
+import functools
+import itertools
+import typing
+
+from google.cloud import bigquery
+import pyarrow as pa
+import sqlglot.expressions as sge
+
+from bigframes.core import expression, identifiers, nodes, rewrite
+from bigframes.core.compile import configs
+import bigframes.core.compile.sqlglot.scalar_compiler as scalar_compiler
+import bigframes.core.compile.sqlglot.sqlglot_ir as ir
+import bigframes.core.ordering as bf_ordering
+
+
+@dataclasses.dataclass(frozen=True)
+class SQLGlotCompiler:
+    """Compiles BigFrame nodes into SQL using SQLGlot."""
+
+    def compile(
+        self,
+        node: nodes.BigFrameNode,
+        *,
+        ordered: bool = True,
+        limit: typing.Optional[int] = None,
+    ) -> str:
+        """Compiles node into sql where rows are sorted with ORDER BY."""
+        request = configs.CompileRequest(node, sort_rows=ordered, peek_count=limit)
+        return self._compile_sql(request).sql
+
+    def compile_raw(
+        self,
+        node: nodes.BigFrameNode,
+    ) -> typing.Tuple[
+        str, typing.Sequence[bigquery.SchemaField], bf_ordering.RowOrdering
+    ]:
+        """Compiles node into sql that exposes all columns, including hidden
+        ordering-only columns."""
+        request = configs.CompileRequest(
+            node, sort_rows=False, materialize_all_order_keys=True
+        )
+        result = self._compile_sql(request)
+        assert result.row_order is not None
+        return result.sql, result.sql_schema, result.row_order
+
+    def _compile_sql(self, request: configs.CompileRequest) -> configs.CompileResult:
+        output_names = tuple(
+            (expression.DerefOp(id), id.sql) for id in request.node.ids
+        )
+        result_node = nodes.ResultNode(
+            request.node,
+            output_cols=output_names,
+            limit=request.peek_count,
+        )
+        if request.sort_rows:
+            # Can only pullup slice if we are doing ORDER BY in outermost SELECT
+            # Need to do this before replacing unsupported ops, as that will rewrite slice ops
+            result_node = rewrite.pull_up_limits(result_node)
+        result_node = _replace_unsupported_ops(result_node)
+        # prune before pulling up order to avoid unnnecessary row_number() ops
+        result_node = typing.cast(nodes.ResultNode, rewrite.column_pruning(result_node))
+        result_node = rewrite.defer_order(
+            result_node, output_hidden_row_keys=request.materialize_all_order_keys
+        )
+        if request.sort_rows:
+            result_node = typing.cast(
+                nodes.ResultNode, rewrite.column_pruning(result_node)
+            )
+            result_node = _remap_variables(result_node)
+            sql = self._compile_result_node(result_node)
+            return configs.CompileResult(
+                sql, result_node.schema.to_bigquery(), result_node.order_by
+            )
+
+        ordering: typing.Optional[bf_ordering.RowOrdering] = result_node.order_by
+        result_node = dataclasses.replace(result_node, order_by=None)
+        result_node = typing.cast(nodes.ResultNode, rewrite.column_pruning(result_node))
+
+        result_node = _remap_variables(result_node)
+        sql = self._compile_result_node(result_node)
+        # Return the ordering iff no extra columns are needed to define the row order
+        if ordering is not None:
+            output_order = (
+                ordering
+                if ordering.referenced_columns.issubset(result_node.ids)
+                else None
+            )
+        assert (not request.materialize_all_order_keys) or (output_order is not None)
+        return configs.CompileResult(
+            sql, result_node.schema.to_bigquery(), output_order
+        )
+
+    def _compile_result_node(self, root: nodes.ResultNode) -> str:
+        sqlglot_ir = compile_node(root.child)
+        # TODO: add order_by, limit, and selections to sqlglot_expr
+        return sqlglot_ir.sql
+
+
+def _replace_unsupported_ops(node: nodes.BigFrameNode):
+    node = nodes.bottom_up(node, rewrite.rewrite_slice)
+    node = nodes.bottom_up(node, rewrite.rewrite_timedelta_expressions)
+    node = nodes.bottom_up(node, rewrite.rewrite_range_rolling)
+    return node
+
+
+def _remap_variables(node: nodes.ResultNode) -> nodes.ResultNode:
+    """Remaps `ColumnId`s in the BFET of a `ResultNode` to produce deterministic UIDs."""
+
+    def anonymous_column_ids() -> typing.Generator[identifiers.ColumnId, None, None]:
+        for i in itertools.count():
+            yield identifiers.ColumnId(name=f"bfcol_{i}")
+
+    result_node, _ = rewrite.remap_variables(node, anonymous_column_ids())
+    return typing.cast(nodes.ResultNode, result_node)
+
+
+@functools.lru_cache(maxsize=5000)
+def compile_node(node: nodes.BigFrameNode) -> ir.SQLGlotIR:
+    """Compiles node into CompileArrayValue. Caches result."""
+    return node.reduce_up(lambda node, children: _compile_node(node, *children))
+
+
+@functools.singledispatch
+def _compile_node(
+    node: nodes.BigFrameNode, *compiled_children: ir.SQLGlotIR
+) -> ir.SQLGlotIR:
+    """Defines transformation but isn't cached, always use compile_node instead"""
+    raise ValueError(f"Can't compile unrecognized node: {node}")
+
+
+@_compile_node.register
+def compile_readlocal(node: nodes.ReadLocalNode, *args) -> ir.SQLGlotIR:
+    pa_table = node.local_data_source.data
+    pa_table = pa_table.select([item.source_id for item in node.scan_list.items])
+    pa_table = pa_table.rename_columns([item.id.sql for item in node.scan_list.items])
+
+    offsets = node.offsets_col.sql if node.offsets_col else None
+    if offsets:
+        pa_table = pa_table.append_column(
+            offsets, pa.array(range(pa_table.num_rows), type=pa.int64())
+        )
+
+    return ir.SQLGlotIR.from_pyarrow(pa_table, node.schema)
+
+
+@_compile_node.register
+def compile_selection(node: nodes.SelectionNode, child: ir.SQLGlotIR) -> ir.SQLGlotIR:
+    select_cols: typing.Dict[str, sge.Expression] = {
+        id.name: scalar_compiler.compile_scalar_expression(expr)
+        for expr, id in node.input_output_pairs
+    }
+    return child.select(select_cols)