bigframes 2.45.0__tar.gz → 2.47.0__tar.gz

{bigframes-2.45.0/bigframes.egg-info → bigframes-2.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bigframes
-Version: 2.45.0
+Version: 2.47.0
 Summary: BigQuery DataFrames -- scalable analytics and machine learning with BigQuery
 Home-page: https://dataframes.bigquery.dev
 Download-URL: https://github.com/googleapis/google-cloud-python/tree/main/packages/bigframes/releases
@@ -33,9 +33,9 @@ Requires-Dist: geopandas>=0.12.2
 Requires-Dist: google-auth[pyopenssl]<3.0,>=2.15.0
 Requires-Dist: google-cloud-bigquery[bqstorage,pandas]>=3.36.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-resource-manager>=1.10.3
+Requires-Dist: google-cloud-functions>=1.20.2
+Requires-Dist: google-cloud-bigquery-connection>=1.18.2
+Requires-Dist: google-cloud-resource-manager>=1.14.2
 Requires-Dist: google-cloud-storage>=2.0.0
 Requires-Dist: google-crc32c<2.0.0,>=1.0.0
 Requires-Dist: grpc-google-iam-v1>=0.14.2
@@ -60,8 +60,8 @@ Requires-Dist: rich<14,>=12.4.4
 Provides-Extra: tests
 Requires-Dist: freezegun; extra == "tests"
 Requires-Dist: pytest-snapshot; extra == "tests"
-Requires-Dist: google-cloud-bigtable>=2.24.0; extra == "tests"
-Requires-Dist: google-cloud-pubsub>=2.21.4; extra == "tests"
+Requires-Dist: google-cloud-bigtable>=2.30.0; extra == "tests"
+Requires-Dist: google-cloud-pubsub>=2.29.0; extra == "tests"
 Requires-Dist: tzdata; extra == "tests"
 Provides-Extra: polars
 Requires-Dist: polars>=1.21.0; extra == "polars"
@@ -78,8 +78,8 @@ Requires-Dist: traitlets>=5.0.0; extra == "anywidget"
 Provides-Extra: all
 Requires-Dist: anywidget>=0.9.18; extra == "all"
 Requires-Dist: freezegun; extra == "all"
-Requires-Dist: google-cloud-bigtable>=2.24.0; extra == "all"
-Requires-Dist: google-cloud-pubsub>=2.21.4; extra == "all"
+Requires-Dist: google-cloud-bigtable>=2.30.0; extra == "all"
+Requires-Dist: google-cloud-pubsub>=2.29.0; extra == "all"
 Requires-Dist: google-cloud-testutils; extra == "all"
 Requires-Dist: nox; extra == "all"
 Requires-Dist: polars>=1.21.0; extra == "all"

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/_config/compute_options.py

@@ -168,26 +168,6 @@ class ComputeOptions:
         int | None: Number of rows, if set.
     """
 
-    semantic_ops_confirmation_threshold: Optional[int] = 0
-    """
-    Deprecated.
-
-    .. deprecated:: 1.42.0
-        Semantic operators are deprecated. Please use the functions in
-        :mod:`bigframes.bigquery.ai` instead.
-
-    """
-
-    semantic_ops_threshold_autofail = False
-    """
-    Deprecated.
-
-    .. deprecated:: 1.42.0
-        Semantic operators are deprecated. Please use the functions in
-        :mod:`bigframes.bigquery.ai` instead.
-
-    """
-
     def assign_extra_query_labels(self, **kwargs: Any) -> None:
         """
         Assigns additional custom labels for query configuration. The method updates the

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/_config/experiment_options.py

@@ -25,52 +25,9 @@ class ExperimentOptions:
     """
 
     def __init__(self):
-        self._semantic_operators: bool = False
-        self._ai_operators: bool = False
         self._sql_compiler: Literal["legacy", "stable", "experimental"] = "stable"
         self._enable_python_transpiler: bool = False
 
-    @property
-    def semantic_operators(self) -> bool:
-        """Deprecated.
-
-        **Examples:**
-
-            >>> import bigframes.pandas as bpd
-            >>> bpd.options.experiments.semantic_operators = True  # doctest: +SKIP
-        """
-        return self._semantic_operators
-
-    @semantic_operators.setter
-    def semantic_operators(self, value: bool):
-        if value is True:
-            msg = bfe.format_message(
-                "Semantic operators are deprecated, and will be removed in the future"
-            )
-            warnings.warn(msg, category=FutureWarning)
-        self._semantic_operators = value
-
-    @property
-    def ai_operators(self) -> bool:
-        """If True, allow using the AI operators.
-
-        **Examples:**
-
-            >>> import bigframes.pandas as bpd
-            >>> bpd.options.experiments.ai_operators = True  # doctest: +SKIP
-        """
-        return self._ai_operators
-
-    @ai_operators.setter
-    def ai_operators(self, value: bool):
-        if value is True:
-            msg = bfe.format_message(
-                "AI operators are still under experiments, and are subject "
-                "to change in the future."
-            )
-            warnings.warn(msg, category=bfe.PreviewWarning)
-        self._ai_operators = value
-
     @property
     def sql_compiler(self) -> Literal["legacy", "stable", "experimental"]:
         """Set to 'experimental' to try out the latest in compilation experiments..

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/_magics.py

@@ -37,6 +37,9 @@ import bigframes.pandas
 )
 def _cell_magic(line, cell):
     ipython = get_ipython()
