splink 4.0.16__tar.gz → 5.0.0.dev2__tar.gz

{splink-4.0.16 → splink-5.0.0.dev2}/.gitignore

@@ -163,6 +163,8 @@ cython_debug/
 
 *.parquet
 *.csv
+*.json
+
 
 # html files opt-in only
 *.html
@@ -177,5 +179,6 @@ cython_debug/
 splink_db
 splink_db_log
 spark-warehouse
+*.ddb*
 
 scripts/pyspelling/dictionary.dic

{splink-4.0.16 → splink-5.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splink
-Version: 4.0.16
+Version: 5.0.0.dev2
 Summary: Fast probabilistic data linkage at scale
 Project-URL: Homepage, https://github.com/moj-analytical-services/splink
 Project-URL: Repository, https://github.com/moj-analytical-services/splink
@@ -13,18 +13,18 @@ Requires-Dist: altair>=5.0.1
 Requires-Dist: duckdb>=0.9.2
 Requires-Dist: igraph>=0.11.2
 Requires-Dist: jinja2>=3.0.3
-Requires-Dist: numpy>=1.19.3
-Requires-Dist: pandas>=1.3.5
 Requires-Dist: sqlglot>=17.6.0
-Provides-Extra: athena
-Requires-Dist: awswrangler; extra == 'athena'
 Provides-Extra: postgres
 Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgres'
 Requires-Dist: sqlalchemy>=2.0.0; extra == 'postgres'
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow>=15.0.0; extra == 'pyarrow'
 Provides-Extra: pyspark
 Requires-Dist: pyspark>=3.5.0; extra == 'pyspark'
 Provides-Extra: spark
 Requires-Dist: pyspark>=3.5.0; extra == 'spark'
+Provides-Extra: sqlite
+Requires-Dist: rapidfuzz>=3.10.0; extra == 'sqlite'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -50,7 +50,7 @@ It is used widely by within government, academia and the private sector - see [u
 
 ⚡ **Speed:** Capable of linking a million records on a laptop in around a minute.<br>
 🎯 **Accuracy:** Support for term frequency adjustments and user-defined fuzzy matching logic.<br>
-🌐 **Scalability:** Execute linkage in Python (using DuckDB) or big-data backends like AWS Athena or Spark for 100+ million records.<br>
+🌐 **Scalability:** Execute linkage in Python (using DuckDB) or big-data backends like Spark for 100+ million records.<br>
 🎓 **Unsupervised Learning:** No training data is required for model training.<br>
 📊 **Interactive Outputs:** A suite of interactive visualisations help users understand their model and diagnose problems.<br>
 
@@ -104,7 +104,7 @@ conda install -c conda-forge splink
 ### Installing Splink for Specific Backends
 
 
-For projects requiring specific backends, Splink offers optional installations for **Spark**, **Athena**, and **PostgreSQL**. These can be installed by appending the backend name in brackets to the pip install command:
+For projects requiring specific backends, Splink offers optional installations for **Spark** and **PostgreSQL**. These can be installed by appending the backend name in brackets to the pip install command:
 ```sh
 pip install 'splink[{backend}]'
 ```
@@ -117,11 +117,6 @@ pip install 'splink[{backend}]'
 pip install 'splink[spark]'
 ```
 
-#### Athena
-```sh
-pip install 'splink[athena]'
-```
-
 #### PostgreSQL
 ```sh
 pip install 'splink[postgres]'

{splink-4.0.16 → splink-5.0.0.dev2}/README.md

@@ -21,7 +21,7 @@ It is used widely by within government, academia and the private sector - see [u
 
 ⚡ **Speed:** Capable of linking a million records on a laptop in around a minute.<br>
 🎯 **Accuracy:** Support for term frequency adjustments and user-defined fuzzy matching logic.<br>
-🌐 **Scalability:** Execute linkage in Python (using DuckDB) or big-data backends like AWS Athena or Spark for 100+ million records.<br>
+🌐 **Scalability:** Execute linkage in Python (using DuckDB) or big-data backends like Spark for 100+ million records.<br>
 🎓 **Unsupervised Learning:** No training data is required for model training.<br>
 📊 **Interactive Outputs:** A suite of interactive visualisations help users understand their model and diagnose problems.<br>
 
@@ -75,7 +75,7 @@ conda install -c conda-forge splink
 ### Installing Splink for Specific Backends
 
 
-For projects requiring specific backends, Splink offers optional installations for **Spark**, **Athena**, and **PostgreSQL**. These can be installed by appending the backend name in brackets to the pip install command:
+For projects requiring specific backends, Splink offers optional installations for **Spark** and **PostgreSQL**. These can be installed by appending the backend name in brackets to the pip install command:
 ```sh
 pip install 'splink[{backend}]'
 ```
@@ -88,11 +88,6 @@ pip install 'splink[{backend}]'
 pip install 'splink[spark]'
 ```
 
-#### Athena
-```sh
-pip install 'splink[athena]'
-```
-
 #### PostgreSQL
 ```sh
 pip install 'splink[postgres]'

{splink-4.0.16 → splink-5.0.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "splink"
-version = "4.0.16"
+version = "5.0.0.dev2"
 description = "Fast probabilistic data linkage at scale"
 authors = [
     { name = "Robin Linacre", email = "robinlinacre@hotmail.com" },
@@ -14,42 +14,47 @@ requires-python = ">=3.9.0,<4.0.0"
 readme = "README.md"
 license = "MIT"
 dependencies = [
-    "pandas>=1.3.5",
     "duckdb>=0.9.2",
     "sqlglot>=17.6.0",
     "altair>=5.0.1",
     "Jinja2>=3.0.3",
-    "numpy>=1.19.3",
     "igraph>=0.11.2",
 ]
 
 [project.optional-dependencies]
 pyspark = ["pyspark>=3.5.0"]
 spark = ["pyspark>=3.5.0"]
-athena = ["awswrangler"]
+# sqlite doesn't _require_ this functionality, but it's used if we want to use fuzzy levels
+sqlite = ["rapidfuzz>=3.10.0"]
 postgres = ["sqlalchemy>=2.0.0", "psycopg2-binary>=2.9.0"]
+pyarrow = ["pyarrow>=15.0.0"]
+# TODO: pandas optional
 
 [project.urls]
 Homepage = "https://github.com/moj-analytical-services/splink"
 Repository = "https://github.com/moj-analytical-services/splink"
 
 [dependency-groups]
-# dummy 'core' group to allow us to declare conflict with athena
-# awswrangler upper-pins packages including pyarrow, so ruins our resolution otherwise
-# additionally allows us to easily check package functionality with just these installed
+# allows us to easily check package functionality with just these installed
 # (and not the rest of our required dependencies)
-core = ["sqlglot", "pandas"]
+core = ["sqlglot", "duckdb"]
 demos = [
     "ipywidgets>=8.1.7",
+    "jupytext>=1.18.1",
     "nbmake>=1.5.5",
+    "pseudopeople>=1.2.6",
     "pytest-xdist>=3.6.1",
 ]
+# dev deliberately doesn't include spark, so we can opt in to different spark versions
 dev = [
-    "tabulate>=0.8.9",
-    "pyspark>=3.5.0",
-    "sqlalchemy>=2.0.0",
-    "psycopg2-binary>=2.9.0",
+    { "include-group" = "linting" },
+    { "include-group" = "testing-core" },
+    { "include-group" = "typechecking" },
 ]
+spark-3 = [
+  "pyspark<4; python_version < '3.12'",
+]
+spark-4 = ["pyspark>=4.0.0"]
 docs = [
     "griffe>=1.4.0",
     # keep jinja2 relaxed so it doesn't constrain us in rest of dev
@@ -68,32 +73,45 @@ docs = [
     "pymdown-extensions>=10.15",
 ]
 linting = ["ruff>=0.4.2,<0.5"]
-testing = [
+pandas = ["pandas>=1.3.5", "numpy>=1.19.3"]
+postgres = [
+    "psycopg2-binary>=2.9.0",
+    "sqlalchemy>=2.0.0",
+]
+sqlite = [
+    "rapidfuzz>=3.10.0",
+]
+testing-core = [
     "pytest>=7.3",
-    "pyarrow>=7.0.0",
+    "pyarrow>=15.0.0",
     "networkx>=2.5.1",
-    "rapidfuzz>=3.0.0",
     "pytest-cov>=5.0.0",
+    { "include-group" = "postgres" },
+    { "include-group" = "sqlite" },
+    # TODO: temporary measure until we can depanda tests
+    { "include-group" = "pandas" },
+]
+testing = [
+    { "include-group" = "testing-core" },
+    { "include-group" = "spark-4" },
 ]
 typechecking = ["mypy==1.9.0"]
+# we will migrate to ty, but won't happen all at once, so run in parallel
+typechecking-dev = [
+    "ty>=0.0.21",
+]
 
 [tool.uv]
 default-groups = [
-    "core",
     "dev",
-    "linting",
-    "testing",
-    "typechecking",
+    "spark-4"
 ]
 conflicts = [
   [
-    { group = "core" },
-    { extra = "athena" }
+    { group = "spark-4" },
+    { group = "spark-3" },
   ]
 ]
-# problematic constraints, and we do not test or otherwise use this
-# we are removing in Splink 5 anyway
-exclude-dependencies = ["awswrangler"]
 
 [tool.uv.dependency-groups]
 docs = { requires-python = ">=3.13" }
@@ -130,6 +148,13 @@ lint.ignore = [
     "B006", # Do not use mutable data structures for argument defaults"
 ]
 
+# really we want to lint docs with a looser set of rules (such as not enforcing the same line length)
+# for now we simply exclude
+exclude = [
+    "docs",
+]
+
+
 [tool.pytest.ini_options]
 addopts = ["-m default"]
 markers = [
@@ -147,6 +172,8 @@ markers = [
     "sqlite_only",
     "postgres",
     "postgres_only",
+# optional dependendencies beyond backends
+    "needs_pandas",
 ]
 
 [tool.mypy]

{splink-4.0.16 → splink-5.0.0.dev2}/splink/__init__.py

@@ -56,7 +56,7 @@ def __getattr__(name):
     raise AttributeError(f"module 'splink' has no attribute '{name}'") from None
 
 
-__version__ = "4.0.16"
+__version__ = "5.0.0.dev2"
 
 
 __all__ = [

{splink-4.0.16 → splink-5.0.0.dev2}/splink/internals/accuracy.py

@@ -422,7 +422,6 @@ def predictions_from_sample_of_pairwise_labels_sql(linker, labels_tablename):
     sqls_2 = predict_from_comparison_vectors_sqls_using_settings(
         linker._settings_obj,
         include_clerical_match_score=True,
-        sql_infinity_expression=linker._infinity_expression,
     )
 
     sqls.extend(sqls_2)

{splink-4.0.16 → splink-5.0.0.dev2}/splink/internals/blocking.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import time
 from typing import TYPE_CHECKING, Any, List, Literal, Optional, TypedDict
 
 from sqlglot import parse_one
@@ -9,6 +10,7 @@ from sqlglot.optimizer.eliminate_joins import join_condition
 from sqlglot.optimizer.optimizer import optimize
 from sqlglot.optimizer.simplify import flatten
 
+from splink.internals.chunking import _chunk_assignment_sql
 from splink.internals.database_api import DatabaseAPISubClass
 from splink.internals.dialects import SplinkDialect
 from splink.internals.input_column import InputColumn
@@ -38,7 +40,6 @@ backend_link_type_options = Literal[
 class BlockingRuleDict(TypedDict):
     blocking_rule: str
     sql_dialect: str
-    salting_partitions: int | None
     arrays_to_explode: list[str] | None
 
 
@@ -52,19 +53,8 @@ def blocking_rule_to_obj(br: BlockingRule | BlockingRuleDict) -> BlockingRule:
         sql_dialect_str = br.get("sql_dialect", None)
         if sql_dialect_str is None:
             raise ValueError("Must provide a valid sql_dialect")
-        salting_partitions = br.get("salting_partitions", None)
-        arrays_to_explode = br.get("arrays_to_explode", None)
-
-        if arrays_to_explode is not None and salting_partitions is not None:
-            raise ValueError(
-                "Splink does not support blocking rules that are "
-                " both salted and exploding"
-            )
 
-        if salting_partitions is not None:
-            return SaltedBlockingRule(
-                blocking_rule, sql_dialect_str, salting_partitions
-            )
+        arrays_to_explode = br.get("arrays_to_explode", None)
 
         if arrays_to_explode is not None:
             return ExplodingBlockingRule(
@@ -97,7 +87,6 @@ def _columns_needed_for_blocking(
     )
 
     for br in blocking_rules:
-        # Preserve first-seen column order so the projected blocking SQL is stable.
         parsed_columns = parse_columns_in_sql(
             br.blocking_rule_sql, sqlglot_dialect=br.sqlglot_dialect
         )
@@ -125,9 +114,13 @@ class BlockingRule:
         self.preceding_rules: List[BlockingRule] = []
 
     @property
-    def sqlglot_dialect(self):
+    def sqlglot_dialect(self) -> str:
         return SplinkDialect.from_string(self._sql_dialect_str).sqlglot_dialect
 
+    @property
+    def sql_dialect(self) -> SplinkDialect:
+        return SplinkDialect.from_string(self._sql_dialect_str)
+
     def _input_column(self, name: str) -> InputColumn:
         """Create an InputColumn with this blocking rule's dialect."""
         return InputColumn(name, sqlglot_dialect_str=self.sqlglot_dialect)
@@ -316,70 +309,6 @@ class BlockingRule:
         return f"{self.descr} blocking rule using SQL: {sql}"
 
 
-class SaltedBlockingRule(BlockingRule):
-    def __init__(
-        self,
-        blocking_rule: str,
-        sqlglot_dialect: str,
-        salting_partitions: int = 1,
-    ):
-        if salting_partitions is None or salting_partitions <= 1:
-            raise ValueError("Salting partitions must be specified and > 1")
-
-        super().__init__(blocking_rule, sqlglot_dialect)
-        self.salting_partitions = salting_partitions
-
-    def as_dict(self):
-        output = super().as_dict()
-        output["salting_partitions"] = self.salting_partitions
-        return output
-
-    def _as_completed_dict(self):
-        return self.as_dict()
-
-    def _salting_condition(self, salt):
-        return f"AND ceiling(l.__splink_salt * {self.salting_partitions}) = {salt + 1}"
-
-    def create_blocked_pairs_sql(
-        self,
-        *,
-        source_dataset_input_column: Optional[InputColumn],
-        unique_id_input_column: InputColumn,
-        input_tablename_l: str,
-        input_tablename_r: str,
-        where_condition: str,
-    ) -> str:
-        if source_dataset_input_column:
-            unique_id_columns = [source_dataset_input_column, unique_id_input_column]
-        else:
-            unique_id_columns = [unique_id_input_column]
-
-        uid_l_expr = _composite_unique_id_from_nodes_sql(unique_id_columns, "l")
-        uid_r_expr = _composite_unique_id_from_nodes_sql(unique_id_columns, "r")
-
-        sqls = []
-        exclude_sql = self.exclude_pairs_generated_by_all_preceding_rules_sql(
-            source_dataset_input_column, unique_id_input_column
-        )
-        for salt in range(self.salting_partitions):
-            salt_condition = self._salting_condition(salt)
-            sql = f"""
-            select
-            '{self.match_key}' as match_key,
-            {uid_l_expr} as join_key_l,
-            {uid_r_expr} as join_key_r
-            from {input_tablename_l} as l
-            inner join {input_tablename_r} as r
-            on
-            ({self.blocking_rule_sql} {salt_condition})
-            {where_condition}
-            {exclude_sql}
-            """
-
-            sqls.append(sql)
-        return " UNION ALL ".join(sqls)
-
-
 def _explode_arrays_sql(db_api, tbl_name, columns_to_explode, other_columns_to_retain):
     return db_api.sql_dialect.explode_arrays_sql(
         tbl_name, columns_to_explode, other_columns_to_retain
@@ -411,10 +340,18 @@ class ExplodingBlockingRule(BlockingRule):
         link_type: "LinkTypeLiteralType",
         input_tablename_l: str,
         input_tablename_r: str,
+        left_chunk: tuple[int, int] | None = None,
+        right_chunk: tuple[int, int] | None = None,
     ) -> str:
         """generates a table of the marginal id pairs from the exploded blocking rule
         i.e. pairs are only created that match this blocking rule and NOT any of
         the preceding blocking rules
+
+        Args:
+            left_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+                left side records.
+            right_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+                right side records.
         """
 
         unique_id_col = unique_id_input_column
@@ -422,7 +359,13 @@ class ExplodingBlockingRule(BlockingRule):
             source_dataset_input_column, unique_id_input_column
         )
 
-        where_condition = _sql_gen_where_condition(link_type, unique_id_input_columns)
+        where_condition = _sql_gen_where_condition(
+            link_type,
+            unique_id_input_columns,
+            left_chunk=left_chunk,
+            right_chunk=right_chunk,
+            sql_dialect=self.sql_dialect,
+        )
 
         id_expr_l = _composite_unique_id_from_nodes_sql(unique_id_input_columns, "l")
         id_expr_r = _composite_unique_id_from_nodes_sql(unique_id_input_columns, "r")
@@ -522,7 +465,17 @@ def materialise_exploded_id_tables(
     splink_df_dict: dict[str, SplinkDataFrame],
     source_dataset_input_column: Optional[InputColumn],
     unique_id_input_column: InputColumn,
+    left_chunk: tuple[int, int] | None = None,
+    right_chunk: tuple[int, int] | None = None,
 ) -> list[ExplodingBlockingRule]:
+    """Materialise exploded ID pair tables for exploding blocking rules.
+
+    Args:
+        left_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            left side records.
+        right_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            right side records.
+    """
     exploding_blocking_rules = [
         br for br in blocking_rules if isinstance(br, ExplodingBlockingRule)
     ]
@@ -573,9 +526,7 @@ def materialise_exploded_id_tables(
             pipeline.enqueue_sql(expl_sql_r, input_tablename_r)
         else:
             sql = vertically_concatenate_sql(
-                splink_df_dict,
-                salting_required=False,
-                source_dataset_input_column=source_dataset_input_column,
+                splink_df_dict, source_dataset_input_column=source_dataset_input_column
             )
             pipeline.enqueue_sql(sql, "__splink__df_concat")
 
@@ -603,6 +554,8 @@ def materialise_exploded_id_tables(
             link_type=link_type,
             input_tablename_l=input_tablename_l,
             input_tablename_r=input_tablename_r,
+            left_chunk=left_chunk,
+            right_chunk=right_chunk,
         )
 
         pipeline.enqueue_sql(sql, table_name)
@@ -614,8 +567,107 @@ def materialise_exploded_id_tables(
     return exploding_blocking_rules
 
 
+def compute_blocked_pairs_from_concat_with_tf(
+    *,
+    pipeline: CTEPipeline,
+    db_api: DatabaseAPISubClass,
+    splink_df_dict: dict[str, SplinkDataFrame],
+    blocking_rules: list[BlockingRule],
+    link_type: "LinkTypeLiteralType",
+    source_dataset_input_column: Optional[InputColumn],
+    unique_id_input_column: InputColumn,
+    df_concat_with_tf_table_name: str = "__splink__df_concat_with_tf",
+    left_chunk: tuple[int, int] | None = None,
+    right_chunk: tuple[int, int] | None = None,
+) -> SplinkDataFrame:
+    """Compute __splink__blocked_id_pairs from df_concat_with_tf.
+
+    Enqueues SQL to the pipeline, materialises the result, and cleans up
+    any exploded ID pair tables used by exploding blocking rules.
+
+    Args:
+        left_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            left side records.
+        right_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            right side records.
+
+    Returns:
+        SplinkDataFrame: The materialised blocked pairs table.
+    """
+    start_time = time.time()
+
+    blocking_input_tablename_l = df_concat_with_tf_table_name
+    blocking_input_tablename_r = df_concat_with_tf_table_name
+    effective_link_type = link_type
+
+    # Optimisation for 2-dataset link_only
+    if len(splink_df_dict) == 2 and link_type == "link_only":
+        if not source_dataset_input_column:
+            raise ValueError(
+                "link_type='link_only' with two input tables requires a "
+                "source_dataset column"
+            )
+
+        input_columns = _columns_needed_for_blocking(
+            blocking_rules=blocking_rules,
+            source_dataset_input_column=source_dataset_input_column,
+            unique_id_input_column=unique_id_input_column,
+        )
+        left_sql, right_sql = select_two_dataset_link_only_input_tables_sqls(
+            splink_df_dict,
+            input_columns=input_columns,
+            source_dataset_input_column=source_dataset_input_column,
+        )
+        pipeline.enqueue_sql(left_sql, f"{df_concat_with_tf_table_name}_left")
+        pipeline.enqueue_sql(right_sql, f"{df_concat_with_tf_table_name}_right")
+
+        blocking_input_tablename_l = f"{df_concat_with_tf_table_name}_left"
+        blocking_input_tablename_r = f"{df_concat_with_tf_table_name}_right"
+        effective_link_type = "two_dataset_link_only"
+
+    materialise_exploded_id_tables(
+        link_type=effective_link_type,
+        blocking_rules=blocking_rules,
+        db_api=db_api,
+        splink_df_dict=splink_df_dict,
+        source_dataset_input_column=source_dataset_input_column,
+        unique_id_input_column=unique_id_input_column,
+        left_chunk=left_chunk,
+        right_chunk=right_chunk,
+    )
+
+    sqls = block_using_rules_sqls(
+        input_tablename_l=blocking_input_tablename_l,
+        input_tablename_r=blocking_input_tablename_r,
+        blocking_rules=blocking_rules,
+        link_type=effective_link_type,
+        source_dataset_input_column=source_dataset_input_column,
+        unique_id_input_column=unique_id_input_column,
+        left_chunk=left_chunk,
+        right_chunk=right_chunk,
+    )
+
+    pipeline.enqueue_list_of_sqls(sqls)
+
+    blocked_pairs = db_api.sql_pipeline_to_splink_dataframe(pipeline)
+
+    # Clean up exploded ID pair tables
+    for br in blocking_rules:
+        if isinstance(br, ExplodingBlockingRule):
+            br.drop_materialised_id_pairs_dataframe()
+
+    blocking_time = time.time() - start_time
+    logger.info(f"Blocking time: {blocking_time:.2f} seconds")
+
+    return blocked_pairs
+
+
 def _sql_gen_where_condition(
-    link_type: backend_link_type_options, unique_id_cols: List[InputColumn]
+    link_type: backend_link_type_options,
+    unique_id_cols: List[InputColumn],
+    left_chunk: tuple[int, int] | None = None,
+    right_chunk: tuple[int, int] | None = None,
+    sql_dialect: "SplinkDialect | None" = None,
 ) -> str:
     id_expr_l = _composite_unique_id_from_nodes_sql(unique_id_cols, "l")
     id_expr_r = _composite_unique_id_from_nodes_sql(unique_id_cols, "r")
@@ -631,6 +683,19 @@ def _sql_gen_where_condition(
             f"and l.{source_dataset_col.name} != r.{source_dataset_col.name}"
         )
 
+    # Add chunk filtering if specified
+    if left_chunk is not None and sql_dialect is not None:
+        chunk_num, total_chunks = left_chunk
+        where_condition += _chunk_assignment_sql(
+            unique_id_cols, chunk_num, total_chunks, "l", sql_dialect
+        )
+
+    if right_chunk is not None and sql_dialect is not None:
+        chunk_num, total_chunks = right_chunk
+        where_condition += _chunk_assignment_sql(
+            unique_id_cols, chunk_num, total_chunks, "r", sql_dialect
+        )
+
     return where_condition
 
 
@@ -642,6 +707,8 @@ def block_using_rules_sqls(
     link_type: "LinkTypeLiteralType",
     source_dataset_input_column: Optional[InputColumn],
     unique_id_input_column: InputColumn,
+    left_chunk: tuple[int, int] | None = None,
+    right_chunk: tuple[int, int] | None = None,
 ) -> list[dict[str, str]]:
     """Use the blocking rules specified in the linker's settings object to
     generate a SQL statement that will create pairwise record comparions
@@ -649,6 +716,13 @@ def block_using_rules_sqls(
 
     Where there are multiple blocking rules, the SQL statement contains logic
     so that duplicate comparisons are not generated.
+
+    Args:
+        left_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            left side records. Requires dialect to be provided.
+        right_chunk: Optional tuple of (chunk_number, total_chunks) for filtering
+            right side records. Requires dialect to be provided.
+        dialect: SQL dialect, required when using chunking parameters.
     """
 
     sqls = []
@@ -657,7 +731,15 @@ def block_using_rules_sqls(
         source_dataset_input_column, unique_id_input_column
     )
 
-    where_condition = _sql_gen_where_condition(link_type, unique_id_input_columns)
+    sql_dialect = blocking_rules[0].sql_dialect if blocking_rules else None
+
+    where_condition = _sql_gen_where_condition(
+        link_type,
+        unique_id_input_columns,
+        left_chunk=left_chunk,
+        right_chunk=right_chunk,
+        sql_dialect=sql_dialect,
+    )
 
     # Cover the case where there are no blocking rules
     # This is a bit of a hack where if you do a self-join on 'true'