Default LookML view table to the view name when unspecified

A LookML view with no sql_table_name and no derived_table implicitly uses a
table named after the view (Looker's default behavior), but the adapter left
table unset, so importing such a view crashed layer validation with
"Model must have a table". Default table to the view name in that case,
while leaving refinements, extends-based views, and abstract
(extension: required) views untouched.

Author: nicosuave

sidemantic/adapters/lookml.py

@@ -35,14 +35,39 @@ class LookMLAdapter(BaseAdapter):
     """
 
     def parse(self, source: str | Path) -> SemanticGraph:
-        """Parse LookML files into semantic graph.
+        """Parse LookML files into a semantic graph.
+
+        Auto-registration to an active SemanticLayer is suppressed while the graph is
+        built, so a tableless view that only gets its default table after refinements/
+        extends are resolved is not validated mid-parse (which would raise inside a
+        ``with SemanticLayer():`` block). The finalized models are registered once.
 
         Args:
             source: Path to .lkml file or directory
 
         Returns:
             Semantic graph with imported models
         """
+        from sidemantic.core.registry import get_current_layer, set_current_layer
+
+        prev_layer = get_current_layer()
+        set_current_layer(None)
+        try:
+            graph = self._build_graph(source)
+        finally:
+            set_current_layer(prev_layer)
+        # Defer auto-registration until models are complete (tables defaulted). Skip
+        # non-queryable models (abstract extension:required bases, unsupported derived
+        # tables) -- they intentionally have no table/sql, so add_model's validation
+        # would reject them; they are templates, not registerable models.
+        if prev_layer is not None:
+            for model in graph.models.values():
+                if model.name not in prev_layer.graph.models and (model.table or model.sql):
+                    prev_layer.add_model(model)
+        return graph
+
+    def _build_graph(self, source: str | Path) -> SemanticGraph:
+        """Build the semantic graph from LookML files (see :meth:`parse`)."""
         graph = SemanticGraph()
         source_path = Path(source)
 
@@ -58,17 +83,50 @@ def parse(self, source: str | Path) -> SemanticGraph:
         for lkml_file in lkml_files:
             self._parse_views_from_file(lkml_file, graph, refinements)
 
+        # Snapshot abstract / unsupported-derived_table flags BEFORE refinement merge:
+        # merge_model REPLACES a base view's meta when the refinement carries metadata,
+        # which would otherwise drop these markers.
+        abstract_pre = {n for n, m in graph.models.items() if (m.meta or {}).get("extension_required")}
+        unsupported_pre = {n for n, m in graph.models.items() if (m.meta or {}).get("unsupported_derived_table")}
+
         # Apply refinements: merge each refinement into its base view
         from sidemantic.core.inheritance import merge_model, resolve_model_inheritance
 
+        refinement_abstract: set[str] = set()
+        refinement_unsupported_dt: set[str] = set()
         for refinement in refinements:
             base_name = refinement.name.lstrip("+")
+            # Record flags from EACH refinement's own meta: a later refinement's merge
+            # can replace the base meta and drop a flag an earlier refinement added.
+            rmeta = refinement.meta or {}
+            if rmeta.get("extension_required"):
+                refinement_abstract.add(base_name)
+            if rmeta.get("unsupported_derived_table"):
+                refinement_unsupported_dt.add(base_name)
             if base_name in graph.models:
                 # Create a copy with the base name for merging
                 refinement_for_merge = refinement.model_copy(update={"name": base_name})
                 merged = merge_model(refinement_for_merge, graph.models[base_name])
                 graph.models[base_name] = merged
 
+        # Union the pre-merge snapshot, every refinement's own flags, and the post-merge
+        # state (so a flag added by ANY refinement is caught even if a later refinement
+        # replaced the meta). Resolve this BEFORE extends so a concrete child that only
+        # INHERITS abstractness is not treated as abstract. Record extends parents too,
+        # so descendants of an unsupported derived table are detectable after resolution
+        # clears `extends`.
+        abstract_views = (
+            abstract_pre
+            | refinement_abstract
+            | {n for n, m in graph.models.items() if (m.meta or {}).get("extension_required")}
+        )
+        unsupported_dt_views = (
+            unsupported_pre
+            | refinement_unsupported_dt
+            | {n for n, m in graph.models.items() if (m.meta or {}).get("unsupported_derived_table")}
+        )
+        extends_parent = {n: m.extends for n, m in graph.models.items() if m.extends}
+
         # Resolve extends chains. Pre-filter to models whose full chain
         # is present so one broken/missing parent doesn't block valid ones.
         def _chain_resolvable(name: str, visited: set[str] | None = None) -> bool:
@@ -92,10 +150,63 @@ def _chain_resolvable(name: str, visited: set[str] | None = None) -> bool:
             resolved.update(unresolvable)
             graph.models = resolved
 
+        def _extends_chain_has(name: str, flagset: set[str]) -> bool:
+            """True if name or any of its extends-ancestors is in flagset."""
+            seen: set[str] = set()
+            cur: str | None = name
+            while cur is not None and cur not in seen:
+                if cur in flagset:
+                    return True
+                seen.add(cur)
+                cur = extends_parent.get(cur)
+            return False
+
+        # Apply the implicit "table = view name" default AFTER refinements and extends
+        # are resolved, so a view whose fields/name come from a refinement or whose
+        # parent was tableless still gets its OWN name as the table (Looker's behavior).
+        # Skip abstract views, still-unresolved-extends, fieldless views, and views that
+        # are (or extend) an unsupported derived table. Abstractness is NOT inherited
+        # through extends (a concrete child of an abstract base gets its own table), but
+        # an unsupported derived table IS inherited by descendants.
+        def _apply_default_tables():
+            for model_name, model in graph.models.items():
+                if (
+                    model.table is None
+                    and model.sql is None
+                    and not model.extends
+                    and model_name not in abstract_views
+                    and not _extends_chain_has(model_name, unsupported_dt_views)
+                    and not (model.meta or {}).get("unsupported_derived_table")
+                    and (model.dimensions or model.metrics or model.segments)
+                ):
+                    model.table = model_name
+
+        _apply_default_tables()
+
         # Second pass: parse explores and add relationships
         for lkml_file in lkml_files:
             self._parse_explores_from_file(lkml_file, graph)
 
+        # Re-apply the default: explores can add segments (sql_always_where /
+        # always_filter) to an otherwise-fieldless view, which only now makes it
+        # eligible for the implicit table default.
+        _apply_default_tables()
+
+        # Re-assert non-queryable markers on models intentionally left tableless. A
+        # refinement can OVERWRITE a view's meta (dropping an `extension_required` flag an
+        # earlier refinement added) even though abstractness is tracked in side-sets, so
+        # without this the loader (which keys off final meta) would try to register and
+        # reject them. Set the flag definitively now, after all merges.
+        for model_name, model in graph.models.items():
+            if model.table is not None or model.sql is not None:
+                continue
+            if model_name in abstract_views:
+                model.meta = {**(model.meta or {}), "extension_required": True}
+            elif _extends_chain_has(model_name, unsupported_dt_views) or (model.meta or {}).get(
+                "unsupported_derived_table"
+            ):
+                model.meta = {**(model.meta or {}), "unsupported_derived_table": True}
+
         # Rebuild adjacency graph now that relationships have been added
         graph.build_adjacency()
 
@@ -966,6 +1077,14 @@ def _folded_measure_filter(m_def):
             elif isinstance(extends_list, str):
                 extends = extends_list
 
+        # A LookML view with no sql_table_name/derived_table implicitly uses a table
+        # named after the view (Looker's default). A view with a derived_table the
+        # adapter cannot turn into SQL must NOT get such a default; mark it so the
+        # post-merge pass skips it (the raw derived_table dict is not retained).
+        unsupported_derived_table = bool(view_def.get("derived_table")) and sql is None
+        if unsupported_derived_table:
+            model_meta["unsupported_derived_table"] = True
+
         # Build kwargs conditionally so that unset scalars don't appear in
         # model_fields_set. This matters for refinements: merge_model treats
         # every field in model_fields_set as an explicit child override, so

sidemantic/loaders.py

@@ -13,6 +13,40 @@
     from sidemantic.core.semantic_layer import SemanticLayer
 
 
+def _is_registerable_model(model) -> bool:
+    """True unless ``model`` is an INTENTIONAL non-queryable template that should be
+    skipped rather than registered/validated.
+
+    Only LookML's ``extension: required`` abstract bases and unsupported derived tables
+    (kept in the parsed graph as tableless templates, marked in ``meta``) are skipped --
+    ``add_model`` would reject them and abort loading an otherwise-valid project. Any
+    OTHER tableless model (e.g. an erroneous Hex view missing its base) is left in so
+    downstream validation still surfaces the real error.
+    """
+    if model.table or model.sql or getattr(model, "dax", None) or getattr(model, "source_uri", None):
+        return True
+    meta = model.meta or {}
+    return not (meta.get("extension_required") or meta.get("unsupported_derived_table"))
+
+
+def _drop_non_registerable_models(all_models: dict) -> dict:
+    """Filter to registerable models AND strip any relationship targeting a dropped one.
+
+    An explore may have already added a relationship pointing at a now-skipped template
+    (e.g. an `extension: required` join target); leaving it would dangle and fail
+    ``sidemantic validate``. Only relationships to models THIS function drops are removed
+    -- a relationship to a never-defined model is a real error that validation must still
+    surface, so it is left intact. Returns the filtered dict (mutating survivors' rels).
+    """
+    kept = {name: model for name, model in all_models.items() if _is_registerable_model(model)}
+    dropped = set(all_models) - set(kept)
+    for model in kept.values():
+        rels = getattr(model, "relationships", None)
+        if rels:
+            model.relationships = [r for r in rels if r.name not in dropped]
+    return kept
+
+
 def load_from_directory(
     layer: "SemanticLayer",
     directory: str | Path,
@@ -331,10 +365,16 @@ def load_from_directory(
     # table pair.
     _apply_snowflake_pending_relationships(all_models, all_pending_relationships)
 
+    # Drop non-queryable template models (LookML `extension: required` abstract bases /
+    # unsupported derived tables) BEFORE inference + registration, so FK inference never
+    # targets a model that won't be registered (which would leave a dangling relationship)
+    # and add_model never rejects a template that was never meant to be queried.
+    all_models = _drop_non_registerable_models(all_models)
+
     # Infer cross-model relationships based on naming conventions
     _infer_relationships(all_models)
 
-    # Add all models to the layer (now with relationships)
+    # Add all models to the layer (now with relationships).
     for model in all_models.values():
         if model.name not in layer.graph.models:
             layer.add_model(model)
@@ -420,6 +460,8 @@ def _load_sml_directory(layer: "SemanticLayer", directory: Path, all_models: dic
         if not hasattr(model, "_source_file"):
             model._source_file = str(directory)
     all_models.update(graph.models)
+    # Drop non-queryable templates (+ their dangling rels) before inference + registration.
+    all_models = _drop_non_registerable_models(all_models)
     _infer_relationships(all_models)
     for model in all_models.values():
         if model.name not in layer.graph.models: