datacontract-cli 1.0.4__tar.gz → 1.0.6__tar.gz

{datacontract_cli-1.0.4/datacontract_cli.egg-info → datacontract_cli-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.4
+Version: 1.0.6
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/datacontract/engines/checks/check_spec.py

@@ -14,7 +14,10 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, List, Optional
+from typing import TYPE_CHECKING, Any, List, Optional
+
+if TYPE_CHECKING:
+    from open_data_contract_standard.model import SchemaProperty
 
 
 class MetricType(str, Enum):
@@ -116,8 +119,9 @@ class CheckSpec:
     valid_min_length: Optional[int] = None  # INVALID_COUNT
     valid_max_length: Optional[int] = None  # INVALID_COUNT
 
-    expected_category: Optional[str] = None  # FIELD_TYPE: normalized type category
+    expected_category: Optional[str] = None  # FIELD_TYPE: human-readable label (display only)
     expected_type_label: Optional[str] = None  # FIELD_TYPE: human-readable expected type
+    expected_schema_property: Optional["SchemaProperty"] = None  # FIELD_TYPE: structural comparison
 
     columns: Optional[List[str]] = None  # DUPLICATE_COUNT across multiple columns
 

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/datacontract/engines/checks/create_checks.py

@@ -22,7 +22,6 @@ from open_data_contract_standard.model import (
 )
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType, Op, Threshold
-from datacontract.engines.checks.type_normalize import normalize_type_name
 
 logger = logging.getLogger(__name__)
 
@@ -54,12 +53,6 @@ def to_schema_name(schema_object: SchemaObject, server_type: Optional[str]) -> s
     return schema_object.name
 
 
-def expected_type_category(prop: SchemaProperty) -> tuple[str, str]:
-    """Return (normalized category, human label) for a property's declared type."""
-    label = prop.physicalType or prop.logicalType
-    return normalize_type_name(label), (label or "")
-
-
 _PERCENT_UNITS = {"percent", "percentage", "%"}
 
 
@@ -178,8 +171,8 @@ def _to_schema_checks(schema_object: SchemaObject, server: Optional[Server]) ->
             )
         )
 
-        if check_types and (prop.physicalType is not None or prop.logicalType is not None):
-            category, label = expected_type_category(prop)
+        if check_types and prop.logicalType is not None:
+            schema_prop, label = prop, prop.logicalType or ""
             checks.append(
                 CheckSpec(
                     key=f"{model}__{field}__field_type",
@@ -189,8 +182,9 @@ def _to_schema_checks(schema_object: SchemaObject, server: Optional[Server]) ->
                     model=model,
                     field=field,
                     metric=MetricType.FIELD_TYPE,
-                    expected_category=category,
+                    expected_category=label,
                     expected_type_label=label,
+                    expected_schema_property=schema_prop,
                 )
             )
 

datacontract_cli-1.0.6/datacontract/engines/checks/type_normalize.py

