sqlbuild 0.113.4__tar.gz → 0.113.6__tar.gz

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/Cargo.lock

@@ -310,8 +310,8 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "polyglot-sql"
-version = "0.12.2"
-source = "git+https://github.com/chio-labs/polyglot.git?rev=dd7154035566933a0f9acae17a2c102afb4dbfde#dd7154035566933a0f9acae17a2c102afb4dbfde"
+version = "0.12.3"
+source = "git+https://github.com/chio-labs/polyglot.git?rev=f3774102f518f716cd648e4fdebb9d8558a0b63a#f3774102f518f716cd648e4fdebb9d8558a0b63a"
 dependencies = [
  "polyglot-sql-ast-derive",
  "serde",
@@ -323,8 +323,8 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.12.2"
-source = "git+https://github.com/chio-labs/polyglot.git?rev=dd7154035566933a0f9acae17a2c102afb4dbfde#dd7154035566933a0f9acae17a2c102afb4dbfde"
+version = "0.12.3"
+source = "git+https://github.com/chio-labs/polyglot.git?rev=f3774102f518f716cd648e4fdebb9d8558a0b63a#f3774102f518f716cd648e4fdebb9d8558a0b63a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -592,7 +592,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.113.4"
+version = "0.113.6"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/Cargo.toml

@@ -13,7 +13,7 @@ fensu-policy = "=0.22.0"
 globset = "0.4"
 proc-macro2 = { version = "1", features = ["span-locations"] }
 pyo3 = { version = "0.26", features = ["abi3-py312"] }
-polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "dd7154035566933a0f9acae17a2c102afb4dbfde", default-features = false, features = [
+polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "f3774102f518f716cd648e4fdebb9d8558a0b63a", default-features = false, features = [
     "ast-tools",
     "builder",
     "dialect-bigquery",

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.113.4
+Version: 0.113.6
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0
-Requires-Dist: polyglot-sql-chio==0.12.2
+Requires-Dist: polyglot-sql-chio==0.12.3
 Requires-Dist: pydantic-settings>=2,<3
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.113.4"
+version = "0.113.6"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.113.4"
+version = "0.113.6"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,7 +15,7 @@ dependencies = [
   "duckdb>=1.3.2",
   "filelock>=3.20.3",
   "orjson>=3.10.0",
-  "polyglot-sql-chio==0.12.2",
+  "polyglot-sql-chio==0.12.3",
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/cli/commands/_helpers/compile/pipeline.py

@@ -204,6 +204,7 @@ def _analyze_compile_project(
             dialect=adapter.sql_analysis_dialect() or "generic",
             selected_keys=selected_keys if select or exclude else None,
             prepared_sql=early_lint.preparation,
+            expansion_reuse=early_lint.expansion_reuse,
         )
         _ = complete_compile_phase(
             status=status,

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/compile/_helpers/attachment/scope_relationships.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from sqlbuild.compiler.compile._helpers.render.macros import find_macro_call_names
+from sqlbuild.compiler.compile._helpers.render.macros import (
+    find_macro_call_names,
+    find_nested_macro_call_names,
+)
 from sqlbuild.compiler.compile._helpers.scenarios.core import (
     extract_sql_scenario_expected_model_names,
 )
@@ -30,12 +33,15 @@ from sqlbuild.compiler.scopes.models import (
     DeclarationRecord,
     GrantRecord,
     ResourceIdentity,
+    ResourceRecord,
     ScopeIndex,
     ScopeLookup,
     VisibilityResolution,
 )
 from sqlbuild.compiler.scopes.types import DeclarationKind, GrantKind, ResourceKind, ScopeKind
 
+type _SharedDeclarations = dict[tuple[str, str], tuple[DeclarationRecord, ...]]
+
 
 def build_scope_relationship_grants(
     *, discovered_inputs: DiscoveredProjectInputs, index: ScopeIndex
@@ -43,11 +49,16 @@ def build_scope_relationship_grants(
     """Return expected-model grants while retaining independent extraction faults."""
 
     lookup: ScopeLookup = build_scope_lookup(index=index)
+    shared_declarations: _SharedDeclarations = _shared_declarations_by_directory(lookup=lookup)
     test_grants, test_faults = _test_relationship_grants(
-        discovered_inputs=discovered_inputs, lookup=lookup
+        discovered_inputs=discovered_inputs,
+        lookup=lookup,
+        shared_declarations=shared_declarations,
     )
     scenario_grants, scenario_faults = _scenario_relationship_grants(
-        discovered_inputs=discovered_inputs, lookup=lookup
+        discovered_inputs=discovered_inputs,
+        lookup=lookup,
+        shared_declarations=shared_declarations,
     )
     return ScopeRelationshipBuild(
         grants=tuple(dict.fromkeys((*test_grants, *scenario_grants))),
@@ -56,7 +67,10 @@ def build_scope_relationship_grants(
 
 
 def _test_relationship_grants(
-    *, discovered_inputs: DiscoveredProjectInputs, lookup: ScopeLookup
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    lookup: ScopeLookup,
+    shared_declarations: _SharedDeclarations,
 ) -> tuple[tuple[GrantRecord, ...], tuple[ScopeRelationshipFault, ...]]:
     grants: list[GrantRecord] = []
     faults: list[ScopeRelationshipFault] = []
@@ -75,7 +89,8 @@ def _test_relationship_grants(
                             ResourceKind.TEST, block.name or test_file.relative_path.stem
                         ),
                         expected_model_names=expected_names,
-                        include_macros=True,
+                        shared_declarations=shared_declarations,
+                        called_macros=frozenset(find_nested_macro_call_names(block.sql_body)),
                     )
                 )
                 if block.mode is SqlTestMode.MACRO:
@@ -95,7 +110,10 @@ def _test_relationship_grants(
 
 
 def _scenario_relationship_grants(
-    *, discovered_inputs: DiscoveredProjectInputs, lookup: ScopeLookup
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    lookup: ScopeLookup,
+    shared_declarations: _SharedDeclarations,
 ) -> tuple[tuple[GrantRecord, ...], tuple[ScopeRelationshipFault, ...]]:
     grants: list[GrantRecord] = []
     faults: list[ScopeRelationshipFault] = []
@@ -109,6 +127,7 @@ def _scenario_relationship_grants(
                     lookup=lookup,
                     resource=ResourceIdentity(ResourceKind.SCENARIO, scenario.name),
                     expected_model_names=expected_names,
+                    shared_declarations=shared_declarations,
                 )
             )
         except Exception as error:
@@ -121,21 +140,18 @@ def _expected_model_grants(
     lookup: ScopeLookup,
     resource: ResourceIdentity,
     expected_model_names: tuple[str, ...],
-    include_macros: bool = False,
+    shared_declarations: _SharedDeclarations,
+    called_macros: frozenset[str] = frozenset(),
 ) -> list[GrantRecord]:
     grants: list[GrantRecord] = []
     for model_name in expected_model_names:
         through: ResourceIdentity = ResourceIdentity(ResourceKind.MODEL, model_name)
-        resolution: VisibilityResolution = resolve_scope_visibility(lookup=lookup, target=through)
-        for visible in resolution.visible:
-            records: tuple[DeclarationRecord, ...] = lookup.declarations.get(
-                visible.declaration, ()
-            )
-            if not records:
-                continue
-            declaration: DeclarationRecord = records[0]
-            if declaration.scope is ScopeKind.PRIVATE or (
-                declaration.identity.kind is DeclarationKind.MACRO and not include_macros
+        for declaration in _shared_visible_declarations(
+            lookup=lookup, resource=through, shared=shared_declarations
+        ):
+            if (
+                declaration.identity.kind is DeclarationKind.MACRO
+                and declaration.identity.name not in called_macros
             ):
                 continue
             grants.append(
@@ -148,6 +164,54 @@ def _expected_model_grants(
     return grants
 
 
+def _shared_declarations_by_directory(*, lookup: ScopeLookup) -> _SharedDeclarations:
+    """Resolve shared non-private visibility once per model directory and ownership root."""
+
+    representatives: dict[tuple[str, str], ResourceIdentity] = {}
+    for identity, records in lookup.resources.items():
+        if (
+            identity.kind is ResourceKind.MODEL
+            and len(records) == 1
+            and identity not in lookup.grants_by_resource
+        ):
+            representatives.setdefault(_directory_key(record=records[0]), identity)
+    return {
+        key: _resolve_shared_declarations(lookup=lookup, resource=identity)
+        for key, identity in representatives.items()
+    }
+
+
+def _directory_key(*, record: ResourceRecord) -> tuple[str, str]:
+    return (Path(record.path).parent.as_posix(), record.ownership_root.path)
+
+
+def _shared_visible_declarations(
+    *, lookup: ScopeLookup, resource: ResourceIdentity, shared: _SharedDeclarations
+) -> tuple[DeclarationRecord, ...]:
+    """Return non-private declarations a resource sees, reusing its directory's resolution."""
+
+    records: tuple[ResourceRecord, ...] = lookup.resources.get(resource, ())
+    if len(records) == 1 and resource not in lookup.grants_by_resource:
+        directory_declarations: tuple[DeclarationRecord, ...] | None = shared.get(
+            _directory_key(record=records[0])
+        )
+        if directory_declarations is not None:
+            return directory_declarations
+    return _resolve_shared_declarations(lookup=lookup, resource=resource)
+
+
+def _resolve_shared_declarations(
+    *, lookup: ScopeLookup, resource: ResourceIdentity
+) -> tuple[DeclarationRecord, ...]:
+    resolution: VisibilityResolution = resolve_scope_visibility(lookup=lookup, target=resource)
+    declarations: list[DeclarationRecord] = []
+    for visible in resolution.visible:
+        records: tuple[DeclarationRecord, ...] = lookup.declarations.get(visible.declaration, ())
+        if records and records[0].scope is not ScopeKind.PRIVATE:
+            declarations.append(records[0])
+    return tuple(declarations)
+
+
 def _tested_macro_grants(
     *, lookup: ScopeLookup, resource: ResourceIdentity, sql: str, file_label: str
 ) -> list[GrantRecord]:

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/compile/_helpers/render/macros.py

@@ -1291,9 +1291,23 @@ def find_macro_call_names(sql: str) -> tuple[str, ...]:
     )
 
 
+def find_nested_macro_call_names(sql: str) -> tuple[str, ...]:
+    """Return unique macro call names, including calls inside other calls' arguments."""
+
+    return tuple(
+        name
+        for name in _scan_sqlbuild_call_names(sql=sql, include_nested=True)
+        if name not in DECLARATION_REFERENCE_NAMES
+    )
+
+
 def _find_sqlbuild_call_names(sql: str) -> tuple[str, ...]:
     """Return executable SQLBuild call names, excluding quoted and commented text."""
 
+    return _scan_sqlbuild_call_names(sql=sql, include_nested=False)
+
+
+def _scan_sqlbuild_call_names(*, sql: str, include_nested: bool) -> tuple[str, ...]:
     if MACRO_TOKEN not in sql:
         return ()
 
@@ -1311,7 +1325,11 @@ def _find_sqlbuild_call_names(sql: str) -> tuple[str, ...]:
         opening_paren_index: int = _skip_whitespace(
             sql=sql, start_index=macro_start_index + 1 + len(macro_name)
         )
-        cursor = _find_matching_paren(sql=sql, opening_paren_index=opening_paren_index) + 1
+        cursor = (
+            opening_paren_index + 1
+            if include_nested
+            else _find_matching_paren(sql=sql, opening_paren_index=opening_paren_index) + 1
+        )
     return tuple(names)
 
 

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/compile/main/_build_compile_inputs.py

@@ -235,6 +235,7 @@ def build_compile_inputs(
         diagnostics=diagnostics,
         external_sql_reference_resolver=external_sql_reference_resolver,
         scope_index=declaration_scope.index,
+        declaration_scope=declaration_scope,
     )
 
 

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/compile/main/sql_expansion_context.py

@@ -39,6 +39,7 @@ def build_sql_expansion_context(
     value_renderer: TypedSqlValueRenderer,
     cli_vars: dict[str, object] | None = None,
     discovered_inputs: DiscoveredProjectInputs | None = None,
+    declaration_scope: DeclarationScopeBuild | None = None,
 ) -> SqlExpansionContext:
     """Assemble project vars, macros and declarations for SQL expansion."""
 
@@ -53,13 +54,10 @@ def build_sql_expansion_context(
         target_config=None,
         cli_vars={} if cli_vars is None else cli_vars,
     )
-    loaded_macros: dict[str, LoadedMacro] = load_project_macros(
-        effective_discovered_inputs.macro_files
-    )
-    declaration_scope: DeclarationScopeBuild = build_declaration_scope(
-        discovered_inputs=effective_discovered_inputs,
-        loaded_macros=loaded_macros,
+    scope: DeclarationScopeBuild = declaration_scope or _build_declaration_scope(
+        discovered_inputs=effective_discovered_inputs
     )
+    loaded_macros: dict[str, LoadedMacro] = scope.loaded_macros
     enums: dict[str, EnumDeclaration]
     constants: dict[str, ConstantDeclaration]
     enums, constants = build_public_declaration_indexes(
@@ -99,5 +97,14 @@ def build_sql_expansion_context(
             declaration_override=None,
         ),
         local_declarations=local_declarations,
-        declaration_resolver=declaration_scope.resolver,
+        declaration_resolver=scope.resolver,
+    )
+
+
+def _build_declaration_scope(
+    *, discovered_inputs: DiscoveredProjectInputs
+) -> DeclarationScopeBuild:
+    return build_declaration_scope(
+        discovered_inputs=discovered_inputs,
+        loaded_macros=load_project_macros(discovered_inputs.macro_files),
     )

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/compile/models.py

@@ -835,6 +835,7 @@ class CompileProjectInputs:
     diagnostics: tuple[CompilerDiagnostic, ...] = field(default_factory=tuple)
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None
     scope_index: ScopeIndex = field(default_factory=ScopeIndex)
+    declaration_scope: DeclarationScopeBuild | None = field(default=None, repr=False, compare=False)
 
 
 @dataclass(frozen=True)

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/planner/_helpers/sql_tests/comments.py

@@ -28,6 +28,8 @@ def uncommented_matches_by_pattern(
 ) -> tuple[tuple[re.Match[str], ...], ...]:
     """Find matches for multiple patterns with one protected-region scan."""
 
+    if all(pattern.search(sql) is None for pattern in patterns):
+        return tuple(() for _pattern in patterns)
     protected_ranges: tuple[tuple[int, int], ...] = tuple(
         (match.start(), match.end()) for match in _SQL_NON_CODE_PATTERN.finditer(sql)
     )

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/scopes/_helpers/lookup.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterable
+from functools import lru_cache
 from types import MappingProxyType
 
 from sqlbuild.compiler.scopes._helpers.identities import format_identity
@@ -128,6 +129,7 @@ def build_lookup(*, index: ScopeIndex) -> ScopeLookup:
     )
 
 
+@lru_cache(maxsize=65_536)
 def identity_key(identity: ResourceIdentity | DeclarationIdentity) -> str:
     return format_identity(identity=identity)
 

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/scopes/_helpers/report_projection.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Iterable
 from typing import cast
 
-from sqlbuild.compiler.scopes._helpers.identities import format_identity
+from sqlbuild.compiler.scopes._helpers.lookup import identity_key
 from sqlbuild.compiler.scopes._helpers.paths import normalize_path
 from sqlbuild.compiler.scopes.constants import (
     DECLARATION_GROUP_DIRECTORY,
@@ -38,7 +38,7 @@ def build_projection(*, index: ScopeIndex) -> dict[str, JsonValue]:
     declarations: list[DeclarationRecord] = sorted(
         index.declarations,
         key=lambda item: (
-            format_identity(identity=item.identity),
+            identity_key(item.identity),
             item.path,
             item.line,
             item.column,
@@ -46,41 +46,41 @@ def build_projection(*, index: ScopeIndex) -> dict[str, JsonValue]:
     )
     resources: list[ResourceRecord] = sorted(
         index.resources,
-        key=lambda item: (format_identity(identity=item.identity), item.path),
+        key=lambda item: (identity_key(item.identity), item.path),
     )
     grants: list[GrantRecord] = sorted(
         index.grants,
         key=lambda item: (
-            format_identity(identity=item.resource),
-            format_identity(identity=item.declaration),
-            format_identity(identity=item.through),
+            identity_key(item.resource),
+            identity_key(item.declaration),
+            identity_key(item.through),
             item.kind.value,
         ),
     )
     usages: list[UsageRecord] = sorted(
         index.usages,
         key=lambda item: (
-            format_identity(identity=item.consumer),
-            format_identity(identity=item.declaration),
+            identity_key(item.consumer),
+            identity_key(item.declaration),
             item.kind.value,
-            format_identity(identity=item.through) if item.through is not None else "",
+            identity_key(item.through) if item.through is not None else "",
             item.enum_member or "",
         ),
     )
     visibility: list[VisibilityRecord] = sorted(
         index.visibility,
         key=lambda item: (
-            format_identity(identity=item.resource),
-            format_identity(identity=item.declaration),
+            identity_key(item.resource),
+            identity_key(item.declaration),
             item.reason.value,
-            format_identity(identity=item.through) if item.through is not None else "",
+            identity_key(item.through) if item.through is not None else "",
         ),
     )
     inaccessible: list[InaccessibleRecord] = sorted(
         index.inaccessible,
         key=lambda item: (
-            format_identity(identity=item.resource),
-            format_identity(identity=item.declaration),
+            identity_key(item.resource),
+            identity_key(item.declaration),
             item.reason.value,
         ),
     )
@@ -103,7 +103,7 @@ def build_projection(*, index: ScopeIndex) -> dict[str, JsonValue]:
         ],
         "resources": [
             {
-                "identity": format_identity(identity=record.identity),
+                "identity": identity_key(record.identity),
                 "kind": record.identity.kind.value,
                 "name": record.identity.name,
                 "path": safe_scope_path(path=record.path),
@@ -119,40 +119,36 @@ def build_projection(*, index: ScopeIndex) -> dict[str, JsonValue]:
         "declarations": [_declaration_projection(record=record) for record in declarations],
         "grants": [
             {
-                "resource": format_identity(identity=record.resource),
-                "declaration": format_identity(identity=record.declaration),
-                "through": format_identity(identity=record.through),
+                "resource": identity_key(record.resource),
+                "declaration": identity_key(record.declaration),
+                "through": identity_key(record.through),
                 "kind": record.kind.value,
             }
             for record in grants
         ],
         "usages": [
             {
-                "consumer": format_identity(identity=record.consumer),
-                "declaration": format_identity(identity=record.declaration),
+                "consumer": identity_key(record.consumer),
+                "declaration": identity_key(record.declaration),
                 "kind": record.kind.value,
-                "through": (
-                    format_identity(identity=record.through) if record.through is not None else None
-                ),
+                "through": (identity_key(record.through) if record.through is not None else None),
                 "enum_member": record.enum_member,
             }
             for record in usages
         ],
         "visibility": [
             {
-                "resource": format_identity(identity=record.resource),
-                "declaration": format_identity(identity=record.declaration),
+                "resource": identity_key(record.resource),
+                "declaration": identity_key(record.declaration),
                 "reason": record.reason.value,
-                "through": (
-                    format_identity(identity=record.through) if record.through is not None else None
-                ),
+                "through": (identity_key(record.through) if record.through is not None else None),
             }
             for record in visibility
         ],
         "inaccessible": [
             {
-                "resource": format_identity(identity=record.resource),
-                "declaration": format_identity(identity=record.declaration),
+                "resource": identity_key(record.resource),
+                "declaration": identity_key(record.declaration),
                 "reason": record.reason.value,
             }
             for record in inaccessible
@@ -172,14 +168,12 @@ def build_projection(*, index: ScopeIndex) -> dict[str, JsonValue]:
                 "line": diagnostic.line,
                 "column": diagnostic.column,
                 "declaration": (
-                    format_identity(identity=diagnostic.declaration)
+                    identity_key(diagnostic.declaration)
                     if diagnostic.declaration is not None
                     else None
                 ),
                 "resource": (
-                    format_identity(identity=diagnostic.resource)
-                    if diagnostic.resource is not None
-                    else None
+                    identity_key(diagnostic.resource) if diagnostic.resource is not None else None
                 ),
             }
             for diagnostic in sorted(
@@ -201,7 +195,7 @@ def _declaration_projection(*, record: DeclarationRecord) -> dict[str, JsonValue
         metadata["macro"] = {
             "parameters": list(record.macro.parameters),
             "dependencies": sorted(
-                format_identity(identity=identity) for identity in record.macro.dependencies
+                identity_key(identity) for identity in record.macro.dependencies
             ),
             "source_digest": record.macro.source_digest,
         }
@@ -220,13 +214,11 @@ def _declaration_projection(*, record: DeclarationRecord) -> dict[str, JsonValue
         }
     role, visibility, role_root, bucket_path = _declaration_container(record=record)
     return {
-        "identity": format_identity(identity=record.identity),
+        "identity": identity_key(record.identity),
         "kind": record.identity.kind.value,
         "name": record.identity.name,
         "owner": (
-            format_identity(identity=record.identity.owner)
-            if record.identity.owner is not None
-            else None
+            identity_key(record.identity.owner) if record.identity.owner is not None else None
         ),
         "path": safe_scope_path(path=record.path),
         "line": record.line,
@@ -275,15 +267,11 @@ def declaration_report(
     """Project a declaration without source, values, callables, or process data."""
 
     usages: tuple[UsageRecord, ...] = lookup.usages_by_declaration.get(record.identity, ())
-    consumers: tuple[str, ...] = tuple(
-        sorted({format_identity(identity=usage.consumer) for usage in usages})
-    )
+    consumers: tuple[str, ...] = tuple(sorted({identity_key(usage.consumer) for usage in usages}))
     dependencies: tuple[str, ...] = ()
     metadata: list[tuple[str, object]] = []
     if record.macro is not None:
-        dependencies = tuple(
-            sorted(format_identity(identity=item) for item in record.macro.dependencies)
-        )
+        dependencies = tuple(sorted(identity_key(item) for item in record.macro.dependencies))
         metadata.extend(
             (("parameters", record.macro.parameters), ("dependency_count", len(dependencies)))
         )
@@ -326,7 +314,7 @@ def declaration_report(
     grants: tuple[str, ...] = tuple(
         sorted(
             {
-                format_identity(identity=grant.resource)
+                identity_key(grant.resource)
                 for grant in lookup.index.grants
                 if grant.declaration == record.identity
             }
@@ -334,14 +322,10 @@ def declaration_report(
     )
     required_scope, required_path, promotion = required_placement(lookup=lookup, record=record)
     return DeclarationReport(
-        identity=format_identity(identity=record.identity),
+        identity=identity_key(record.identity),
         kind=record.identity.kind.value,
         name=record.identity.name,
-        owner=(
-            format_identity(identity=record.identity.owner)
-            if record.identity.owner is not None
-            else None
-        ),
+        owner=(identity_key(record.identity.owner) if record.identity.owner is not None else None),
         definition=SourceLocation(safe_scope_path(path=record.path), record.line, record.column),
         scope=record.scope.value,
         owning_path=record.owning_path,
@@ -406,7 +390,7 @@ def records_for_identities(
         sorted(
             records,
             key=lambda item: (
-                format_identity(identity=item.identity),
+                identity_key(item.identity),
                 item.path,
                 item.line,
                 item.column,
@@ -430,4 +414,4 @@ def _identity_text(*, identity: DeclarationIdentity | object | None) -> str | No
     typed_identity: DeclarationIdentity | ResourceIdentity = cast(
         "DeclarationIdentity | ResourceIdentity", identity
     )
-    return format_identity(identity=typed_identity)
+    return identity_key(typed_identity)

{sqlbuild-0.113.4 → sqlbuild-0.113.6}/src/sqlbuild/compiler/scopes/_helpers/visibility.py

@@ -15,6 +15,7 @@ from sqlbuild.compiler.scopes.constants import (
 from sqlbuild.compiler.scopes.models import (
     DeclarationIdentity,
     DeclarationRecord,
+    GrantRecord,
     InaccessibleRecord,
     OwnershipRoot,
     ResourceIdentity,
@@ -66,9 +67,9 @@ def resolve_visibility(
     inaccessible: list[InaccessibleRecord] = []
     resource: ResourceRecord
     for resource in query.matches:
-        granted_declarations: set[DeclarationIdentity] = {
-            grant.declaration for grant in lookup.grants_by_resource.get(resource.identity, ())
-        }
+        grants_by_declaration: dict[DeclarationIdentity, list[GrantRecord]] = {}
+        for grant in lookup.grants_by_resource.get(resource.identity, ()):
+            grants_by_declaration.setdefault(grant.declaration, []).append(grant)
         declaration: DeclarationRecord
         for declaration in lookup.index.declarations:
             positive: VisibilityReason | None = _visibility_reason(
@@ -76,7 +77,10 @@ def resolve_visibility(
             )
             if positive is not None:
                 visible.append(VisibilityRecord(resource.identity, declaration.identity, positive))
-            if declaration.identity in granted_declarations:
+            declaration_grants: list[GrantRecord] | None = grants_by_declaration.get(
+                declaration.identity
+            )
+            if declaration_grants is not None:
                 visible.extend(
                     VisibilityRecord(
                         resource.identity,
@@ -88,8 +92,7 @@ def resolve_visibility(
                         ),
                         grant.through,
                     )
-                    for grant in lookup.grants_by_resource.get(resource.identity, ())
-                    if grant.declaration == declaration.identity
+                    for grant in declaration_grants
                 )
             elif positive is None:
                 inaccessible.append(