+    if ipython is None:
+        raise RuntimeError("BigQuery magic must be run in an IPython environment.")
+
     args = magic_arguments.parse_argstring(_cell_magic, line)
     if not cell:
         print("Query is missing.")

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/block_transforms.py

@@ -27,22 +27,26 @@ import bigframes.core.blocks as blocks
 import bigframes.core.bytecode as bytecode
 import bigframes.core.expression as ex
 import bigframes.core.ordering as ordering
-import bigframes.core.window_spec as windows
+import bigframes.core.window_spec as window_specs
 import bigframes.dtypes as dtypes
+import bigframes.functions
 import bigframes.operations as ops
 import bigframes.operations.aggregations as agg_ops
+from bigframes._config import options
 from bigframes.core import agg_expressions, py_expressions
 
 
-def apply_to_block_rows(
-    func: Callable, block: blocks.Block, *args, **kwargs
-) -> blocks.Block:
-    """
-    Apply the given function to each row of the block.
-
-    The function is applied to each row of the block, and the result is returned
-    as a new block with the same index.
-    """
+def compile_udf(
+    block: blocks.Block,
+    func: Callable,
+    args: tuple = (),
+    kwargs: dict | None = None,
+    col_series_args: typing.Mapping[str, str] | None = None,
+    window_spec: Optional[window_specs.WindowSpec] = None,
+) -> ex.Expression:
+    """Compile a python function to a BigFrames expression in the context of a block."""
+    if kwargs is None:
+        kwargs = {}
     expr = bytecode._compile_bytecode_to_py_expr(func)
     sig = inspect.signature(func)
 