@@ -0,0 +1,214 @@
+"""Type normalization and structural comparison for schema ``field_type`` checks.
+
+``normalize_type_name`` maps a raw type string (logical or physical) to one of
+the nine ODCS logical-type categories.
+
+``schema_property_matches`` compares two ``SchemaProperty`` trees — one from the
+contract, one reconstructed from the ibis-reported dtype — and returns True when
+the actual type is structurally compatible with the expected one.
+"""
+
+from __future__ import annotations
+
+import re
+
+from open_data_contract_standard.model import SchemaProperty
+
+
+def normalize_type_name(type_name: str | None) -> str | None:
+    """Map a contract type name (logical or physical) to one of the 9 ODCS categories.
+
+    Returns ``None`` for types that are unsupported or unrecognized (binary,
+    map, null, interval …) so they can be silently ignored rather than
+    producing false type-check failures.
+    """
+    if not type_name:
+        return None
+    name = type_name.strip().lower()
+    # strip parameters like varchar(10) / decimal(10,2) and array<...> wrappers
+    name = re.sub(r"\(.*\)", "", name)
+    name = re.sub(r"<.*>", "", name).strip()
+
+    if name in {
+        "varchar",
+        "varchar2",
+        "char",
+        "character",
+        "character varying",
+        "nvarchar",
+        "nvarchar2",
+        "nchar",
+        "text",
+        "string",
+        "str",
+        "clob",
+        "nclob",
+        "uuid",
+        "enum",
+    }:
+        return "string"
+    if name in {
+        "int",
+        "integer",
+        "bigint",
+        "smallint",
+        "tinyint",
+        "long",
+        "short",
+        "int2",
+        "int4",
+        "int8",
+        "serial",
+        "bigserial",
+        "smallserial",
+        "int64",
+        "int32",
+        "int16",
+        "int8",
+        "byteint",
+    }:
+        return "integer"
+    if name in {
+        "decimal",
+        "numeric",
+        "dec",
+        "float",
+        "double",
+        "double precision",
+        "real",
+        "float4",
+        "float8",
+        "float32",
+        "float64",
+        "binary_float",
+        "binary_double",
+        "number",
+    }:
+        return "number"
+    if name in {"bool", "boolean", "bit", "logical"}:
+        return "boolean"
+    if name in {
+        "timestamp",
+        "timestamptz",
+        "timestamp without time zone",
+        "timestamp with time zone",
+        "timestamp_tz",
+        "timestamp_ntz",
+        "timestamp_ltz",
+        "datetime",
+        "datetime2",
+        "smalldatetime",
+    }:
+        return "timestamp"
+    if name in {"date"}:
+        return "date"
+    if name in {"time", "time without time zone", "time with time zone"}:
+        return "time"
+    if name in {"struct", "record", "object", "row", "json", "jsonb", "variant"}:
+        return "object"
+    if name in {"array", "list"}:
+        return "array"
+    # binary, map, null, interval and other unrecognized types are not in the
+    # 9 allowed categories; return None so they are silently ignored.
+    return None
+
+
+_NUMERIC = {"integer", "number"}
+
+
+def schema_property_matches(expected: SchemaProperty | None, actual: SchemaProperty | None) -> bool:
+    """Return True if ``actual`` is structurally compatible with ``expected``.
+
+    Lenient by design:
+
+    - If expected is ``None`` (unsupported/unrecognized type) always passes.
+    - ``integer`` and ``number`` are mutually compatible (ODCS "number" is
+      intentionally ambiguous across numeric storage classes).
+    - A bare ``object`` or ``array`` on the expected side (no nested detail)
+      matches any actual structure with the same base (underdeclared contract).
+    - Extra actual fields inside an ``object`` are ignored.
+    """
+    if expected is None:
+        return True
+    if actual is None:
+        return False
+
+    expected_base = normalize_type_name(expected.logicalType or expected.physicalType)
+    actual_base = normalize_type_name(actual.logicalType or actual.physicalType)
+
+    if expected_base is None:
+        return True
+    if actual_base is None:
+        return False
+    if expected_base != actual_base and not (expected_base in _NUMERIC and actual_base in _NUMERIC):
+        return False
+
+    if expected_base == "array":
+        if expected.items is None:
+            return True
+        return schema_property_matches(expected.items, actual.items)
+
+    if expected_base == "object":
+        if not expected.properties:
+            return True
+        actual_by_name = {p.name.lower(): p for p in (actual.properties or []) if p.name}
+        for exp_field in expected.properties:
+            if not exp_field.name:
+                continue
+            act_field = actual_by_name.get(exp_field.name.lower())
+            if act_field is None:
+                return False
+            if not schema_property_matches(exp_field, act_field):
+                return False
+        return True
+
+    return True
+
+
+def schema_property_mismatch_reason(
+    expected: SchemaProperty | None,
+    actual: SchemaProperty | None,
+    path: str = "",
+) -> str:
+    """Return a human-readable description of the first structural mismatch, or '' if none."""
+    if expected is None:
+        return ""
+    field_label = f"field '{path}'" if path else "column"
+    if actual is None:
+        exp_str = expected.logicalType or expected.physicalType
+        return f"{field_label}: expected type '{exp_str}' but the column type could not be determined"
+
+    expected_base = normalize_type_name(expected.logicalType or expected.physicalType)
+    actual_base = normalize_type_name(actual.logicalType or actual.physicalType)
+
+    if expected_base is None:
+        return ""
+
+    if expected_base != actual_base and not (expected_base in _NUMERIC and actual_base in _NUMERIC):
+        exp_str = expected.logicalType or expected.physicalType
+        act_str = actual.logicalType or actual.physicalType
+        return f"{field_label}: expected type '{exp_str}' but got '{act_str}'"
+
+    if expected_base == "array":
+        if expected.items is not None:
+            child_path = f"{path}[]" if path else "[]"
+            return schema_property_mismatch_reason(expected.items, actual.items, child_path)
+        return ""
+
+    if expected_base == "object":
+        if not expected.properties:
+            return ""
+        actual_by_name = {p.name.lower(): p for p in (actual.properties or []) if p.name}
+        for exp_field in expected.properties:
+            if not exp_field.name:
+                continue
+            child_path = f"{path}.{exp_field.name}" if path else exp_field.name
+            act_field = actual_by_name.get(exp_field.name.lower())
+            if act_field is None:
+                return f"field '{child_path}' is missing"
+            reason = schema_property_mismatch_reason(exp_field, act_field, child_path)
+            if reason:
+                return reason
+        return ""
+
+    return ""

