ibis-typing 1.0.0__tar.gz

ibis_typing-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ibis-typing contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ibis_typing-1.0.0/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: ibis-typing
+Version: 1.0.0
+Summary: A typed framework for writing Ibis expressions with full IDE and static-analysis support
+Keywords: ibis,typing,dataframe,duckdb,trino,type hints
+Author: ibis-typing contributors
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Dist: ibis-framework[duckdb,trino]>=9
+Requires-Dist: sqlglot>=25
+Requires-Dist: pyarrow>=17
+Requires-Dist: attrs>=24
+Requires-Dist: cattrs>=24
+Requires-Dist: more-itertools>=10
+Requires-Dist: typing-extensions>=4
+Requires-Dist: hypothesis>=6
+Requires-Dist: networkx>=3
+Requires-Dist: matplotlib>=3
+Requires-Dist: pydot>=4
+Requires-Dist: graphviz>=0.21
+Requires-Dist: humanize>=4
+Requires-Dist: pytest>=8 ; extra == 'dev'
+Requires-Dist: testcontainers>=4 ; extra == 'dev'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/FortnoxAB/ibis-typing
+Project-URL: Repository, https://github.com/FortnoxAB/ibis-typing
+Project-URL: Issues, https://github.com/FortnoxAB/ibis-typing/issues
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# ibis-typing
+
+[![PyPI](https://img.shields.io/pypi/v/ibis-typing)](https://pypi.org/project/ibis-typing/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/ibis-typing)](https://pypi.org/project/ibis-typing/)
+[![CI](https://github.com/FortnoxAB/ibis-typing/actions/workflows/ci.yml/badge.svg)](https://github.com/FortnoxAB/ibis-typing/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/FortnoxAB/ibis-typing/branch/main/graph/badge.svg)](https://codecov.io/gh/FortnoxAB/ibis-typing)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+
+A typed framework for writing [Ibis](https://ibis-project.org/) dataframe expressions — with full IDE support, static analysis, and property-based testing.
+
+[Ibis](https://ibis-project.org/) is a portable Python dataframe library (DSL) that runs on DuckDB, Polars, Trino, BigQuery, and more. **ibis-typing** layers a type-safe schema system on top of it, so your transforms carry type information end-to-end.
+
+## Installation
+
+```bash
+pip install ibis-typing
+```
+
+```bash
+uv add ibis-typing
+```
+
+After installation, run the type-patch step once to inject typed overloads into your installed `ibis` package:
+
+```bash
+python -m ibis_typing.type_patch
+```
+
+## Quick start
+
+### 1. Define schemas
+
+```python
+from attrs import frozen
+from ibis_typing import IbisSchema, it
+
+@frozen
+class Transaction(IbisSchema):
+    date: it.Date = None
+    amount: it.Float64 = None
+    category: it.String = None
+```
+
+### 2. Define a typed expression
+
+```python
+from ibis_typing import Expression, IbisTable, this, it
+
+@frozen
+class MonthlyAmounts(Expression):
+    month: it.Date = None
+    amount: it.Float64 = None
+
+    @classmethod
+    def from_expression(cls, inputs: IbisTable[Transaction]):
+        cols = inputs.cols
+        table = (
+            inputs.table
+            @ it.Select(expr={"month": this[cols.date].truncate("M")})
+            @ it.Aggregate(by=["month"], sum=[cols.amount])
+        )
+        return cls.of(table)
+```
+
+> **Tip:** `IbisSchema` classes for your `Expression` outputs can be generated automatically using `ibis_typing.schema_writer`. The code is backend-agnostic — schemas are derived from abstract Ibis table schemas, so no live backend is required.
+
+### 3. Evaluate against a backend
+
+```python
+from datetime import date
+
+from ibis_typing import IbisConnection, evaluator
+
+conn = IbisConnection()
+transactions = Transaction.of_rows([Transaction(date=date(2024, 1, 15), amount=100.0, category="A")])
+monthly_amounts = evaluator.from_expression(MonthlyAmounts, transactions)
+results: list[MonthlyAmounts] = list(conn.fetch_table(monthly_amounts))
+```
+
+### 4. Test with Hypothesis
+
+pytest fixtures are registered automatically — no `conftest.py` needed.
+
+```python
+from hypothesis import given, strategies as st
+from ibis_typing.hypothesis import strategy_for
+
+@given(st.lists(strategy_for(Transaction), min_size=1))
+def test_monthly_amounts(evaluate_table, transactions):
+    actual, expected = evaluate_table(MonthlyAmounts, transactions)
+    assert sorted(actual) == sorted(expected)
+```
+
+## Core concepts
+
+```mermaid
+graph TD
+    IbisSchema -->|describes| IbisTable
+    IbisTable -->|In| Expression
+    Expression -->|Out| IbisTable
+    TableProvider -->|provides tables to| Expression
+    IbisConnection -->|fetches typed rows from| IbisTable
+    ChecksumBuckets -->|incremental inputs to| IncrementalExpression
+    IncrementalExpression -->|is a| Expression
+    BucketedInputsExpression -->|is a| IncrementalExpression
+    RevertibleTableExpression -->|can revert| Expression
+```
+
+| Class                       | Purpose |
+|-----------------------------|---|
+| `IbisSchema`                | Base class for typed table schemas (attrs frozen dataclass) |
+| `IbisTable[S]`              | Generic typed wrapper around `ibis.Table` |
+| `Expression`                | Abstract base for typed ibis transforms |
+| `IbisConnection`            | Typed backend wrapper: `fetch_table()`, `evaluate()`, `read/write_parquet()` |
+| `BucketedInputsExpression`  | Expression that only re-runs for changed input buckets |
+| `ChecksumBuckets`           | Checksum-based incremental input tracking |
+| `RevertibleTableExpression` | Transform that can undo itself back to the original schema |
+
+## Type aliases
+
+Declare schema fields using column-type aliases from `ibis_typing.it`:
+
+```python
+from ibis_typing import it
+
+it.Int8, it.Int16, it.Int32, it.Int64
+it.Float32, it.Float64
+it.Boolean
+it.String, it.Binary
+it.Decimal
+it.Date, it.Time, it.Timestamp
+it.UUID, it.JSON
+it.Array[it.Int64]
+it.Map[it.String, it.Float64]
+it.Struct[MyTypedDict]
+```
+
+## Table operations
+
+Use the infix `@` operator for composable, typed table transforms:
+
+```python
+from ibis_typing import IbisSchema, IbisTable, this, it
+
+@frozen
+class InputSchema(IbisSchema):
+    a: it.Float64 = None
+    b: it.Float64 = None
+    category: it.String = None
+    amount: it.Float64 = None
+    key: it.String = None
+
+
+inputs: IbisTable[InputSchema] = ...
+other_table: IbisTable = ...
+cols = InputSchema.cols
+
+table = InputSchema.of(
+    inputs.table
+    @ it.Select(cols.a, cols.b, expr={"c": this[cols.a] + this[cols.b]})
+    @ it.Aggregate(by=[cols.category], sum=[cols.amount])
+    @ it.InnerJoin(other_table.table, keys=[cols.key])
+)
+```
+
+## Pytest fixtures
+
+The following fixtures are auto-registered via the pytest plugin entry point (no `conftest.py` needed):
+
+| Fixture | Purpose |
+|---|---|
+| `evaluate_table` | Runs an `Expression`, returns `(actual, expected)` row lists |
+| `fetch_table` | Fetches rows from an `IbisTable` via DuckDB |
+| `ibis_connection` | Provides a DuckDB-backed `IbisConnection` |
+
+## Extras
+
+- **`ibis_typing.type_patch`** — patches installed ibis with typed `@overload` stubs for `ibis.ifelse`, `ibis.cases`, `ibis.coalesce`, etc.
+- **`ibis_typing.schema_writer`** — code-gen: write `IbisSchema` `.py` files from `Expression` output schemas
+- **`ibis_typing.plot`** — plots the dependency graph of an `Expression` using matplotlib/graphviz
+- **`ibis_typing.custom`** — custom ibis operations: `DateAddMonth`, `DateAddDay`, `ColumnChecksum`, `JsonParse`, `JsonFormat`, `UUIDFromInt`, `LuhnCheck`
+
+## Contributing
+
+```bash
+git clone https://github.com/FortnoxAB/ibis-typing
+cd ibis-typing
+uv sync --all-extras
+uv run python -m ibis_typing.type_patch
+make test
+```
+
+Pull requests welcome. Please run `make` before submitting.
+
+## License
+
+[MIT](LICENSE)

ibis_typing-1.0.0/README.md

@@ -0,0 +1,200 @@
+# ibis-typing
+
+[![PyPI](https://img.shields.io/pypi/v/ibis-typing)](https://pypi.org/project/ibis-typing/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/ibis-typing)](https://pypi.org/project/ibis-typing/)
+[![CI](https://github.com/FortnoxAB/ibis-typing/actions/workflows/ci.yml/badge.svg)](https://github.com/FortnoxAB/ibis-typing/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/FortnoxAB/ibis-typing/branch/main/graph/badge.svg)](https://codecov.io/gh/FortnoxAB/ibis-typing)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+
+A typed framework for writing [Ibis](https://ibis-project.org/) dataframe expressions — with full IDE support, static analysis, and property-based testing.
+
+[Ibis](https://ibis-project.org/) is a portable Python dataframe library (DSL) that runs on DuckDB, Polars, Trino, BigQuery, and more. **ibis-typing** layers a type-safe schema system on top of it, so your transforms carry type information end-to-end.
+
+## Installation
+
+```bash
+pip install ibis-typing
+```
+
+```bash
+uv add ibis-typing
+```
+
+After installation, run the type-patch step once to inject typed overloads into your installed `ibis` package:
+
+```bash
+python -m ibis_typing.type_patch
+```
+
+## Quick start
+
+### 1. Define schemas
+
+```python
+from attrs import frozen
+from ibis_typing import IbisSchema, it
+
+@frozen
+class Transaction(IbisSchema):
+    date: it.Date = None
+    amount: it.Float64 = None
+    category: it.String = None
+```
+
+### 2. Define a typed expression
+
+```python
+from ibis_typing import Expression, IbisTable, this, it
+
+@frozen
+class MonthlyAmounts(Expression):
+    month: it.Date = None
+    amount: it.Float64 = None
+
+    @classmethod
+    def from_expression(cls, inputs: IbisTable[Transaction]):
+        cols = inputs.cols
+        table = (
+            inputs.table
+            @ it.Select(expr={"month": this[cols.date].truncate("M")})
+            @ it.Aggregate(by=["month"], sum=[cols.amount])
+        )
+        return cls.of(table)
+```
+
+> **Tip:** `IbisSchema` classes for your `Expression` outputs can be generated automatically using `ibis_typing.schema_writer`. The code is backend-agnostic — schemas are derived from abstract Ibis table schemas, so no live backend is required.
+
+### 3. Evaluate against a backend
+
+```python
+from datetime import date
+
+from ibis_typing import IbisConnection, evaluator
+
+conn = IbisConnection()
+transactions = Transaction.of_rows([Transaction(date=date(2024, 1, 15), amount=100.0, category="A")])
+monthly_amounts = evaluator.from_expression(MonthlyAmounts, transactions)
+results: list[MonthlyAmounts] = list(conn.fetch_table(monthly_amounts))
+```
+
+### 4. Test with Hypothesis
+
+pytest fixtures are registered automatically — no `conftest.py` needed.
+
+```python
+from hypothesis import given, strategies as st
+from ibis_typing.hypothesis import strategy_for
+
+@given(st.lists(strategy_for(Transaction), min_size=1))
+def test_monthly_amounts(evaluate_table, transactions):
+    actual, expected = evaluate_table(MonthlyAmounts, transactions)
+    assert sorted(actual) == sorted(expected)
+```
+
+## Core concepts
+
+```mermaid
+graph TD
+    IbisSchema -->|describes| IbisTable
+    IbisTable -->|In| Expression
+    Expression -->|Out| IbisTable
+    TableProvider -->|provides tables to| Expression
+    IbisConnection -->|fetches typed rows from| IbisTable
+    ChecksumBuckets -->|incremental inputs to| IncrementalExpression
+    IncrementalExpression -->|is a| Expression
+    BucketedInputsExpression -->|is a| IncrementalExpression
+    RevertibleTableExpression -->|can revert| Expression
+```
+
+| Class                       | Purpose |
+|-----------------------------|---|
+| `IbisSchema`                | Base class for typed table schemas (attrs frozen dataclass) |
+| `IbisTable[S]`              | Generic typed wrapper around `ibis.Table` |
+| `Expression`                | Abstract base for typed ibis transforms |
+| `IbisConnection`            | Typed backend wrapper: `fetch_table()`, `evaluate()`, `read/write_parquet()` |
+| `BucketedInputsExpression`  | Expression that only re-runs for changed input buckets |
+| `ChecksumBuckets`           | Checksum-based incremental input tracking |
+| `RevertibleTableExpression` | Transform that can undo itself back to the original schema |
+
+## Type aliases
+
+Declare schema fields using column-type aliases from `ibis_typing.it`:
+
+```python
+from ibis_typing import it
+
+it.Int8, it.Int16, it.Int32, it.Int64
+it.Float32, it.Float64
+it.Boolean
+it.String, it.Binary
+it.Decimal
+it.Date, it.Time, it.Timestamp
+it.UUID, it.JSON
+it.Array[it.Int64]
+it.Map[it.String, it.Float64]
+it.Struct[MyTypedDict]
+```
+
+## Table operations
+
+Use the infix `@` operator for composable, typed table transforms:
+
+```python
+from ibis_typing import IbisSchema, IbisTable, this, it
+
+@frozen
+class InputSchema(IbisSchema):
+    a: it.Float64 = None
+    b: it.Float64 = None
+    category: it.String = None
+    amount: it.Float64 = None
+    key: it.String = None
+
+
+inputs: IbisTable[InputSchema] = ...
+other_table: IbisTable = ...
+cols = InputSchema.cols
+
+table = InputSchema.of(
+    inputs.table
+    @ it.Select(cols.a, cols.b, expr={"c": this[cols.a] + this[cols.b]})
+    @ it.Aggregate(by=[cols.category], sum=[cols.amount])
+    @ it.InnerJoin(other_table.table, keys=[cols.key])
+)
+```
+
+## Pytest fixtures
+
+The following fixtures are auto-registered via the pytest plugin entry point (no `conftest.py` needed):
+
+| Fixture | Purpose |
+|---|---|
+| `evaluate_table` | Runs an `Expression`, returns `(actual, expected)` row lists |
+| `fetch_table` | Fetches rows from an `IbisTable` via DuckDB |
+| `ibis_connection` | Provides a DuckDB-backed `IbisConnection` |
+
+## Extras
+
+- **`ibis_typing.type_patch`** — patches installed ibis with typed `@overload` stubs for `ibis.ifelse`, `ibis.cases`, `ibis.coalesce`, etc.
+- **`ibis_typing.schema_writer`** — code-gen: write `IbisSchema` `.py` files from `Expression` output schemas
+- **`ibis_typing.plot`** — plots the dependency graph of an `Expression` using matplotlib/graphviz
+- **`ibis_typing.custom`** — custom ibis operations: `DateAddMonth`, `DateAddDay`, `ColumnChecksum`, `JsonParse`, `JsonFormat`, `UUIDFromInt`, `LuhnCheck`
+
+## Contributing
+
+```bash
+git clone https://github.com/FortnoxAB/ibis-typing
+cd ibis-typing
+uv sync --all-extras
+uv run python -m ibis_typing.type_patch
+make test
+```
+
+Pull requests welcome. Please run `make` before submitting.
+
+## License
+
+[MIT](LICENSE)

ibis_typing-1.0.0/ibis_typing/__init__.py

@@ -0,0 +1,30 @@
+"""Facade for collected ibis-typing imports."""
+
+from ibis.expr import datatypes as dt
+
+# ruff: noqa  # Ensure no cyclical imports
+from .fixtures.patch_target import PatchTarget
+from .ibis_adapter import IbisDbSchema, IbisSchema, IbisTable, this
+from .ibis_connection import IbisConnection
+from .expression import Expression
+from .revertible import RevertibleTableExpression
+from .checksum_buckets import (
+    ChecksumBuckets,
+    BucketedInputsExpression,
+    IncrementalExpression,
+)
+
+__all__ = [
+    "BucketedInputsExpression",
+    "ChecksumBuckets",
+    "Expression",
+    "IbisConnection",
+    "IbisDbSchema",
+    "IbisSchema",
+    "IbisTable",
+    "IncrementalExpression",
+    "PatchTarget",
+    "RevertibleTableExpression",
+    "dt",
+    "this",
+]

ibis_typing-1.0.0/ibis_typing/checksum_buckets.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import functools
+import operator
+from collections.abc import Sequence
+from typing import ClassVar
+
+from attrs import frozen
+
+from . import ibis_types as it
+from .expression import (
+    Expression,
+    GenericExpression,
+    TableExpression,
+)
+from .ibis_adapter import IbisSchema, IbisTable, this
+from .ibis_extension_method import deferred
+from .ibis_joins import LeftJoin, OuterJoin
+from .ibis_ops import ColumnChecksum
+from .ibis_time import TimestampNow
+from .ibis_utils import Aggregate
+
+__all__ = [
+    "BucketedInputsExpression",
+    "BucketedInputsParams",
+    "ChecksumBuckets",
+    "ChecksumParams",
+    "IncrementalExpression",
+]
+
+
+@frozen
+class IncrementalParams:
+    group_by: Sequence[it.NameOrType]
+    updated_at_col: it.Timestamp = "checksum_updated_at"  # type: ignore
+
+
+@frozen(kw_only=True)
+class ChecksumParams(IncrementalParams):
+    inputs: type[IbisSchema]
+    checksum_col: it.Int64 = "checksum"  # type: ignore
+
+
+@frozen(kw_only=True)
+class BucketedInputsParams(IncrementalParams):
+    buckets: type[ChecksumBuckets]
+
+
+class IncrementalExpression(Expression):
+    """Expressions that can be updated incrementally."""
+
+    incremental_params: ClassVar[IncrementalParams]
+
+
+class BucketedInputsExpression(IncrementalExpression):
+    """Base class for implementing IncrementalExpressions.
+
+    On incremental updates,
+    the expression is only provided inputs from updated ChecksumBuckets.
+    """
+
+    incremental_params: ClassVar[BucketedInputsParams]  # constant
+
+    @classmethod
+    def get_parameter_schema_types(cls):
+        # Replace plain IbisTable[Inputs] with IbisTable[BucketedInputs] variant.
+        params = super().get_parameter_schema_types()
+        buckets = cls.incremental_params.buckets
+        inputs = buckets.incremental_params.inputs
+
+        bucketed_inputs = BucketedInputsTableExpression(buckets).as_expression_schema()
+
+        if inputs not in params.values():
+            raise TypeError(f"{cls.__name__} lacks {ChecksumBuckets.__name__} input.")
+
+        return {
+            name: bucketed_inputs if issubclass(schema, inputs) else schema
+            for name, schema in params.items()
+        }
+
+
+@frozen
+class ChecksumBucketsTableExpression(TableExpression):
+    params: ChecksumParams
+
+    @property
+    def input_schemas(self):
+        return {"inputs": self.params.inputs, "timestamp": TimestampNow}
+
+    def __call__(self, inputs: IbisTable, timestamp: IbisTable[TimestampNow]):
+        args = self.params
+        checksums = [
+            this[col_name] @ ColumnChecksum()
+            for col_name in sorted(inputs.table.columns)
+            if col_name not in args.group_by
+        ]
+        return (
+            inputs.table
+            @ Aggregate(
+                by=args.group_by,
+                expr={args.checksum_col: functools.reduce(operator.xor, checksums)},
+            )
+            @ deferred.join(timestamp.table)
+            .rename({args.updated_at_col: timestamp.cols.timestamp})
+            .relocate(args.updated_at_col, before=args.checksum_col)
+        )
+
+
+class ChecksumBuckets(IncrementalExpression, GenericExpression):
+    """Checksum for inputs grouped by specific key columns."""
+
+    incremental_params: ClassVar[ChecksumParams]  # constant
+
+    @classmethod
+    def get_table_expression(cls):
+        return ChecksumBucketsTableExpression(cls.incremental_params)
+
+    @classmethod
+    def construct_increment[E: ChecksumBuckets](
+        cls: type[E],
+        buckets: IbisTable[E],
+        prior: IbisTable[E],
+        timestamp: IbisTable[TimestampNow],
+    ) -> IbisTable[E]:
+        """Calculate updated ChecksumBuckets table."""
+        args = cls.incremental_params
+
+        table = (
+            buckets.table
+            @ OuterJoin(prior.table, keys=args.group_by)
+            @ deferred.fill_null({args.checksum_col: 0})
+            .filter(
+                ~this[args.checksum_col].identical_to(
+                    this[f"{args.checksum_col}_right"]
+                )
+            )
+            .join(timestamp.table)
+            .rename({args.updated_at_col: timestamp.cols.timestamp})
+            .relocate(args.updated_at_col, before=args.checksum_col)
+            .select(buckets.table.columns)
+        )
+
+        return cls.of(table)
+
+
+@frozen
+class ChecksumBucketsIncrementTableExpression(TableExpression):
+    buckets: type[ChecksumBuckets]
+    target: type[IncrementalExpression]
+
+    @property
+    def input_schemas(self):
+        return {"buckets": self.buckets, "target": self.target}
+
+    def __call__(self, buckets: IbisTable, target: IbisTable):
+        target_updated_at = self.target.incremental_params.updated_at_col
+        bucket_updated_at = self.buckets.incremental_params.updated_at_col
+
+        is_updated = this[bucket_updated_at] > target.table[target_updated_at].max()
+
+        return buckets.table.filter(is_updated)
+
+    @property
+    def generated_class_name(self) -> str:
+        return f"{self.buckets.__name__}Increment"
+
+
+@frozen
+class BucketedInputsTableExpression(TableExpression):
+    buckets: type[ChecksumBuckets]
+
+    @property
+    def input_schemas(self):
+        inputs = self.buckets.incremental_params.inputs
+        return {"buckets": self.buckets, "inputs": inputs}
+
+    def __call__(self, buckets: IbisTable, inputs: IbisTable):
+        args = self.buckets.incremental_params
+        return (
+            buckets.table
+            @ LeftJoin(
+                inputs.table,
+                keys=args.group_by,
+            )
+            @ deferred.drop(args.checksum_col)
+        )
+
+    @property
+    def generated_class_name(self) -> str:
+        inputs = self.buckets.incremental_params.inputs
+        return f"{inputs.__name__}BucketedInputs"