sqlbuild 0.48.2__tar.gz → 0.48.4__tar.gz

sqlbuild-0.48.4/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.48.4"
+}

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.48.4](https://github.com/chio-labs/sqlbuild/compare/v0.48.3...v0.48.4) (2026-08-01)
+
+
+### Bug Fixes
+
+* **sqlserver:** type loader cursor delete bounds ([79c2213](https://github.com/chio-labs/sqlbuild/commit/79c221364f83612f3cdd512e4fe9852e1f4d01f8))
+* **sqlserver:** type loader cursor delete bounds ([7a53481](https://github.com/chio-labs/sqlbuild/commit/7a534813859723e331214476a00c6c38fce0b7f4))
+
+## [0.48.3](https://github.com/chio-labs/sqlbuild/compare/v0.48.2...v0.48.3) (2026-08-01)
+
+
+### Bug Fixes
+
+* **sqlserver:** harden test SQL and cursor bounds ([d73edbf](https://github.com/chio-labs/sqlbuild/commit/d73edbf77d1c8239fd6d300c7b5fb9c24ef4e0b5))
+* **sqlserver:** harden test SQL and cursor bounds ([8e5fb24](https://github.com/chio-labs/sqlbuild/commit/8e5fb24bbadac12d67ccd833920b707e22243c0d))
+
 ## [0.48.2](https://github.com/chio-labs/sqlbuild/compare/v0.48.1...v0.48.2) (2026-07-31)
 
 

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.48.2
+Version: 0.48.4
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.48.2"
+version = "0.48.4"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -437,6 +437,7 @@ class BaseAdapter(StrictAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         delete_sql: str = (
             f"DELETE FROM {destination} "
@@ -1338,6 +1339,7 @@ class BaseAdapter(StrictAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -1346,6 +1348,7 @@ class BaseAdapter(StrictAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         with self.transaction(connection):

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -1526,6 +1526,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         delete_sql: str = (
             f"DELETE FROM {destination} "
@@ -1815,6 +1816,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -1823,6 +1825,7 @@ class DuckDbBackedAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         with self.transaction(connection):

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapter/contract/classes/materialization.py

@@ -169,6 +169,7 @@ class MaterializationMixin(ABC):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         """Delete rows by cursor range then insert from a SELECT statement."""
         ...

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapter/contract/classes/strict_adapter.py

@@ -238,6 +238,7 @@ class StrictAdapter(
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         """Render SQL statements for cursor-bounded delete-insert."""
         ...

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -1620,6 +1620,7 @@ class BigQueryAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         insert_clause: str = "INSERT ROW"
         if columns is not None:
@@ -2140,6 +2141,7 @@ class BigQueryAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         if columns is None:
             columns = self.query_column_names(connection=connection, sql=sql)
@@ -2150,6 +2152,7 @@ class BigQueryAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         statement: str

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -1632,6 +1632,7 @@ class DatabricksAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         column_list: str = ""
         if columns is not None:
@@ -1988,6 +1989,7 @@ class DatabricksAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -1996,6 +1998,7 @@ class DatabricksAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         statement: str

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapters/postgres/classes/postgres_adapter.py

@@ -455,6 +455,7 @@ class PostgresAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         quoted_cursor_column: str = self.render_identifier(cursor_column)
         delete_sql: str = (
@@ -913,6 +914,7 @@ class PostgresAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -921,6 +923,7 @@ class PostgresAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         with self.transaction(connection):

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -557,6 +557,7 @@ class SnowflakeAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
         quoted_cursor_column: str = self.render_identifier(cursor_column)
         delete_sql: str = (
@@ -869,6 +870,7 @@ class SnowflakeAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -877,6 +879,7 @@ class SnowflakeAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         with self.transaction(connection):

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/adapters/sqlserver/classes/sqlserver_adapter.py

@@ -339,7 +339,7 @@ class SqlServerAdapter(BaseAdapter):
         self.execute(connection=connection, sql="COMMIT TRANSACTION")
 
     def rollback(self, connection: Any) -> None:
-        self.execute(connection=connection, sql="ROLLBACK TRANSACTION")
+        self.execute(connection=connection, sql="IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION")
 
     def default_schema(self) -> str:
         return "dbo"
@@ -932,7 +932,9 @@ class SqlServerAdapter(BaseAdapter):
     def render_cursor_bound_literal(self, *, value: str, cursor_type: str | None) -> str:
         if cursor_type == CursorKind.INTEGER:
             return value
-        return f"'{value}'"
+        if cursor_type == CursorKind.TIMESTAMP:
+            return f"CAST({self._quote_sql_string(value)} AS DATETIME2(6))"
+        return self._quote_sql_string(value)
 
     def describe_relation(self, *, connection: Any, relation: str) -> tuple[ColumnInfo, ...]:
         parts: list[str] = [part.strip("[]") for part in relation.split(".")]
@@ -1182,6 +1184,7 @@ class SqlServerAdapter(BaseAdapter):
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
         statement_recorder: StatementRecorder,
+        cursor_type: str | None = None,
     ) -> None:
         statements: tuple[str, ...] = self.render_delete_insert_cursor(
             destination=destination,
@@ -1190,6 +1193,7 @@ class SqlServerAdapter(BaseAdapter):
             cursor_start=cursor_start,
             cursor_end=cursor_end,
             columns=columns,
+            cursor_type=cursor_type,
         )
         statement_recorder.record_many(statements)
         with self.transaction(connection):
@@ -2011,11 +2015,18 @@ class SqlServerAdapter(BaseAdapter):
         cursor_start: str,
         cursor_end: str,
         columns: tuple[str, ...] | None = None,
+        cursor_type: str | None = None,
     ) -> tuple[str, ...]:
+        start_literal: str = self.render_cursor_bound_literal(
+            value=cursor_start, cursor_type=cursor_type
+        )
+        end_literal: str = self.render_cursor_bound_literal(
+            value=cursor_end, cursor_type=cursor_type
+        )
         delete_sql: str = (
             f"DELETE FROM {destination} "
-            f"WHERE {self.render_identifier(cursor_column)} >= '{cursor_start}' "
-            f"AND {self.render_identifier(cursor_column)} < '{cursor_end}'"
+            f"WHERE {self.render_identifier(cursor_column)} >= {start_literal} "
+            f"AND {self.render_identifier(cursor_column)} < {end_literal}"
         )
         insert_stmts: tuple[str, ...] = self.render_append(
             destination=destination, sql=sql, columns=columns

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/compiler/planner/_helpers/output/plan_entry.py

@@ -615,6 +615,7 @@ def plan_model_from_change(
         warehouse_columns=warehouse_columns,
         cursor_column=cursor_column,
         cursor_bounds=ddl_cursor_bounds,
+        cursor_type=cursor_type,
     )
 
     entry: ModelPlanEntry = ModelPlanEntry(
@@ -979,6 +980,7 @@ def _build_logical_ddl_from_adapter(
     warehouse_columns: tuple[ColumnInfo, ...],
     cursor_column: str | None = None,
     cursor_bounds: CursorBounds | None = None,
+    cursor_type: str | None = None,
 ) -> str:
     """Generate logical DDL using adapter render methods."""
 
@@ -1006,6 +1008,7 @@ def _build_logical_ddl_from_adapter(
                     cursor_column=cursor_column,
                     cursor_start=cursor_bounds.start,
                     cursor_end=cursor_bounds.end,
+                    cursor_type=cursor_type,
                 )
             )
         return ";\n\n".join(

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/compiler/planner/_helpers/sql_tests/assembly.py

@@ -55,6 +55,7 @@ _DBT_REF_PATTERN: re.Pattern[str] = re.compile(
     rf'{reference_call_prefix_pattern_text(SqlReferenceKind.DBT_REF)}"([^"]+)"'
     r'(?:,\s*"([^"]+)")?\)'
 )
+_LEADING_WITH_PATTERN: re.Pattern[str] = re.compile(r"^\s*WITH\b", re.IGNORECASE)
 
 
 def plan_test(
@@ -169,7 +170,6 @@ def plan_test(
             )
             if sql_analysis_sql is not None:
                 step_sql = sql_analysis_sql.resolved_sql
-                resolved_value = sql_analysis_sql.resolved_sql
                 sql_analysis_resolved[model_name] = sql_analysis_sql
                 reachable_mocks.update(sql_analysis_sql.reachable_mock_names)
 
@@ -191,26 +191,16 @@ def plan_test(
             )
         )
 
-    assertion_steps: list[SqlTestAssertionStep] = []
-    assertion_name: str
-    assertion_sql: str
-    for assertion_name, assertion_sql in assertion_map.items():
-        assertion_steps.append(
-            SqlTestAssertionStep(
-                name=assertion_name,
-                resolved_sql=_resolve_assertion_sql(
-                    sql=assertion_sql,
-                    resolved_chain=resolved,
-                    mock_refs=mock_refs,
-                    mock_sources=mock_sources,
-                    mock_seeds=mock_seeds,
-                    mock_dbt_refs=mock_dbt_refs,
-                    helper_ctes=helper_ctes,
-                    function_locations=function_locations,
-                    adapter=adapter,
-                ),
-            )
-        )
+    assertion_steps: tuple[SqlTestAssertionStep, ...] = _build_assertion_steps(
+        assertion_map=assertion_map,
+        test=test,
+        function_locations=function_locations,
+        helper_ctes=helper_ctes,
+        resolved_chain=resolved,
+        sql_analysis_resolved=sql_analysis_resolved,
+        adapter=adapter,
+        sql_analysis_enabled=sql_analysis_enabled,
+    )
 
     unreachable_ref: str
     for unreachable_ref in sorted(set(mock_refs) - reachable_mocks):
@@ -262,7 +252,7 @@ def plan_test(
         key=test.key,
         name=test.name,
         chain=tuple(chain_steps),
-        assertions=tuple(assertion_steps),
+        assertions=assertion_steps,
         scope_deps=test.scope_deps,
         function_deps=_dedupe_function_deps(function_deps),
         sql_analysis_enabled=sql_analysis_enabled,
@@ -270,6 +260,69 @@ def plan_test(
     return entry, tuple(warnings)
 
 
+def _build_assertion_steps(
+    *,
+    assertion_map: dict[str, str],
+    test: CompiledSqlTest,
+    function_locations: dict[str, CompiledRelationLocation],
+    helper_ctes: tuple[CompileSqlTestCte, ...],
+    resolved_chain: dict[str, str],
+    sql_analysis_resolved: dict[str, SqlAnalysisResolvedTestSql],
+    adapter: BaseAdapter,
+    sql_analysis_enabled: bool,
+) -> tuple[SqlTestAssertionStep, ...]:
+    mock_refs: dict[str, str] = _extract_mock_refs(test)
+    mock_sources: dict[str, str] = _extract_mock_sources(test)
+    mock_seeds: dict[str, str] = _extract_mock_seeds(test)
+    mock_dbt_refs: dict[str, str] = _extract_mock_dbt_refs(test)
+    assertion_steps: list[SqlTestAssertionStep] = []
+    assertion_name: str
+    assertion_sql: str
+    for assertion_name, assertion_sql in assertion_map.items():
+        resolved_assertion_sql: str | None = None
+        if sql_analysis_enabled:
+            analyzed_assertion_sql: SqlAnalysisResolvedTestSql | None = (
+                try_resolve_test_model_sql_with_sql_analysis(
+                    query_sql=assertion_sql,
+                    mock_refs=mock_refs,
+                    mock_sources=mock_sources,
+                    mock_seeds=mock_seeds,
+                    mock_dbt_refs=mock_dbt_refs,
+                    function_locations={
+                        name: target.qualified_name
+                        for name, target in function_locations.items()
+                        if target.qualified_name is not None
+                    },
+                    helper_ctes=helper_ctes,
+                    resolved_chain=sql_analysis_resolved,
+                    file_label=str(test.test_file.relative_path),
+                )
+            )
+            if analyzed_assertion_sql is not None and not _has_unresolved_test_reference(
+                analyzed_assertion_sql.resolved_sql
+            ):
+                resolved_assertion_sql = analyzed_assertion_sql.resolved_sql
+        if resolved_assertion_sql is None:
+            resolved_assertion_sql = _resolve_assertion_sql(
+                sql=assertion_sql,
+                resolved_chain=resolved_chain,
+                mock_refs=mock_refs,
+                mock_sources=mock_sources,
+                mock_seeds=mock_seeds,
+                mock_dbt_refs=mock_dbt_refs,
+                helper_ctes=helper_ctes,
+                function_locations=function_locations,
+                adapter=adapter,
+            )
+        assertion_steps.append(
+            SqlTestAssertionStep(
+                name=assertion_name,
+                resolved_sql=resolved_assertion_sql,
+            )
+        )
+    return tuple(assertion_steps)
+
+
 def _plan_direct_logic_test(
     *,
     test: CompiledSqlTest,
@@ -344,9 +397,13 @@ def _resolve_assertion_sql(
     function_locations: dict[str, CompiledRelationLocation],
     adapter: BaseAdapter,
 ) -> str:
-    assertion_resolved_chain: dict[str, str] = {
-        name: _wrap_resolved_chain_sql(sql) for name, sql in resolved_chain.items()
-    }
+    assertion_resolved_chain: dict[str, str]
+    assertion_chain_ctes: tuple[str, ...]
+    assertion_resolved_chain, assertion_chain_ctes = _build_assertion_chain_ctes(
+        assertion_sql=sql,
+        resolved_chain=resolved_chain,
+        requires_flat_ctes=adapter.requires_derived_table_aliases(),
+    )
     resolved_sql: str
     resolved_sql, _ = _resolve_test_model_sql(
         query_sql=sql,
@@ -359,14 +416,42 @@ def _resolve_assertion_sql(
         function_locations=function_locations,
         adapter=adapter,
     )
+    if assertion_chain_ctes:
+        return f"WITH {', '.join(assertion_chain_ctes)} {resolved_sql}"
     return resolved_sql
 
 
-def _wrap_resolved_chain_sql(sql: str) -> str:
-    stripped: str = sql.strip()
-    if stripped.startswith("(") and stripped.endswith(")"):
-        return stripped
-    return f"({stripped})"
+def _build_assertion_chain_ctes(
+    *,
+    assertion_sql: str,
+    resolved_chain: dict[str, str],
+    requires_flat_ctes: bool,
+) -> tuple[dict[str, str], tuple[str, ...]]:
+    if requires_flat_ctes and _LEADING_WITH_PATTERN.search(assertion_sql) is not None:
+        raise PlannerInputError(
+            "SQL test assertion fallback cannot safely flatten an assertion beginning with WITH"
+        )
+    assertion_resolved_chain: dict[str, str] = {}
+    cte_parts: list[str] = []
+    seen_names: set[str] = set()
+    match: re.Match[str]
+    for match in _REF_PATTERN.finditer(assertion_sql):
+        name: str = match.group(1)
+        if name in seen_names or name not in resolved_chain:
+            continue
+        seen_names.add(name)
+        cte_name: str = f"{REF_TEST_CTE_PREFIX}{name}"
+        resolved_sql: str = resolved_chain[name].strip()
+        if resolved_sql.startswith("(") and resolved_sql.endswith(")"):
+            resolved_sql = resolved_sql[1:-1].strip()
+        if requires_flat_ctes and _LEADING_WITH_PATTERN.search(resolved_sql) is not None:
+            raise PlannerInputError(
+                "SQL test assertion fallback cannot safely flatten a referenced model beginning "
+                "with WITH"
+            )
+        assertion_resolved_chain[name] = cte_name
+        cte_parts.append(f"{cte_name} AS ({resolved_sql})")
+    return assertion_resolved_chain, tuple(cte_parts)
 
 
 def _dedupe_function_deps(deps: list[CompiledObjectKey]) -> tuple[CompiledObjectKey, ...]:
@@ -555,6 +640,16 @@ def _validate_resolved_sql(
     return tuple(warnings)
 
 
+def _has_unresolved_test_reference(sql: str) -> bool:
+    normalized_sql: str = sql.lower()
+    return (
+        _REF_PATTERN.search(normalized_sql) is not None
+        or _SOURCE_PATTERN.search(normalized_sql) is not None
+        or _SEED_PATTERN.search(normalized_sql) is not None
+        or _DBT_REF_PATTERN.search(normalized_sql) is not None
+    )
+
+
 def _wrap_mock_with_helpers(
     *,
     mock_body: str,

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/executor/load/_helpers/cursors.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
+from sqlbuild.adapter.contract.types import CursorKind
 from sqlbuild.errors.contracts.exceptions import ExecutorInputError
 
 
@@ -40,6 +41,16 @@ def exclusive_cursor_end(value: object) -> object:
     return value
 
 
+def infer_cursor_kind(value: object) -> CursorKind | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return CursorKind.INTEGER
+    if isinstance(value, datetime):
+        return CursorKind.TIMESTAMP
+    return None
+
+
 def format_cursor_bound(value: object) -> str:
     if isinstance(value, datetime | date):
         return value.isoformat()

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/executor/load/main/_execute.py

@@ -9,6 +9,7 @@ from typing import Any
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
 from sqlbuild.adapter.contract.models import ColumnInfo
+from sqlbuild.adapter.contract.types import CursorKind
 from sqlbuild.adapter.relations.main.resolve_qualified_name_parts import (
     resolve_qualified_name_parts,
 )
@@ -18,6 +19,7 @@ from sqlbuild.errors.contracts.exceptions import ExecutorInputError
 from sqlbuild.executor.load._helpers.cursors import (
     exclusive_cursor_end,
     format_cursor_bound,
+    infer_cursor_kind,
     load_staging_cursor_bounds,
 )
 from sqlbuild.executor.load._helpers.execution import load_resource_kind
@@ -265,6 +267,7 @@ def _apply_source_write_strategy(
         cursor_start, cursor_max = cursor_bounds
         if cursor_start is None or cursor_max is None:
             return adapter
+        cursor_type: CursorKind | None = infer_cursor_kind(cursor_start)
         adapter.delete_insert_cursor(
             connection=connection,
             destination=target,
@@ -273,6 +276,7 @@ def _apply_source_write_strategy(
             cursor_start=format_cursor_bound(cursor_start),
             cursor_end=format_cursor_bound(exclusive_cursor_end(cursor_max)),
             statement_recorder=statement_recorder,
+            cursor_type=cursor_type,
         )
         return adapter
     raise ExecutorInputError(f"unsupported source write_strategy: {source_entry.write_strategy}")

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/executor/run/_helpers/materializations/incremental.py

@@ -613,6 +613,7 @@ def _execute_dml(
                 cursor_end=cursor_end,
                 columns=dml_columns,
                 statement_recorder=statement_recorder,
+                cursor_type=entry.cursor_type,
             )
         else:
             adapter.delete_insert(

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/executor/scenario/main/expected_comparison_sql.py

@@ -20,5 +20,5 @@ def build_scenario_expected_comparison_sql(
         "(SELECT COUNT(*) FROM __expected) AS expected_count, "
         "(SELECT COUNT(*) FROM ("
         f"SELECT * FROM __actual {set_difference_operator} SELECT * FROM __expected"
-        ")) AS mismatched_count"
+        ") AS __sqlbuild_mismatch) AS mismatched_count"
     )

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/src/sqlbuild/executor/testing/main/comparison_sql.py

@@ -61,7 +61,7 @@ def build_sql_test_comparison_sql(
             f"(SELECT COUNT(*) FROM {expected_cte}) AS expected_count, "
             f"(SELECT COUNT(*) FROM ("
             f"SELECT * FROM {actual_cte} {set_difference_operator} SELECT * FROM {expected_cte}"
-            f")) AS mismatched_count"
+            f") AS __sqlbuild_mismatch) AS mismatched_count"
         )
     assertion_index: int
     for assertion_index, assertion in enumerate(test_entry.assertions, start=len(test_entry.chain)):

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/tests/e2e/src/sqlbuild/cli/commands/main/sqlserver/helpers.py

@@ -428,6 +428,7 @@ def prepare_sqlserver_waffle_shop(*, tmp_path: Path, config: dict[str, object])
     (project_dir / "functions" / "sql" / "customer_orders.sql").unlink(missing_ok=True)
     (project_dir / "functions" / "python" / "is_completed_order_py.py").unlink(missing_ok=True)
     (project_dir / "tests" / "unit" / "test_customer_orders_table_fn.sql").unlink(missing_ok=True)
+    (project_dir / "tests" / "unit" / "test_fact_orders.sql").unlink(missing_ok=True)
     (project_dir / "models" / "marts" / "daily_order_partitioned.sql").unlink(missing_ok=True)
     (project_dir / "tests" / "unit" / "test_is_completed_order_udf.sql").unlink(missing_ok=True)
 
@@ -485,9 +486,15 @@ def prepare_sqlserver_waffle_shop(*, tmp_path: Path, config: dict[str, object])
         lookups_path.read_text(encoding="utf-8").replace("type: VARCHAR", "type: NVARCHAR(100)"),
         encoding="utf-8",
     )
-    adapt_sqlserver_text_file(project_dir / "sources" / "raw.yml")
-    for test_path in (project_dir / "tests" / "unit").glob("*.sql"):
-        test_path.unlink(missing_ok=True)
+    raw_sources_path: Path = project_dir / "sources" / "raw.yml"
+    adapt_sqlserver_text_file(raw_sources_path)
+    raw_sources_path.write_text(
+        raw_sources_path.read_text(encoding="utf-8").replace(
+            "      - name: ordered_at\n        type: DATETIME2",
+            "      - name: ordered_at\n        type: DATETIME",
+        ),
+        encoding="utf-8",
+    )
     return project_dir, schema_name
 
 

{sqlbuild-0.48.2 → sqlbuild-0.48.4}/tests/e2e/src/sqlbuild/cli/commands/main/sqlserver/test_sqlserver.py

@@ -278,14 +278,30 @@ def test_given_waffle_shop_when_running_full_build_on_sqlserver_then_expected_ta
     ensure_sqlserver_schema_ready(schema_name=schema_name, config=config)
 
     try:
-        result: subprocess.CompletedProcess[str] = run_sqb(
+        first_result: subprocess.CompletedProcess[str] = run_sqb(
+            command=test_case.command,
+            project_dir=project_dir,
+        )
+        cursor_type_rows: tuple[tuple[object, ...], ...] = fetch_sqlserver_rows(
+            sql=(
+                "SELECT data_type FROM information_schema.columns "
+                f"WHERE table_schema = '{schema_name}' AND table_name = 'raw_orders' "
+                "AND column_name = 'ordered_at'"
+            ),
+            config=config,
+        )
+        second_result: subprocess.CompletedProcess[str] = run_sqb(
             command=test_case.command,
             project_dir=project_dir,
         )
 
-        assert result.returncode == test_case.expected_return_code, result.stdout + result.stderr
-        for fragment in test_case.expected_stdout_fragments:
-            assert fragment in result.stdout
+        assert cursor_type_rows == (("datetime",),)
+        for result in (first_result, second_result):
+            assert result.returncode == test_case.expected_return_code, (
+                result.stdout + result.stderr
+            )
+            for fragment in test_case.expected_stdout_fragments:
+                assert fragment in result.stdout
         rows: tuple[tuple[object, ...], ...] = fetch_sqlserver_rows(
             sql=(
                 "SELECT COUNT(*) FROM "
@@ -294,6 +310,13 @@ def test_given_waffle_shop_when_running_full_build_on_sqlserver_then_expected_ta
             config=config,
         )
         assert int(str(rows[0][0])) == test_case.expected_row_count
+        source_rows: tuple[tuple[object, ...], ...] = fetch_sqlserver_rows(
+            sql=(
+                f"SELECT COUNT(*) FROM {relation_name(schema_name=schema_name, name='raw_orders')}"
+            ),
+            config=config,
+        )
+        assert int(str(source_rows[0][0])) == test_case.expected_row_count
     finally:
         cleanup_sqlserver_schema(schema_name=schema_name, config=config)