datacontract_cli-1.0.6/datacontract/engines/ibis/dtype_category.py

@@ -0,0 +1,93 @@
+"""Map an ibis dtype to the coarse category used by ``field_type`` checks."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from open_data_contract_standard.model import SchemaProperty
+
+if TYPE_CHECKING:
+    from ibis.expr.datatypes import DataType
+
+
+def ibis_dtype_category(dtype) -> str:
+    """Return the normalized category for an ibis ``DataType``.
+
+    Order matters: boolean is checked before integer (some engines model bool as
+    a 1-bit int), and decimal before floating.
+    """
+    try:
+        if dtype.is_boolean():
+            return "boolean"
+        if dtype.is_integer():
+            return "integer"
+        if dtype.is_decimal():
+            return "decimal"
+        if dtype.is_floating():
+            return "float"
+        if dtype.is_string():
+            return "string"
+        if dtype.is_timestamp():
+            return "timestamp"
+        if dtype.is_date():
+            return "date"
+        if dtype.is_time():
+            return "time"
+        if dtype.is_binary():
+            return "binary"
+        if dtype.is_struct():
+            return "struct"
+        if dtype.is_array():
+            return "array"
+        if dtype.is_map():
+            return "map"
+        if dtype.is_null():
+            return "null"
+    except AttributeError:
+        return "other"
+    return "other"
+
+
+def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty | None:
+    """Map an ibis DataType to a SchemaProperty for structural type comparison.
+
+    Returns a ``SchemaProperty`` with ``logicalType`` set to one of the 9 ODCS
+    categories, recursively populating ``properties`` for structs and ``items``
+    for arrays. Returns ``None`` for unsupported types (binary, map, null, etc.)
+    so the caller can skip comparison rather than raising a false failure.
+    """
+    try:
+        if dtype.is_boolean():
+            return SchemaProperty(logicalType="boolean")
+        if dtype.is_integer():
+            return SchemaProperty(logicalType="integer")
+        if dtype.is_decimal() or dtype.is_floating():
+            return SchemaProperty(logicalType="number")
+        if dtype.is_string():
+            return SchemaProperty(logicalType="string")
+        if dtype.is_timestamp():
+            return SchemaProperty(logicalType="timestamp")
+        if dtype.is_date():
+            return SchemaProperty(logicalType="date")
+        if dtype.is_time():
+            return SchemaProperty(logicalType="time")
+        if dtype.is_struct():
+            properties = []
+            for field_name, ftype in dtype.fields.items():
+                child = ibis_dtype_to_schema_property(ftype)
+                if child is not None:
+                    properties.append(
+                        SchemaProperty(
+                            name=field_name,
+                            logicalType=child.logicalType,
+                            items=child.items,
+                            properties=child.properties,
+                        )
+                    )
+            return SchemaProperty(logicalType="object", properties=properties if properties else None)
+        if dtype.is_array():
+            element = ibis_dtype_to_schema_property(dtype.value_type)
+            return SchemaProperty(logicalType="array", items=element)
+    except AttributeError:
+        return None
+    return None

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/datacontract/engines/ibis/ibis_check_execute.py

@@ -17,9 +17,9 @@ from typing import List, Optional
 from open_data_contract_standard.model import OpenDataContractStandard, Server
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType
-from datacontract.engines.checks.type_normalize import category_matches
+from datacontract.engines.checks.type_normalize import schema_property_matches, schema_property_mismatch_reason
 from datacontract.engines.ibis.connections.connect import connect_ibis
-from datacontract.engines.ibis.dtype_category import ibis_dtype_category
+from datacontract.engines.ibis.dtype_category import ibis_dtype_to_schema_property
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Check, ResultEnum, Run
 from datacontract.model.server import get_server_type
@@ -177,7 +177,7 @@ def _run_model(
     include_failed_samples: bool = False,
 ):
     try:
-        t = _resolve_table(con, model)
+        t = _resolve_table(con, model, _table_database(con, server))
     except Exception as e:
         logger.warning("Could not read model '%s': %s", model, e)
         _fail_all(run, specs, ResultEnum.failed, f"Could not read model '{model}': {e}")
@@ -607,31 +607,30 @@ def _run_type(run: Run, schema, columns, spec: CheckSpec):
     _set_impl(
         run,
         spec.key,
-        f"type of '{spec.field}' is compatible with '{spec.expected_type_label}' ({spec.expected_category})",
+        f"type of '{spec.field}' is compatible with '{spec.expected_type_label}'",
         "introspection",
     )
-    expected_label = f"{spec.expected_type_label} ({spec.expected_category})"
     actual_col = columns.get(spec.field.lower())
     if actual_col is None:
-        _set_diagnostics(run, spec.key, _diag(metric="field_type", field=spec.field, expected=expected_label))
+        _set_diagnostics(run, spec.key, _diag(metric="field_type", field=spec.field, expected=spec.expected_type_label))
         _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
         return
     dtype = schema[actual_col]
-    actual_category = ibis_dtype_category(dtype)
+    actual_prop = ibis_dtype_to_schema_property(dtype)
     _set_diagnostics(
         run,
         spec.key,
-        _diag(metric="field_type", field=spec.field, expected=expected_label, actual=f"{dtype} ({actual_category})"),
+        _diag(metric="field_type", field=spec.field, expected=spec.expected_type_label, actual=str(dtype)),
     )
-    if category_matches(spec.expected_category, actual_category):
+    if schema_property_matches(spec.expected_schema_property, actual_prop):
         _set_result(run, spec.key, ResultEnum.passed, None)
     else:
+        reason = schema_property_mismatch_reason(spec.expected_schema_property, actual_prop)
         _set_result(
             run,
             spec.key,
             ResultEnum.failed,
-            f"Expected type '{spec.expected_type_label}' ({spec.expected_category}) "
-            f"but column is '{dtype}' ({actual_category})",
+            reason or f"Expected type '{spec.expected_type_label}' but column is '{dtype}'",
         )
 
 
@@ -849,21 +848,52 @@ def _resolve_col(columns: dict, field: str) -> str:
     return actual
 
 
-def _resolve_table(con, model: str):
+def _table_database(con, server: Optional[Server]) -> Optional[str]:
+    """The schema to qualify the table with during introspection, or ``None``.
+
+    Two backends need the contract's ``server.schema`` passed explicitly instead
+    of relying on ibis's default:
+
+    - **Oracle** logs in as one user but the tables may be owned by a different
+      schema (``server.schema``). ibis defaults the owner to the login user, so
+      an unqualified lookup raises ``TableNotFound``.
+    - **Redshift** has no dedicated ibis backend and goes through the Postgres
+      backend (``con.name == "postgres"``). When no schema is passed, ibis's
+      Postgres introspection resolves the active schema with ``SELECT
+      current_schema`` (no parentheses) — valid on PostgreSQL but rejected by
+      Redshift with ``column "current_schema" does not exist``, since Redshift
+      only supports the parenthesized ``current_schema()``. Passing the schema
+      explicitly skips that query.
+
+    Other backends pin the schema at connect time and need no qualifier.
+    """
+    if server is None or not server.schema_:
+        return None
+    if getattr(con, "name", None) == "oracle":
+        return server.schema_
+    # Redshift rides the Postgres backend, so detect it by the contract's server
+    # type rather than con.name.
+    if get_server_type(server) == "redshift":
+        return server.schema_
+    return None
+
+
+def _resolve_table(con, model: str, database: Optional[str] = None):
     """Resolve a table by name, tolerating case differences across dialects."""
     if getattr(con, "name", None) == "pyspark":
         return _pyspark_table_unconvertible_as_unknown(con, model)
+    kwargs = {"database": database} if database else {}
     try:
-        return con.table(model)
+        return con.table(model, **kwargs)
     except Exception:
         try:
-            available = con.list_tables()
+            available = con.list_tables(**kwargs)
         except Exception:
             raise
         match = next((name for name in available if name.lower() == model.lower()), None)
         if match is None:
             raise
-        return con.table(match)
+        return con.table(match, **kwargs)
 
 
 def _pyspark_table_unconvertible_as_unknown(con, name: str):

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/datacontract/imports/dcs_importer.py

@@ -570,10 +570,10 @@ def _convert_field_to_property(
     return prop
 
 
-def _convert_type_to_logical_type(dcs_type: str) -> str:
+def _convert_type_to_logical_type(dcs_type: str) -> str | None:
     """Convert DCS type to ODCS logical type."""
     if dcs_type is None:
-        return "string"
+        return None
 
     t = dcs_type.lower()
 
@@ -598,19 +598,26 @@ def _convert_type_to_logical_type(dcs_type: str) -> str:
         "timestamp_tz": "timestamp",
         "timestamp_ntz": "timestamp",
         "date": "date",
-        "time": "string",  # not supported in ODCS
+        "time": None,  # not supported in ODCS
         "datetime": "timestamp",
         "array": "array",
         "object": "object",
         "record": "object",
         "struct": "object",
-        "map": "object",
-        "bytes": "string",  # not supported in ODCS
-        "binary": "string",  # not supported in ODCS
-        "null": "string",  # not supported in ODCS
+        "map": None,  # not supported in ODCS
+        "interval": None,  # not supported in ODCS
+        "bytes": None,  # not supported in ODCS
+        "binary": None,  # not supported in ODCS
+        "varbinary": None,  # not supported in ODCS
+        "blob": None,  # not supported in ODCS
+        "bytea": None,  # not supported in ODCS
+        "raw": None,  # not supported in ODCS
+        "null": None,  # not supported in ODCS
+        "none": None,  # not supported in ODCS
+        "void": None,  # not supported in ODCS
     }
 
-    return type_mapping.get(t, t)
+    return type_mapping.get(t, None)
 
 
 def _convert_quality_list(quality_list: list) -> List[DataQuality]:

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6/datacontract_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.4
+Version: 1.0.6
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/datacontract_cli.egg-info/SOURCES.txt

@@ -292,6 +292,7 @@ tests/test_export_sql_clickhouse.py
 tests/test_export_sql_query.py
 tests/test_export_sqlalchemy.py
 tests/test_ibis_mssql_pattern.py
+tests/test_ibis_oracle_schema.py
 tests/test_import_avro.py
 tests/test_import_bigquery.py
 tests/test_import_csv.py

{datacontract_cli-1.0.4 → datacontract_cli-1.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datacontract-cli"
-version = "1.0.4"
+version = "1.0.6"
 description = "The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library."
 license = "MIT"
 readme = "README.md"

datacontract_cli-1.0.6/tests/test_ibis_oracle_schema.py

@@ -0,0 +1,98 @@
+"""Unit tests for Oracle table resolution across schemas (owners).
+
+Oracle logs in as one user but the contract's tables may be owned by a different
+schema (``server.schema``). ibis defaults the owner to the login user during
+introspection, so an unqualified lookup raises ``TableNotFound``. The engine
+must qualify the table with the configured schema. See issue: cross-schema
+Oracle test fails with "Could not read model '<table>': <table>".
+"""
+
+from open_data_contract_standard.model import Server
+
+from datacontract.engines.ibis.ibis_check_execute import _resolve_table, _table_database
+
+
+class _FakeBackend:
+    """Minimal stand-in for an ibis backend that records how it is queried."""
+
+    def __init__(self, name, tables):
+        self.name = name
+        # tables: {database_or_None: {table_name: object}}
+        self._tables = tables
+        self.table_calls = []
+
+    def table(self, name, database=None):
+        self.table_calls.append((name, database))
+        try:
+            return self._tables[database][name]
+        except KeyError:
+            raise Exception(name)
+
+    def list_tables(self, database=None):
+        return list(self._tables.get(database, {}))
+
+
+def test_table_database_uses_server_schema_for_oracle():
+    server = Server(type="oracle", schema="PSD1_VERBIS")
+    con = _FakeBackend("oracle", {})
+    assert _table_database(con, server) == "PSD1_VERBIS"
+
+
+def test_table_database_none_for_oracle_without_schema():
+    server = Server(type="oracle")
+    con = _FakeBackend("oracle", {})
+    assert _table_database(con, server) is None
+
+
+def test_table_database_none_for_non_oracle_backend():
+    # Postgres/snowflake pin the schema at connect time, so no qualifier is added.
+    server = Server(type="postgres", schema="public")
+    con = _FakeBackend("postgres", {})
+    assert _table_database(con, server) is None
+
+
+def test_table_database_uses_server_schema_for_redshift():
+    # Redshift rides the Postgres ibis backend (con.name == "postgres"). Without
+    # an explicit schema, ibis introspects via `SELECT current_schema` (no
+    # parens), which Redshift rejects ("column current_schema does not exist").
+    # Passing the schema explicitly avoids that query.
+    server = Server(type="redshift", schema="dwh_academic")
+    con = _FakeBackend("postgres", {})
+    assert _table_database(con, server) == "dwh_academic"
+
+
+def test_table_database_none_for_redshift_without_schema():
+    server = Server(type="redshift")
+    con = _FakeBackend("postgres", {})
+    assert _table_database(con, server) is None
+
+
+def test_table_database_none_without_server():
+    con = _FakeBackend("oracle", {})
+    assert _table_database(con, None) is None
+
+
+def test_resolve_table_qualifies_with_schema():
+    sentinel = object()
+    con = _FakeBackend("oracle", {"PSD1_VERBIS": {"BERUF": sentinel}})
+
+    assert _resolve_table(con, "BERUF", "PSD1_VERBIS") is sentinel
+    assert ("BERUF", "PSD1_VERBIS") in con.table_calls
+
+
+def test_resolve_table_without_schema_does_not_pass_database():
+    sentinel = object()
+    con = _FakeBackend("oracle", {None: {"BERUF": sentinel}})
+
+    assert _resolve_table(con, "BERUF") is sentinel
+    assert con.table_calls == [("BERUF", None)]
+
+
+def test_resolve_table_case_insensitive_fallback_keeps_schema():
+    sentinel = object()
+    con = _FakeBackend("oracle", {"PSD1_VERBIS": {"BERUF": sentinel}})
+
+    # Contract uses lowercase; the actual table is uppercase in the schema.
+    assert _resolve_table(con, "beruf", "PSD1_VERBIS") is sentinel
+    # The successful resolution still targets the qualifying schema.
+    assert con.table_calls[-1] == ("BERUF", "PSD1_VERBIS")