@@ -54,17 +58,77 @@ def apply_to_block_rows(
     for name, value in bound_params.items():
         bindings[name] = ex.const(value)
 
-    expr = py_expressions.resolve_py_exprs(
-        expr,
-        series_arg=next(iter(sig.parameters.keys())),
-        series_attrs={
-            label: col_id
-            for label in block.column_labels
-            if (col_id := block.resolve_label_exact(label)) is not None
-        },
-    )
+    series_arg = next(iter(sig.parameters.keys()))
+
+    if col_series_args is not None:
+        expr = py_expressions.resolve_py_exprs(
+            expr,
+            series_arg=series_arg,
+            col_series_args=col_series_args,
+            window_spec=window_spec,
+        )
+    else:
+        series_attrs: dict = {}
+        for i, (col_id, label) in enumerate(
+            zip(block.value_columns, block.column_labels)
+        ):
+            series_attrs[i] = col_id
+            if label is not None:
+                series_attrs[label] = col_id
+
+        expr = py_expressions.resolve_py_exprs(
+            expr,
+            series_arg=series_arg,
+            series_attrs=series_attrs,
+            window_spec=window_spec,
+        )
+
     expr = expr.bind_variables(bindings)
+    return expr
+
 
+def is_transpiler_eligible(func: typing.Any) -> bool:
+    """Return True if func is eligible for Python transpilation."""
+    return (
+        options.experiments.enable_python_transpiler
+        and callable(func)
+        and not isinstance(func, bigframes.functions.Udf)
+    )
+
+
+def compile_column_udf(
+    block: blocks.Block,
+    func: Callable,
+    column_id: str,
+    args: tuple = (),
+    kwargs: dict | None = None,
+    window_spec: Optional[window_specs.WindowSpec] = None,
+) -> tuple[ex.Expression, str]:
+    """Compile a column-wise python UDF in block context and return (expr, name)."""
+    sig = inspect.signature(func)
+    series_arg = next(iter(sig.parameters.keys()))
+    expr = compile_udf(
+        block,
+        func,
+        args=args,
+        kwargs=kwargs,
+        col_series_args={series_arg: column_id},
+        window_spec=window_spec,
+    )
+    name = getattr(func, "__name__", "<lambda>")
+    return expr, name
+
+
+def apply_to_block_rows(
+    func: Callable, block: blocks.Block, *args, **kwargs
+) -> blocks.Block:
+    """
+    Apply the given function to each row of the block.
+
+    The function is applied to each row of the block, and the result is returned
+    as a new block with the same index.
+    """
+    expr = compile_udf(block, func, args, kwargs)
     return block.project_exprs([expr], labels=[None], drop=True)
 
 
@@ -107,13 +171,13 @@ def indicate_duplicates(
         agg_expressions.NullaryAggregation(
             agg_ops.RowNumberOp(),
         ),
-        window=windows.unbound(grouping_keys=tuple(columns)),
+        window=window_specs.unbound(grouping_keys=tuple(columns)),
     )
     count = agg_expressions.WindowExpression(
         agg_expressions.NullaryAggregation(
             agg_ops.SizeOp(),
         ),
-        window=windows.unbound(grouping_keys=tuple(columns)),
+        window=window_specs.unbound(grouping_keys=tuple(columns)),
     )
 
     if keep == "first":
@@ -147,7 +211,7 @@ def quantile(
     dropna: bool = False,
 ) -> blocks.Block:
     # TODO: handle windowing and more interpolation methods
-    window = windows.unbound(
+    window = window_specs.unbound(
         grouping_keys=tuple(grouping_column_ids),
     )
     quantile_cols = []
@@ -248,8 +312,8 @@ def _interpolate_column(
     if interpolate_method not in ["linear", "nearest", "ffill"]:
         raise ValueError("interpolate method not supported")
     window_ordering = (ordering.OrderingExpression(ex.deref(x_values)),)
-    backwards_window = windows.rows(end=0, ordering=window_ordering)
-    forwards_window = windows.rows(start=0, ordering=window_ordering)
+    backwards_window = window_specs.rows(end=0, ordering=window_ordering)
+    forwards_window = window_specs.rows(start=0, ordering=window_ordering)
 
     # Note, this method may
     block, notnull = block.apply_unary_op(column, ops.notnull_op)
@@ -401,7 +465,7 @@ def value_counts(
     )
     count_id = block.value_columns[0]
     if normalize:
-        unbound_window = windows.unbound(grouping_keys=tuple(grouping_keys))
+        unbound_window = window_specs.unbound(grouping_keys=tuple(grouping_keys))
         block, total_count_id = block.apply_window_op(
             count_id, agg_ops.sum_op, unbound_window
         )
@@ -429,7 +493,7 @@ def pct_change(block: blocks.Block, periods: int = 1) -> blocks.Block:
     column_labels = block.column_labels
 
     # Window framing clause is not allowed for analytic function lag.
-    window_spec = windows.unbound()
+    window_spec = window_specs.unbound()
 
     original_columns = block.value_columns
     exprs = []
@@ -484,9 +548,9 @@ def rank(
         )
         window_op = agg_ops.dense_rank_op if method == "dense" else agg_ops.count_op
         window_spec = (
-            windows.unbound(grouping_keys=grouping_cols, ordering=window_ordering)
+            window_specs.unbound(grouping_keys=grouping_cols, ordering=window_ordering)
             if method == "dense"
-            else windows.rows(
+            else window_specs.rows(
                 end=0, ordering=window_ordering, grouping_keys=grouping_cols
             )
         )
@@ -498,7 +562,7 @@ def rank(
                 result_expr,
                 agg_expressions.WindowExpression(
                     agg_expressions.UnaryAggregation(agg_ops.max_op, result_expr),
-                    windows.unbound(grouping_keys=grouping_cols),
+                    window_specs.unbound(grouping_keys=grouping_cols),
                 ),
             )
         # Step 2: Apply aggregate to groups of like input values.
@@ -511,7 +575,7 @@ def rank(
             }[method]
             result_expr = agg_expressions.WindowExpression(
                 agg_expressions.UnaryAggregation(agg_op, result_expr),
-                windows.unbound(grouping_keys=(col, *grouping_cols)),
+                window_specs.unbound(grouping_keys=(col, *grouping_cols)),
             )
         # Pandas masks all values where any grouping column is null
         # Note: we use pd.NA instead of float('nan')
@@ -612,7 +676,7 @@ def nsmallest(
         block, counter = block.apply_window_op(
             column_ids[0],
             agg_ops.rank_op,
-            window_spec=windows.unbound(ordering=tuple(order_refs)),
+            window_spec=window_specs.unbound(ordering=tuple(order_refs)),
         )
         block, condition = block.project_expr(ops.le_op.as_expr(counter, ex.const(n)))
         block = block.filter_by_id(condition)
@@ -642,7 +706,7 @@ def nlargest(
         block, counter = block.apply_window_op(
             column_ids[0],
             agg_ops.rank_op,
-            window_spec=windows.unbound(ordering=tuple(order_refs)),
+            window_spec=window_specs.unbound(ordering=tuple(order_refs)),
         )
         block, condition = block.project_expr(ops.le_op.as_expr(counter, ex.const(n)))
         block = block.filter_by_id(condition)
@@ -913,7 +977,7 @@ def _idx_extrema(
                 for idx_col in original_block.index_columns
             ],
         ]
-        window_spec = windows.unbound(ordering=tuple(order_refs))
+        window_spec = window_specs.unbound(ordering=tuple(order_refs))
         idx_col = original_block.index_columns[0]
         block, result_col = block.apply_window_op(
             idx_col, agg_ops.first_op, window_spec

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/bytecode.py

@@ -31,6 +31,7 @@ _BINARY_OP_MAP = {
     "//": operator.floordiv,
     "%": operator.mod,
     "**": operator.pow,
+    "[]": operator.getitem,
 }
 
 _COMPARE_OP_MAP = {
@@ -508,6 +509,18 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                         )
                     )
 
+                case "BINARY_SUBSCR":
+                    if len(stack) < 2:
+                        raise ValueError("Stack has < 2 elements")
+                    key = stack.pop()
+                    container = stack.pop()
+                    stack.append(
+                        py_exprs.Call(
+                            py_exprs.PyObject(operator.getitem),
+                            (container, key),
+                        )
+                    )
+
                 case name if name in _OLD_BINARY_OP_MAP:
                     if len(stack) < 2:
                         raise ValueError("Stack has < 2 elements")
@@ -575,17 +588,28 @@ def _compile_bytecode_to_py_expr(func: Callable) -> expression.Expression:
                     if len(stack) < num_args:
                         raise ValueError(f"Stack has fewer than {num_args} elements")
                     args = [stack.pop() for _ in range(num_args)][::-1]
-                    if len(stack) >= 2 and stack[-2] == _NULL:
-                        stack[-1], stack[-2] = stack[-2], stack[-1]
-                    if stack and stack[-1] == _NULL:
-                        stack.pop()
-                    elif (
-                        stack
-                        and stack[-1] != _NULL
-                        and isinstance(stack[-1], expression.Expression)
-                    ):
-                        self_arg = stack.pop()
-                        args = [self_arg] + args
+
+                    is_method_call = False
+                    if opname == "CALL" or opname == "CALL_METHOD":
+                        if len(stack) >= 2 and stack[-2] == _NULL:
+                            stack[-1], stack[-2] = stack[-2], stack[-1]
+                        if stack and stack[-1] == _NULL:
+                            stack.pop()
+                            is_method_call = False
+                        else:
+                            is_method_call = True
+                    elif opname == "CALL_FUNCTION":
+                        is_method_call = False
+
+                    if is_method_call:
+                        if (
+                            stack
+                            and stack[-1] != _NULL
+                            and isinstance(stack[-1], expression.Expression)
+                        ):
+                            self_arg = stack.pop()
+                            args = [self_arg] + args
+
                     if not stack:
                         raise ValueError("Stack is empty")
                     callable_expr = stack.pop()

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/compile/ibis_compiler/scalar_op_registry.py

@@ -363,14 +363,6 @@ def contains_regex_op_impl(x: ibis_types.Value, op: ops.StrContainsRegexOp):
     return typing.cast(ibis_types.StringValue, x).re_search(op.pat)
 
 
-@scalar_op_compiler.register_unary_op(ops.StrGetOp, pass_op=True)
-def strget_op_impl(x: ibis_types.Value, op: ops.StrGetOp):
-    substr = typing.cast(
-        ibis_types.StringValue, typing.cast(ibis_types.StringValue, x)[op.i]
-    )
-    return substr.nullif(ibis_types.literal(""))
-
-
 @scalar_op_compiler.register_unary_op(ops.StrPadOp, pass_op=True)
 def strpad_op_impl(x: ibis_types.Value, op: ops.StrPadOp):
     str_val = typing.cast(ibis_types.StringValue, x)
@@ -1059,13 +1051,39 @@ def array_to_string_op_impl(x: ibis_types.Value, op: ops.ArrayToStringOp):
     return typing.cast(ibis_types.ArrayValue, x).join(op.delimiter)
 
 
-@scalar_op_compiler.register_unary_op(ops.ArrayIndexOp, pass_op=True)
-def array_index_op_impl(x: ibis_types.Value, op: ops.ArrayIndexOp):
-    res = typing.cast(ibis_types.ArrayValue, x)[op.index]
-    if x.type().is_string():
+@scalar_op_compiler.register_unary_op(ops.GetItemOp, pass_op=True)
+def getitem_op_impl(x: ibis_types.Value, op: ops.GetItemOp):
+    if x.type().is_struct():
+        struct_value = typing.cast(ibis_types.StructValue, x)
+        if isinstance(op.key, str):
+            name = op.key
+        else:
+            name = struct_value.names[op.key]
+        result = struct_value[name]
+        return result.cast(result.type()(nullable=True)).name(name)
+    elif x.type().is_array():
+        key = typing.cast(int, op.key)
+        res = typing.cast(ibis_types.ArrayValue, x)[key]
+        return res
+    elif x.type().is_string():
+        key = typing.cast(int, op.key)
+        res = typing.cast(ibis_types.StringValue, x)[key]
         return _null_or_value(res, res != ibis_types.literal(""))
     else:
-        return res
+        raise TypeError(f"Cannot subscript input of type {x.type()}")
+
+
+@scalar_op_compiler.register_binary_op(ops.DynamicGetItemOp)
+def dynamic_getitem_op_impl(left: ibis_types.Value, right: ibis_types.Value):
+    if left.type().is_array():
+        int_right = typing.cast(ibis_types.IntegerValue, right)
+        return typing.cast(ibis_types.ArrayValue, left)[int_right]
+    elif left.type().is_string():
+        scalar_right = typing.cast(ibis_types.IntegerScalar, right)
+        res = typing.cast(ibis_types.StringValue, left)[scalar_right]
+        return _null_or_value(res, res != ibis_types.literal(""))
+    else:
+        raise TypeError(f"Cannot dynamically subscript input of type {left.type()}")
 
 
 @scalar_op_compiler.register_unary_op(ops.ArraySliceOp, pass_op=True)

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/compile/polars/__init__.py

@@ -24,6 +24,7 @@ import warnings
 # The ops imports appear first so that the implementations can be registered.
 # polars shouldn't be needed at import time, as register is a no-op if polars
 # isn't installed.
+import bigframes.core.compile.polars.operations.array_ops  # noqa: F401
 import bigframes.core.compile.polars.operations.generic_ops  # noqa: F401
 import bigframes.core.compile.polars.operations.numeric_ops  # noqa: F401
 import bigframes.core.compile.polars.operations.struct_ops  # noqa: F401

bigframes-2.47.0/bigframes/core/compile/polars/operations/array_ops.py

@@ -0,0 +1,62 @@
+# Copyright 2026 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.
+
+"""
+BigFrames -> Polars compilation for the operations in bigframes.operations.array_ops.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import bigframes.core.compile.polars.compiler as polars_compiler
+import bigframes.dtypes as dtypes
+from bigframes.operations import generic_ops
+
+if TYPE_CHECKING:
+    import polars as pl
+
+
+@polars_compiler.register_op(generic_ops.GetItemOp)
+def getitem_op_impl(
+    compiler: polars_compiler.PolarsExpressionCompiler,
+    op: generic_ops.GetItemOp,  # type: ignore
+    input: pl.Expr,
+) -> pl.Expr:
+    input_type = compiler._expr_types.get(id(input))
+    if input_type is not None and dtypes.is_struct_like(input_type):
+        if isinstance(op.key, str):
+            return input.struct.field(op.key)
+        else:
+            raise NotImplementedError(
+                "Referencing a struct field by number not implemented in polars compiler."
+            )
+    elif input_type is not None and dtypes.is_string_like(input_type):
+        return input.str.slice(op.key, 1)
+    else:
+        return input.list.get(op.key)
+
+
+@polars_compiler.register_op(generic_ops.DynamicGetItemOp)
+def dynamic_getitem_op_impl(
+    compiler: polars_compiler.PolarsExpressionCompiler,
+    op: generic_ops.DynamicGetItemOp,  # type: ignore
+    left: pl.Expr,
+    right: pl.Expr,
+) -> pl.Expr:
+    left_type = compiler._expr_types.get(id(left))
+    if left_type is not None and dtypes.is_string_like(left_type):
+        return left.str.slice(right, 1)
+    else:
+        return left.list.get(right)

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/compile/sqlglot/expression_compiler.py

@@ -48,6 +48,10 @@ class ExpressionCompiler:
         sge.LT,
         sge.EQ,
         sge.NEQ,
+        sge.Like,
+        sge.RegexpLike,
+        sge.In,
+        sge.Between,
         # Logical operations
         sge.And,
         sge.Or,

{bigframes-2.45.0 → bigframes-2.47.0}/bigframes/core/compile/sqlglot/expressions/array_ops.py

@@ -18,6 +18,8 @@ import typing
 
 import bigframes_vendored.sqlglot as sg
 import bigframes_vendored.sqlglot.expressions as sge
+import pandas as pd
+import pyarrow as pa
 
 import bigframes.core.compile.sqlglot.expression_compiler as expression_compiler
 import bigframes.dtypes as dtypes
@@ -32,17 +34,56 @@ register_unary_op = expression_compiler.expression_compiler.register_unary_op
 register_nary_op = expression_compiler.expression_compiler.register_nary_op
 
 
-@register_unary_op(ops.ArrayIndexOp, pass_op=True)
-def _(expr: TypedExpr, op: ops.ArrayIndexOp) -> sge.Expression:
-    if expr.dtype == dtypes.STRING_DTYPE:
-        return string_index(expr, op.index)
+@register_unary_op(ops.GetItemOp, pass_op=True)
+def _(expr: TypedExpr, op: ops.GetItemOp) -> sge.Expression:
+    if dtypes.is_struct_like(expr.dtype):
+        if isinstance(op.key, str):
+            name = op.key
+        else:
+            pa_type = typing.cast(pd.ArrowDtype, expr.dtype)
+            pa_struct_type = typing.cast(pa.StructType, pa_type.pyarrow_dtype)
+            name = pa_struct_type.field(op.key).name
 
-    return sge.Bracket(
-        this=expr.expr,
-        expressions=[sge.convert(op.index)],
-        safe=True,
-        offset=False,
-    )
+        return sge.Column(
+            this=sge.to_identifier(name, quoted=True),
+            catalog=expr.expr,
+        )
+    elif dtypes.is_array_like(expr.dtype):
+        return sge.Bracket(
+            this=expr.expr,
+            expressions=[sge.convert(op.key)],
+            safe=True,
+            offset=False,
+        )
+    elif expr.dtype == dtypes.STRING_DTYPE:
+        return string_index(expr, typing.cast(int, op.key))
+    else:
+        raise TypeError(f"Cannot subscript input of type {expr.dtype}")
+
+
+@register_nary_op(ops.DynamicGetItemOp)  # type: ignore[arg-type]
+def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
+    if dtypes.is_array_like(left.dtype):
+        return sge.Bracket(
+            this=left.expr,
+            expressions=[right.expr],
+            safe=True,
+            offset=False,
+        )
+    elif left.dtype == dtypes.STRING_DTYPE:
+        start_expr = sge.Add(this=right.expr, expression=sge.convert(1))
+        sub_str = sge.Substring(
+            this=left.expr,
+            start=start_expr,
+            length=sge.convert(1),
+        )
+        return sge.If(
+            this=sge.NEQ(this=sub_str, expression=sge.convert("")),
+            true=sub_str,
+            false=sge.Null(),
+        )
+    else:
+        raise TypeError(f"Cannot dynamically subscript input of type {left.dtype}")
 
 
 @register_unary_op(ops.ArrayReduceOp, pass_op=True)
@@ -105,7 +146,7 @@ def _(expr: TypedExpr, op: ops.ArraySliceOp) -> sge.Expression:
 
 @register_unary_op(ops.ArrayToStringOp, pass_op=True)
 def _(expr: TypedExpr, op: ops.ArrayToStringOp) -> sge.Expression:
-    return sge.ArrayToString(this=expr.expr, expression=f"'{op.delimiter}'")
+    return sge.ArrayToString(this=expr.expr, expression=sge.convert(op.delimiter))
 
 
 @register_nary_op(ops.ToArrayOp)