datacontract-cli 1.0.11__tar.gz → 1.0.12__tar.gz

{datacontract_cli-1.0.11/datacontract_cli.egg-info → datacontract_cli-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.11
+Version: 1.0.12
 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.11 → datacontract_cli-1.0.12}/datacontract/engines/checks/type_normalize.py

@@ -14,6 +14,13 @@ import re
 
 from open_data_contract_standard.model import SchemaProperty
 
+# logicalType marker for a field whose type the backend cannot describe: a
+# dynamically-typed column (ibis json: Snowflake VARIANT, Postgres JSONB,
+# BigQuery JSON) or an unsupported one (binary, geography). No declared type can
+# be confirmed against it, so any expected type fails rather than silently passing.
+# Distinct from a missing field, which is what dropping it would look like.
+UNKNOWN_LOGICAL_TYPE = "__unknown__"
+
 
 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.
@@ -139,6 +146,8 @@ def schema_property_matches(expected: SchemaProperty | None, actual: SchemaPrope
     if expected_base is None:
         return True
     if actual_base is None:
+        # actual is unsupported or dynamically typed (json element/variant): a
+        # declared concrete type can't be confirmed against it, so it fails.
         return False
     if expected_base != actual_base and not (expected_base in _NUMERIC and actual_base in _NUMERIC):
         return False
@@ -151,6 +160,8 @@ def schema_property_matches(expected: SchemaProperty | None, actual: SchemaPrope
     if expected_base == "object":
         if not expected.properties:
             return True
+        # actual.properties is None for an untyped object (ibis map/variant): the
+        # empty lookup below fails every declared field, which is what we want.
         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:
@@ -197,13 +208,22 @@ def schema_property_mismatch_reasons(
         exp_str = expected.logicalType or expected.physicalType
         errors.append(f"{field_label}: expected type '{exp_str}' but the column type could not be determined")
         return errors
-
     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 errors
 
+    if actual_base is None:
+        exp_str = expected.logicalType or expected.physicalType
+        act_str = actual.physicalType or "unknown"
+        errors.append(
+            f"{field_label}: has type '{act_str}', but the contract specifies '{exp_str}'. "
+            f"A '{act_str}' value has no verifiable logical type. "
+            f"If this is intentional, specify `physicalType: {act_str}`."
+        )
+        return errors
+
     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
@@ -218,6 +238,12 @@ def schema_property_mismatch_reasons(
     if expected_base == "object":
         if not expected.properties:
             return errors
+        if actual.properties is None:
+            errors.append(
+                f"{field_label}: declared with nested fields but the column is an untyped object "
+                "(map/variant) whose structure can't be verified; use a structured type or specify physicalType"
+            )
+            return errors
 
         actual_by_name = {p.name.lower(): p for p in (actual.properties or []) if p.name}
         for exp_field in expected.properties:

{datacontract_cli-1.0.11 → datacontract_cli-1.0.12}/datacontract/engines/ibis/dtype_category.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING
 
 from open_data_contract_standard.model import SchemaProperty
 
+from datacontract.engines.checks.type_normalize import UNKNOWN_LOGICAL_TYPE
+
 if TYPE_CHECKING:
     from ibis.expr.datatypes import DataType
 
@@ -48,13 +50,14 @@ def ibis_dtype_category(dtype) -> str:
     return "other"
 
 
-def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty | None:
+def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty:
     """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.
+    for arrays. A type that carries no verifiable logical type (json, binary,
+    null, …) becomes ``UNKNOWN_LOGICAL_TYPE`` with the actual type kept in
+    ``physicalType``, so the failure message can name it.
     """
     try:
         if dtype.is_boolean():
@@ -74,20 +77,25 @@ def ibis_dtype_to_schema_property(dtype: DataType) -> SchemaProperty | None:
         if dtype.is_struct():
             properties = []
             for field_name, ftype in dtype.fields.items():
+                # an unverifiable field type is still a field: keep it, so it is not reported missing
                 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,
-                        )
+                properties.append(
+                    SchemaProperty(
+                        name=field_name,
+                        logicalType=child.logicalType,
+                        physicalType=child.physicalType,
+                        items=child.items,
+                        properties=child.properties,
                     )
-            return SchemaProperty(logicalType="object", properties=properties if properties else None)
+                )
+            return SchemaProperty(logicalType="object", properties=properties)
         if dtype.is_array():
             element = ibis_dtype_to_schema_property(dtype.value_type)
             return SchemaProperty(logicalType="array", items=element)
+        if dtype.is_map():
+            # base is confirmable, inner values are not (yet)
+            return SchemaProperty(logicalType="object", properties=None)
     except AttributeError:
-        return None
-    return None
+        return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE)
+    # json holds a different type per row; binary and null have no ODCS category
+    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=str(dtype))

{datacontract_cli-1.0.11 → datacontract_cli-1.0.12}/datacontract/engines/ibis/ibis_check_execute.py

@@ -14,7 +14,7 @@ import uuid
 from collections import defaultdict
 from typing import List, Optional
 
-from open_data_contract_standard.model import OpenDataContractStandard, Server
+from open_data_contract_standard.model import OpenDataContractStandard, SchemaProperty, Server
 
 from datacontract.engines.checks.check_spec import CheckSpec, MetricType
 from datacontract.engines.checks.physical_type_match import physical_type_matches
@@ -22,6 +22,7 @@ from datacontract.engines.checks.type_normalize import schema_property_matches,
 from datacontract.engines.ibis.connections.connect import connect_ibis
 from datacontract.engines.ibis.dtype_category import ibis_dtype_to_schema_property
 from datacontract.engines.ibis.native_type import fetch_native_types, sqlglot_dialect
+from datacontract.engines.ibis.snowflake_structured_types import fetch_structured_types, has_nesting
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Check, ResultEnum, Run
 from datacontract.model.server import get_server_type
@@ -196,6 +197,14 @@ def _run_model(
     if any(spec.metric == MetricType.FIELD_PHYSICAL_TYPE for spec in specs):
         native_types = fetch_native_types(con, server, model)
 
+    # Snowflake collapses structured OBJECT/ARRAY nesting in the ibis dtype; read
+    # the real nested types from SHOW COLUMNS so field_type checks can recurse.
+    structured_types = None
+    if get_server_type(server) == "snowflake" and any(
+        spec.metric in (MetricType.FIELD_TYPE, MetricType.FIELD_PHYSICAL_TYPE) for spec in specs
+    ):
+        structured_types = fetch_structured_types(con, server, t.get_name())
+
     agg_exprs = []  # list[(spec, named_expr)]
     for spec in specs:
         try:
@@ -219,9 +228,9 @@ def _run_model(
             elif spec.metric == MetricType.FIELD_PRESENT:
                 _run_present(run, con, model, columns, spec)
             elif spec.metric == MetricType.FIELD_TYPE:
-                _run_type(run, schema, columns, spec)
+                _run_type(run, schema, columns, spec, structured_types)
             elif spec.metric == MetricType.FIELD_PHYSICAL_TYPE:
-                _run_physical_type(run, con, server, schema, columns, native_types, spec)
+                _run_physical_type(run, con, server, schema, columns, native_types, spec, structured_types)
             elif spec.metric in (MetricType.FRESHNESS, MetricType.RETENTION):
                 _run_freshness(run, t, columns, spec)
             elif spec.metric == MetricType.CUSTOM_SQL:
@@ -615,7 +624,7 @@ def _run_present(run: Run, con, model: str, columns, spec: CheckSpec):
     )
 
 
-def _run_type(run: Run, schema, columns, spec: CheckSpec):
+def _run_type(run: Run, schema, columns, spec: CheckSpec, structured_types: dict[str, SchemaProperty] | None = None):
     _set_impl(
         run,
         spec.key,
@@ -628,11 +637,19 @@ def _run_type(run: Run, schema, columns, spec: CheckSpec):
         _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
         return
     dtype = schema[actual_col]
-    actual_prop = ibis_dtype_to_schema_property(dtype)
+    # Snowflake structured types come back collapsed from ibis; prefer the nested
+    # tree recovered from SHOW COLUMNS when available.
+    structured_prop = structured_types.get(spec.field.lower()) if structured_types else None
+    actual_prop = structured_prop or ibis_dtype_to_schema_property(dtype)
     _set_diagnostics(
         run,
         spec.key,
-        _diag(metric="field_type", field=spec.field, expected=spec.expected_type_label, actual=str(dtype)),
+        _diag(
+            metric="field_type",
+            field=spec.field,
+            expected=spec.expected_type_label,
+            actual=structured_prop.physicalType if structured_prop else str(dtype),
+        ),
     )
     if schema_property_matches(spec.expected_schema_property, actual_prop):
         _set_result(run, spec.key, ResultEnum.passed, None)
@@ -646,7 +663,16 @@ def _run_type(run: Run, schema, columns, spec: CheckSpec):
         )
 
 
-def _run_physical_type(run: Run, con, server, schema, columns, native_types, spec: CheckSpec):
+def _run_physical_type(
+    run: Run,
+    con,
+    server,
+    schema,
+    columns,
+    native_types,
+    spec: CheckSpec,
+    structured_types: dict[str, SchemaProperty] | None = None,
+):
     """Compare a column's real native type against the contract's physicalType.
 
     When the native type cannot be read for this backend, or the declared
@@ -668,7 +694,13 @@ def _run_physical_type(run: Run, con, server, schema, columns, native_types, spe
         _set_result(run, spec.key, ResultEnum.failed, f"Column '{spec.field}' is missing")
         return
 
-    actual_native = native_types.get(spec.field.lower()) if native_types else None
+    # The catalog reports a structured OBJECT/ARRAY as its bare token, dropping the
+    # nested types; the tree recovered from SHOW COLUMNS renders the real native type.
+    structured_prop = structured_types.get(spec.field.lower()) if structured_types else None
+    if structured_prop is not None and has_nesting(structured_prop):
+        actual_native = structured_prop.physicalType
+    else:
+        actual_native = native_types.get(spec.field.lower()) if native_types else None
     _set_diagnostics(
         run,
         spec.key,
@@ -697,16 +729,17 @@ def _run_physical_type(run: Run, con, server, schema, columns, native_types, spe
     # logicalType category check when the property declares one.
     fallback = spec.expected_schema_property
     if fallback is not None and fallback.logicalType is not None:
-        actual_prop = ibis_dtype_to_schema_property(schema[actual_col])
+        actual_prop = structured_prop or ibis_dtype_to_schema_property(schema[actual_col])
         if schema_property_matches(fallback, actual_prop):
             _set_result(run, spec.key, ResultEnum.passed, None)
         else:
             mismatch = schema_property_mismatch_reason(fallback, actual_prop)
+            actual_label = actual_native or schema[actual_col]
             _set_result(
                 run,
                 spec.key,
                 ResultEnum.failed,
-                mismatch or f"Expected type '{fallback.logicalType}' but column is '{schema[actual_col]}'",
+                mismatch or f"Expected type '{fallback.logicalType}' but column is '{actual_label}'",
             )
         return
 

datacontract_cli-1.0.12/datacontract/engines/ibis/snowflake_structured_types.py

@@ -0,0 +1,134 @@
+"""Rebuild Snowflake structured OBJECT/ARRAY nesting, which ibis collapses, from SHOW COLUMNS."""
+
+from __future__ import annotations
+
+import json
+
+from open_data_contract_standard.model import SchemaProperty, Server
+
+from datacontract.engines.checks.type_normalize import UNKNOWN_LOGICAL_TYPE
+from datacontract.engines.ibis.native_type import _quote, _rows
+
+# SHOW COLUMNS leaf ``type`` tokens -> ODCS logical type. FIXED and REAL both map
+# to "number" (the comparator treats integer/number as compatible). Tokens not
+# listed (BINARY, GEOGRAPHY, VARIANT, …) carry no verifiable logical type.
+_LEAF_TYPES = {
+    "FIXED": "number",
+    "REAL": "number",
+    "TEXT": "string",
+    "BOOLEAN": "boolean",
+    "DATE": "date",
+    "TIME": "time",
+    "TIMESTAMP_NTZ": "timestamp",
+    "TIMESTAMP_LTZ": "timestamp",
+    "TIMESTAMP_TZ": "timestamp",
+}
+
+
+def _to_property(node: dict) -> SchemaProperty:
+    """Convert one ``data_type`` JSON node to a ``SchemaProperty``."""
+    node_type = node.get("type")
+    if node_type == "OBJECT":
+        fields = node.get("fields")
+        if not fields:
+            # untyped OBJECT: same shape as the collapsed ibis map
+            return SchemaProperty(logicalType="object", properties=None)
+        properties = []
+        for field in fields:
+            name = field.get("fieldName")
+            if not name:
+                continue
+            child = _to_property(field.get("fieldType") or {})
+            properties.append(
+                SchemaProperty(
+                    name=name,
+                    logicalType=child.logicalType,
+                    physicalType=child.physicalType,
+                    items=child.items,
+                    properties=child.properties,
+                )
+            )
+        return SchemaProperty(logicalType="object", properties=properties or None)
+    if node_type == "ARRAY":
+        element = node.get("elementType")
+        # untyped ARRAY: no element type to recurse into
+        return SchemaProperty(logicalType="array", items=_to_property(element) if element else None)
+    if node_type == "MAP":
+        # dynamic keys can't be matched to named contract properties
+        return SchemaProperty(logicalType="object", properties=None)
+    logical = _LEAF_TYPES.get(node_type)
+    if logical:
+        return SchemaProperty(logicalType=logical)
+    # VARIANT, BINARY, GEOGRAPHY, …: keep the Snowflake token for the failure message
+    return SchemaProperty(logicalType=UNKNOWN_LOGICAL_TYPE, physicalType=node_type)
+
+
+def has_nesting(prop: SchemaProperty) -> bool:
+    """True only when the property is a structured OBJECT/ARRAY worth substituting."""
+    return bool(prop.properties) or prop.items is not None
+
+
+def _render_native(node: dict) -> str:
+    """Render one ``data_type`` JSON node back to its Snowflake type string."""
+    node_type = node.get("type")
+    if node_type == "OBJECT":
+        fields = node.get("fields")
+        if not fields:
+            return "OBJECT"
+        rendered = [
+            f"{field['fieldName']} {_render_native(field.get('fieldType') or {})}"
+            for field in fields
+            if field.get("fieldName")
+        ]
+        return "OBJECT({})".format(", ".join(rendered)) if rendered else "OBJECT"
+    if node_type == "ARRAY":
+        element = node.get("elementType")
+        return "ARRAY({})".format(_render_native(element)) if element else "ARRAY"
+    if node_type == "MAP":
+        key, value = node.get("keyType"), node.get("valueType")
+        if key and value:
+            return "MAP({}, {})".format(_render_native(key), _render_native(value))
+        return "MAP"
+    if node_type == "FIXED":
+        return "NUMBER({},{})".format(node.get("precision", 38), node.get("scale", 0))
+    if node_type == "REAL":
+        return "FLOAT"
+    if node_type == "TEXT":
+        length = node.get("length")
+        return f"VARCHAR({length})" if length is not None else "VARCHAR"
+    return str(node_type)
+
+
+def fetch_structured_types(con, server: Server, table_name: str) -> dict[str, SchemaProperty] | None:
+    """Return ``{column_name_lower: SchemaProperty}`` for the columns whose real type
+    the collapsed ibis dtype does not convey: structured OBJECT/ARRAY, and leaves with
+    no verifiable logical type. Other columns are omitted. Any failure returns ``None``.
+    """
+    quoted_table = '"{}"'.format(table_name.replace('"', '""'))
+    path = ".".join(part for part in (server.database, server.schema_, quoted_table) if part)
+    identifier = "IDENTIFIER('{}')".format(_quote(path))
+    rows = _rows(con, f"SHOW COLUMNS IN TABLE {identifier}")
+    if not rows:
+        return None
+
+    # SHOW COLUMNS columns: table_name, schema_name, column_name, data_type, ...
+    result: dict[str, SchemaProperty] = {}
+    for row in rows:
+        column_name, data_type = row[2], row[3]
+        if not column_name or not data_type:
+            continue
+        try:
+            node = json.loads(data_type)
+        except (TypeError, ValueError):
+            continue
+        prop = _to_property(node)
+        if has_nesting(prop):
+            # the real native type, for diagnostics the collapsed ibis dtype can't give
+            prop.physicalType = _render_native(node)
+        elif prop.logicalType != UNKNOWN_LOGICAL_TYPE:
+            # scalars and untyped OBJECT/ARRAY: the collapsed ibis dtype says the same
+            continue
+        # an unverifiable leaf (VARIANT, GEOGRAPHY, …) keeps its Snowflake token, which
+        # the ibis dtype renders as the useless 'json'
+        result[str(column_name).lower()] = prop
+    return result or None

{datacontract_cli-1.0.11 → datacontract_cli-1.0.12/datacontract_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.11
+Version: 1.0.12
 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.11 → datacontract_cli-1.0.12}/datacontract_cli.egg-info/SOURCES.txt

@@ -133,6 +133,7 @@ datacontract/engines/ibis/__init__.py
 datacontract/engines/ibis/dtype_category.py
 datacontract/engines/ibis/ibis_check_execute.py
 datacontract/engines/ibis/native_type.py
+datacontract/engines/ibis/snowflake_structured_types.py
 datacontract/engines/ibis/connections/__init__.py
 datacontract/engines/ibis/connections/connect.py
 datacontract/engines/ibis/connections/duckdb_connection.py
@@ -328,6 +329,7 @@ tests/test_require_env.py
 tests/test_resolve.py
 tests/test_resolve_definitions.py
 tests/test_roundtrip_jsonschema.py
+tests/test_snowflake_structured_types.py
 tests/test_sql_type_converter_physicaltype.py
 tests/test_test_api.py
 tests/test_test_athena_iceberg.py

{datacontract_cli-1.0.11 → datacontract_cli-1.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datacontract-cli"
-version = "1.0.11"
+version = "1.0.12"
 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.12/tests/test_dtype_category.py

@@ -0,0 +1,84 @@
+import ibis.expr.datatypes as dt
+from open_data_contract_standard.model import SchemaProperty
+
+from datacontract.engines.checks.type_normalize import (
+    UNKNOWN_LOGICAL_TYPE,
+    schema_property_matches,
+    schema_property_mismatch_reason,
+)
+from datacontract.engines.ibis.dtype_category import (
+    ibis_dtype_category,
+    ibis_dtype_to_schema_property,
+)
+
+
+def test_uuid_maps_to_string_category():
+    # SQL Server `uniqueidentifier` columns surface as ibis UUID; they must be
+    # treated as strings, not "other" (regression for #1354).
+    assert ibis_dtype_category(dt.UUID()) == "string"
+
+
+def test_uuid_dtype_to_schema_property_is_string():
+    prop = ibis_dtype_to_schema_property(dt.UUID())
+    assert prop is not None
+    assert prop.logicalType == "string"
+
+
+def test_uuid_column_matches_string_contract_property():
+    # A property declared as logicalType string (physicalType uniqueidentifier)
+    # must match a column ibis reports as UUID.
+    expected = SchemaProperty(logicalType="string", physicalType="uniqueidentifier")
+    actual = ibis_dtype_to_schema_property(dt.UUID())
+    assert schema_property_matches(expected, actual)
+
+
+def test_json_maps_to_unknown_marker():
+    # Snowflake VARIANT / Postgres JSONB / BigQuery JSON reflect as ibis json.
+    prop = ibis_dtype_to_schema_property(dt.JSON())
+    assert prop.logicalType == UNKNOWN_LOGICAL_TYPE
+    assert prop.physicalType == "json"
+
+
+def test_unsupported_types_are_unknown_and_name_themselves():
+    # binary/null have no ODCS category; the type is kept for the failure message
+    for dtype, name in ((dt.binary, "binary"), (dt.null, "null")):
+        prop = ibis_dtype_to_schema_property(dtype)
+        assert prop.logicalType == UNKNOWN_LOGICAL_TYPE
+        assert prop.physicalType == name
+
+
+def test_map_maps_to_untyped_object():
+    # Snowflake OBJECT reflects as ibis map<string, json>: base confirmable,
+    # inner structure unknowable (properties=None).
+    prop = ibis_dtype_to_schema_property(dt.Map(dt.string, dt.JSON()))
+    assert prop.logicalType == "object"
+    assert prop.properties is None
+
+
+def test_struct_keeps_unsupported_field_as_unknown():
+    # a binary field is present but unverifiable: keep it, so it is not reported missing
+    actual = ibis_dtype_to_schema_property(dt.Struct({"blob": dt.binary}))
+    assert [(p.name, p.logicalType, p.physicalType) for p in actual.properties] == [
+        ("blob", UNKNOWN_LOGICAL_TYPE, "binary")
+    ]
+
+    expected = SchemaProperty(logicalType="object", properties=[SchemaProperty(name="blob", logicalType="string")])
+    assert not schema_property_matches(expected, actual)
+    reason = schema_property_mismatch_reason(expected, actual)
+    assert "missing" not in reason
+    assert "field 'blob': has type 'binary'" in reason
+
+
+def test_struct_still_reports_a_genuinely_absent_field_as_missing():
+    actual = ibis_dtype_to_schema_property(dt.Struct({"blob": dt.binary}))
+    expected = SchemaProperty(logicalType="object", properties=[SchemaProperty(name="city", logicalType="string")])
+    assert not schema_property_matches(expected, actual)
+    assert schema_property_mismatch_reason(expected, actual) == "field 'city' is missing"
+
+
+def test_array_of_json_items_are_unknown():
+    # Snowflake ARRAY reflects as ibis array<json>: array base with an
+    # unknown-typed element.
+    prop = ibis_dtype_to_schema_property(dt.Array(dt.JSON()))
+    assert prop.logicalType == "array"
+    assert prop.items.logicalType == UNKNOWN_LOGICAL_TYPE