sqlbuild 0.48.1__tar.gz → 0.48.3__tar.gz

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

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

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [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)
+
+
+### Bug Fixes
+
+* preserve build errors and normalize schema types ([4753e41](https://github.com/chio-labs/sqlbuild/commit/4753e418fd0add3161435727321902d9ed051f88))
+* preserve build errors and normalize schema types ([3480cd1](https://github.com/chio-labs/sqlbuild/commit/3480cd168887c3c1b2e2abd0a821fba53f823768))
+
 ## [0.48.1](https://github.com/chio-labs/sqlbuild/compare/v0.48.0...v0.48.1) (2026-07-30)
 
 

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/PKG-INFO

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

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/pyproject.toml

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

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/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(".")]

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/src/sqlbuild/cli/commands/classes/build_progress_callbacks.py

@@ -660,9 +660,35 @@ def _format_python_failure_details(
     return lines
 
 
-def _format_failure_details(*, result: BuildExecutionResult, style: CliStyle) -> list[str]:
+def _format_load_failure_details(
+    *, results: tuple[LoadExecutionResult, ...], style: CliStyle
+) -> list[str]:
     lines: list[str] = []
-    has_failures: bool = False
+    load_result: LoadExecutionResult
+    for load_result in results:
+        if load_result.status != ExecutionStatus.FAILED:
+            continue
+        if not lines:
+            lines.append("")
+            lines.append(style.error_strong("Failures:"))
+            lines.append("")
+        lines.append(f"  {load_result.source_name}  ({load_result.resource_kind.value})")
+        if load_result.error_message is not None:
+            lines.extend(
+                _format_failure_error_block(
+                    error_code=None,
+                    error_message=load_result.error_message,
+                    error_help=None,
+                    style=style,
+                )
+            )
+        lines.append("")
+    return lines
+
+
+def _format_failure_details(*, result: BuildExecutionResult, style: CliStyle) -> list[str]:
+    lines: list[str] = _format_load_failure_details(results=result.load_results, style=style)
+    has_failures: bool = bool(lines)
 
     seed_result: SeedExecutionResult
     for seed_result in result.seed_results:
@@ -820,7 +846,7 @@ def _format_failure_error_block(
         use_color=style.use_color,
     )
     formatted_line: str
-    for index, formatted_line in enumerate(_format_error_lines(message)):
+    for index, formatted_line in enumerate(message.splitlines() or [message]):
         display_label: str = label if index == 0 else ""
         lines.append(f"    {display_label:<{_TYPE_WIDTH}}{formatted_line}")
     return lines

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/src/sqlbuild/compiler/planner/_helpers/changes/schema.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from sqlbuild.adapter.contract.models import ColumnInfo
+from sqlbuild.adapter.type_system.main.types_equal import types_equal
 from sqlbuild.compiler.compile.models import InferredColumn
 from sqlbuild.compiler.planner.models import SchemaFinding
 from sqlbuild.compiler.planner.types import SchemaChangeKind, SchemaColumnSource
@@ -98,7 +99,7 @@ def _compare_yml_columns(
                     expected_type=col.type,
                 )
             )
-        elif warehouse_map[col.name] != col.type:
+        elif not types_equal(left=warehouse_map[col.name], right=col.type, dialect=None):
             findings.append(
                 SchemaFinding(
                     kind=SchemaChangeKind.COLUMN_TYPE_CHANGED,
@@ -133,7 +134,7 @@ def _compare_yml_columns_non_enforced(
                     expected_type=col.type,
                 )
             )
-        elif warehouse_map[col.name] != col.type:
+        elif not types_equal(left=warehouse_map[col.name], right=col.type, dialect=None):
             findings.append(
                 SchemaFinding(
                     kind=SchemaChangeKind.COLUMN_TYPE_CHANGED,
@@ -168,7 +169,9 @@ def _compare_inferred_columns(
                     expected_type=col.type,
                 )
             )
-        elif col.type is not None and warehouse_map[col.name] != col.type:
+        elif col.type is not None and not types_equal(
+            left=warehouse_map[col.name], right=col.type, dialect=None
+        ):
             findings.append(
                 SchemaFinding(
                     kind=SchemaChangeKind.COLUMN_TYPE_CHANGED,

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/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.1 → sqlbuild-0.48.3}/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.1 → sqlbuild-0.48.3}/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.1 → sqlbuild-0.48.3}/src/sqlbuild/integrations/dbt/_helpers/pipeline/execute.py

@@ -235,11 +235,11 @@ def render_dbt_execution_summary_footer(
 
     if not node_results:
         return None
-    pass_count = 0
-    warn_count = 0
-    fail_count = 0
-    skip_count = 0
-    elapsed = 0.0
+    pass_count: int = 0
+    warn_count: int = 0
+    fail_count: int = 0
+    skip_count: int = 0
+    elapsed: float = 0.0
     for result in node_results:
         status: str = result.status.lower()
         if result.execution_time is not None:

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/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)
 
@@ -486,8 +487,6 @@ def prepare_sqlserver_waffle_shop(*, tmp_path: Path, config: dict[str, object])
         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)
     return project_dir, schema_name
 
 

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/tests/integration/src/sqlbuild/adapters/sqlserver/_test_types.py

@@ -48,3 +48,18 @@ class SqlServerSeedTestCase:
     description: str
     csv_text: str
     expected_rows: tuple[tuple[object, ...], ...]
+
+
+@dataclass(frozen=True)
+class SqlServerRollbackPreservationTestCase:
+    description: str
+    original_error_message: str
+    expected_transaction_count: int
+
+
+@dataclass(frozen=True)
+class SqlServerTimestampCursorBoundTestCase:
+    description: str
+    cursor_start: str
+    cursor_end: str
+    expected_rows: tuple[tuple[object, ...], ...]

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/tests/integration/src/sqlbuild/adapters/sqlserver/test_client.py

@@ -7,6 +7,7 @@ import pytest
 
 from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
 from sqlbuild.adapter.contract.models import ColumnInfo, QueryResult
+from sqlbuild.adapter.contract.types import CursorKind
 from sqlbuild.adapters.sqlserver.classes.sqlserver_adapter import SqlServerAdapter
 from sqlbuild.executor.run._helpers.reuse.core import create_relation_from_reuse_origin
 from tests.integration.src.sqlbuild.adapters.sqlserver._test_types import (
@@ -14,8 +15,10 @@ from tests.integration.src.sqlbuild.adapters.sqlserver._test_types import (
     SqlServerMergeTestCase,
     SqlServerQueryTestCase,
     SqlServerRelationReuseCopyTestCase,
+    SqlServerRollbackPreservationTestCase,
     SqlServerSchemaIntrospectionTestCase,
     SqlServerSeedTestCase,
+    SqlServerTimestampCursorBoundTestCase,
 )
 from tests.integration.src.sqlbuild.adapters.sqlserver.helpers import (
     build_statement_recorder,
@@ -241,3 +244,76 @@ def test_given_seed_csv_when_loading_then_sqlserver_inserts_all_rows(
         adapter=adapter, connection=connection, sql=f"SELECT id, name FROM {target} ORDER BY id"
     )
     assert rows == test_case.expected_rows
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        SqlServerRollbackPreservationTestCase(
+            description="preserves the original error after sqlserver already rolled back",
+            original_error_message="original transaction failure",
+            expected_transaction_count=0,
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_ended_transaction_when_context_raises_then_original_error_is_preserved(
+    test_case: SqlServerRollbackPreservationTestCase,
+    adapter: SqlServerAdapter,
+    connection: Any,
+) -> None:
+    with pytest.raises(RuntimeError, match=test_case.original_error_message):
+        with adapter.transaction(connection):
+            adapter.execute(connection=connection, sql="ROLLBACK TRANSACTION")
+            raise RuntimeError(test_case.original_error_message)
+
+    rows: tuple[tuple[object, ...], ...] = fetch_rows(
+        adapter=adapter,
+        connection=connection,
+        sql="SELECT @@TRANCOUNT",
+    )
+    assert int(str(rows[0][0])) == test_case.expected_transaction_count
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        SqlServerTimestampCursorBoundTestCase(
+            description="compares legacy datetime values with fractional datetime2 bounds",
+            cursor_start="2026-04-03T14:30:00.000001",
+            cursor_end="2026-04-04T14:30:00.000001",
+            expected_rows=((1,),),
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_legacy_datetime_when_querying_fractional_bounds_then_sqlserver_accepts_them(
+    test_case: SqlServerTimestampCursorBoundTestCase,
+    adapter: SqlServerAdapter,
+    connection: Any,
+    sqlserver_schema: str,
+) -> None:
+    target: str = qualified_name(schema=sqlserver_schema, name="timestamp_events")
+    adapter.execute(
+        connection=connection,
+        sql=f"CREATE TABLE {target} (event_id INT, ordered_at DATETIME)",
+    )
+    adapter.execute(
+        connection=connection,
+        sql=f"INSERT INTO {target} VALUES (1, '2026-04-04T14:30:00')",
+    )
+    bounded_sql: str = adapter.render_query_with_cursor_bounds(
+        sql=f"SELECT event_id, ordered_at FROM {target}",
+        cursor_column="ordered_at",
+        cursor_start=test_case.cursor_start,
+        cursor_end=test_case.cursor_end,
+        cursor_type=CursorKind.TIMESTAMP,
+    )
+
+    rows: tuple[tuple[object, ...], ...] = fetch_rows(
+        adapter=adapter,
+        connection=connection,
+        sql=f"SELECT event_id FROM ({bounded_sql}) AS bounded_events",
+    )
+
+    assert rows == test_case.expected_rows

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/tests/unit/src/sqlbuild/adapters/sqlserver/_test_types.py

@@ -55,6 +55,20 @@ class SqlServerRenderRenameTestCase:
     expected_statements: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class SqlServerCursorBoundLiteralTestCase:
+    description: str
+    value: str
+    cursor_type: str | None
+    expected_literal: str
+
+
+@dataclass(frozen=True)
+class SqlServerRollbackTestCase:
+    description: str
+    expected_statement: str
+
+
 @dataclass(frozen=True)
 class SqlServerMoveOrCopyRelationTestCase:
     description: str

{sqlbuild-0.48.1 → sqlbuild-0.48.3}/tests/unit/src/sqlbuild/adapters/sqlserver/test_client.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 import pytest
 
 from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
+from sqlbuild.adapter.contract.types import CursorKind
 from sqlbuild.adapters.sqlserver.classes.sqlserver_adapter import SqlServerAdapter
 from sqlbuild.compiler.compile.models import FunctionArgument
 from tests.unit.src.sqlbuild.adapters.sqlserver._test_types import (
     SqlServerAdapterDefaultsTestCase,
+    SqlServerCursorBoundLiteralTestCase,
     SqlServerIndexSqlTestCase,
     SqlServerLatestReadSqlTestCase,
     SqlServerMoveOrCopyRelationTestCase,
@@ -17,6 +19,7 @@ from tests.unit.src.sqlbuild.adapters.sqlserver._test_types import (
     SqlServerRenderIdentifierTestCase,
     SqlServerRenderQualifiedNameTestCase,
     SqlServerRenderRenameTestCase,
+    SqlServerRollbackTestCase,
 )
 from tests.unit.src.sqlbuild.adapters.sqlserver.helpers import FakeSqlServerConnection
 
@@ -71,6 +74,58 @@ def test_given_identifier_when_rendering_then_sqlserver_bracket_quotes_identifie
     assert identifier == test_case.expected_identifier
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        SqlServerCursorBoundLiteralTestCase(
+            description="casts fractional timestamp cursor bounds to datetime2",
+            value="2026-04-04T14:30:00.000001",
+            cursor_type=CursorKind.TIMESTAMP,
+            expected_literal="CAST('2026-04-04T14:30:00.000001' AS DATETIME2(6))",
+        ),
+        SqlServerCursorBoundLiteralTestCase(
+            description="leaves integer cursor bounds unquoted",
+            value="42",
+            cursor_type=CursorKind.INTEGER,
+            expected_literal="42",
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_cursor_bound_when_rendering_then_sqlserver_uses_compatible_literal(
+    test_case: SqlServerCursorBoundLiteralTestCase,
+) -> None:
+    adapter: SqlServerAdapter = SqlServerAdapter()
+
+    literal: str = adapter.render_cursor_bound_literal(
+        value=test_case.value,
+        cursor_type=test_case.cursor_type,
+    )
+
+    assert literal == test_case.expected_literal
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        SqlServerRollbackTestCase(
+            description="guards rollback when sqlserver already ended the transaction",
+            expected_statement="IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION",
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_transaction_when_rolling_back_then_sqlserver_checks_transaction_count(
+    test_case: SqlServerRollbackTestCase,
+) -> None:
+    adapter: SqlServerAdapter = SqlServerAdapter()
+    connection: FakeSqlServerConnection = FakeSqlServerConnection()
+
+    adapter.rollback(connection)
+
+    assert connection.executed_sql == [test_case.expected_statement]
+
+
 @pytest.mark.parametrize(
     "test_case",
     [