@google-cloud/kcmd 0.0.0-stage → 0.1.0

package/build/ts/kcmd/semantic/resolve_profiles.js

@@ -0,0 +1,1822 @@
+"use strict";
+// Applies a chosen binding profile to a logical semantic model, and prunes what
+// the resulting binding cannot answer.
+//
+// A model is authored as ONE logical declaration (entities, fields,
+// relationships, metrics, the grain, and the graph shape) plus zero or more
+// BINDING PROFILES that supply the physical facets it leaves open: each entity's
+// `source`, each field's column (`expression`) and each action's `executor`.
+// `kcmd push` applies the profile each deployment names to the logical model
+// BY NAME and deploys the result. See docs/semantic-model/profiles.md.
+//
+// Two passes live here:
+//   - applyProfile applies a profile, read into a ProfileSpec, to a loaded
+//     model. Push, `kcmd profiles`, the runtime and the profile checks apply a
+//     profile file this way, and a profile held in memory is applied the same
+//     way. Push, `kcmd profiles` and the runtime start at profileForDocument,
+//     which finds the profile by name and loads the model file on its own
+//     (applyToDocument). A file is read with loadProfileFile.
+//     applyProfileSpec then checks what the profile may set
+//     (profileApplyError), sets the values (applyBindings) and gives the
+//     warnings (warningsAfterProfile). applyProfile and applyProfileFile take
+//     the same steps for a model already loaded, and the completeness check
+//     applies the bindings with applyBindings.
+//   - pruneUnavailable runs over the loaded IR and drops each field left unbound
+//     or excluded, every field that reads one of those, and every metric whose
+//     expression reads any of them, returning the pruned model and a
+//     per-profile availability report. Keys and join columns are physical
+//     columns rather than fields, so pruning fields never removes an entity or
+//     a relationship.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORT_TRANSPILE_COMMAND = exports.DEFAULT_PROFILE = void 0;
+exports.plainCopy = plainCopy;
+exports.pruneUnavailable = pruneUnavailable;
+exports.withoutExclusions = withoutExclusions;
+exports.resolvedEntities = resolvedEntities;
+exports.inheritedNamesOf = inheritedNamesOf;
+exports.loadProfileFile = loadProfileFile;
+exports.applyProfile = applyProfile;
+exports.applyProfileFile = applyProfileFile;
+exports.declaredProfiles = declaredProfiles;
+exports.profileForDocument = profileForDocument;
+exports.profileErrorMessage = profileErrorMessage;
+exports.unknownProfileMessage = unknownProfileMessage;
+exports.reservedProfileNameError = reservedProfileNameError;
+exports.profileSpecOf = profileSpecOf;
+exports.expressionSources = expressionSources;
+exports.noTextFor = noTextFor;
+exports.tableDialects = tableDialects;
+exports.fieldsOnTables = fieldsOnTables;
+exports.importTranspiles = importTranspiles;
+exports.sourcesDialect = sourcesDialect;
+exports.validateProfileCompleteness = validateProfileCompleteness;
+exports.validateProfileConsistency = validateProfileConsistency;
+exports.inheritanceErrorOf = inheritanceErrorOf;
+exports.columnBinding = columnBinding;
+exports.statesKey = statesKey;
+const yaml = __importStar(require("yaml"));
+const ir_1 = require("./ir");
+const loader_1 = require("./loader");
+const names_1 = require("./names");
+const resolve_inheritance_1 = require("./resolve_inheritance");
+const sql_expr_utils_1 = require("./sql_expr_utils");
+const transpile_1 = require("./transpile");
+const yaml_options_1 = require("./yaml_options");
+// The implicit profile: the inline bindings already in the model document (the
+// combined single-file form).
+exports.DEFAULT_PROFILE = 'default';
+// Keys a profile may carry at each level. Everything else is a logical
+// declaration the model owns; setting it in a profile is rejected so swapping a
+// profile can move data but never change what the model means.
+const PROFILE_FILE_KEYS = new Set([
+    'name', 'entities', 'relationships', 'metrics_exclude', 'actions',
+]);
+const PROFILE_ENTITY_KEYS = new Set([
+    'name', 'source', 'primary_key', 'unique_keys', 'fields', 'fields_exclude',
+]);
+const PROFILE_RELATIONSHIP_KEYS = new Set(['name', 'from_columns', 'to_columns']);
+const PROFILE_FIELD_KEYS = new Set(['name', 'expression']);
+const PROFILE_ACTION_KEYS = new Set(['name', 'executor']);
+// A deep copy in which every node is its own object. structuredClone keeps a
+// YAML anchor and its aliases as one object, so an edit through one alias
+// would change every node that shares it.
+function plainCopy(value) {
+    if (Array.isArray(value))
+        return value.map(plainCopy);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, plainCopy(v)]));
+    }
+    return value;
+}
+function notAllowed(where, key) {
+    return `${where} sets '${key}', which a profile may not set; a profile ` +
+        `carries only physical bindings, and the logical model owns everything ` +
+        `else`;
+}
+/**
+ * Returns a clone of `model` reduced to what `profileName` can answer: unbound
+ * and excluded fields taken off their entities, with every field that reads
+ * one of them, directly or through other fields; every excluded metric and
+ * every metric that reads an unavailable field dropped; and every action with
+ * no executor dropped. A field counts whether the entity declares or inherits
+ * it. What a field or metric reads comes from the text `dialect` evaluates
+ * (see textsFor). `dialect` defaults to the dialect the model's sources
+ * imply. When the sources are in systems of different dialects, or one names
+ * no system, there is no dialect and every text counts.
+ * The input is never mutated. The report names each dropped block
+ * and the unbound field that stops it, so a caller can state the withheld
+ * coverage. A model with nothing unbound resolves unchanged.
+ */
+function pruneUnavailable(model, profileName, dialect = sourcesDialect(model)) {
+    const clone = structuredClone(model);
+    const report = {
+        profile: profileName,
+        unboundFields: [],
+        excludedFields: [],
+        droppedEntities: [],
+        droppedMetrics: [],
+        droppedRelationships: [],
+        droppedActions: [],
+        droppedFields: [],
+        warnings: [],
+    };
+    // A field is bound when isFieldBound says so; otherwise it is unbound
+    // (structurally absent under this profile). A field awaiting transpilation
+    // (its column carried on the imported expression) or bound only through a
+    // dialect list counts as bound, not dropped. The graph generators ask a
+    // narrower question, whether the field has SQL for their engine, and leave
+    // out a bound field that has none with a warning of their own.
+    //
+    // Availability is judged on each entity's resolved fields, declared plus
+    // inherited, since a metric can read an inherited field as readily as a
+    // declared one. A field the profile excludes on an entity is unavailable on
+    // that entity.
+    const unbound = new Set();
+    const resolved = resolvedEntities(clone);
+    for (const e of resolved) {
+        // An abstract entity has no table and no bindings by design: it survives
+        // only as a label on its subtypes (which bind its inherited fields on their
+        // own tables). Its fields are legitimately column-less, so they are not
+        // "unbound" in the pruning sense.
+        if (e.abstract)
+            continue;
+        for (const f of e.fields ?? []) {
+            if (!(0, ir_1.isFieldBound)(f))
+                unbound.add(`${e.name}.${f.name}`);
+        }
+        for (const name of e.excludedFields ?? []) {
+            unbound.add(`${e.name}.${name}`);
+            report.excludedFields.push(`${e.name}.${name}`);
+        }
+    }
+    report.unboundFields = [...unbound];
+    // A field that reads an unavailable field of its entity is unavailable too,
+    // and so is every field and metric that reads it in turn. Each field's
+    // dependencies are read once, and only when something is unbound.
+    const unavailable = new Set(unbound);
+    const unreadable = new Set();
+    const dependencies = new Map();
+    if (unbound.size) {
+        for (const e of resolved) {
+            if (e.abstract)
+                continue;
+            for (const f of e.fields ?? []) {
+                const key = `${e.name}.${f.name}`;
+                if (unbound.has(key))
+                    continue;
+                dependencies.set(key, fieldDependencies(clone, e.name, f.name, unreadable, dialect)
+                    .map(dep => `${e.name}.${dep}`));
+            }
+        }
+    }
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const [key, deps] of dependencies) {
+            if (unavailable.has(key))
+                continue;
+            const reached = deps.find(target => unavailable.has(target));
+            if (reached) {
+                unavailable.add(key);
+                report.droppedFields.push({ name: key, reason: `reads ${reached}, which is unavailable` });
+                grew = true;
+            }
+        }
+    }
+    for (const what of unreadable) {
+        report.warnings.push(`${what}: kcmd could not read its SQL, so the fields it reads were ` +
+            `not checked`);
+    }
+    // Keys and join columns are physical column names, not fields, so whether a
+    // field is bound says nothing about them. Excluding a field that happens to
+    // share a key column's name drops the field and nothing else.
+    const allEntityNames = (clone.entities ?? []).map(e => e.name);
+    // Take unbound and excluded fields off the entities that declare them. (A
+    // bound field whose value is null still emits a column -- unbound is not
+    // null.) A declaration that a descendant inherits stays, so the descendant
+    // keeps the definition and whatever binding it has, and is marked excluded on
+    // the declaring entity instead, since a binding is a fact about one table.
+    const extendedNames = new Set(resolvedEntities(clone).flatMap(e => e.extends ?? []));
+    for (const e of clone.entities ?? []) {
+        // Keep an abstract entity's fields intact: they are column-less by design
+        // and name the shared label's property set for the emitter (see above).
+        if (e.abstract)
+            continue;
+        // An inherited field that is unavailable on this entity is marked excluded
+        // here, whether it is unbound, excluded, or reads such a field. Removing
+        // this entity's line alone, or having none to remove, would let inheritance
+        // hand back the ancestor's definition and binding.
+        const inheritedUnavailable = [...inheritedNamesOf(clone, e.name)].filter(name => unavailable.has(`${e.name}.${name}`));
+        const excluded = new Set(e.excludedFields ?? []);
+        const gone = (f) => !(0, ir_1.isFieldBound)(f) || excluded.has(f.name) ||
+            unavailable.has(`${e.name}.${f.name}`);
+        if (extendedNames.has(e.name)) {
+            const kept = (e.fields ?? []).filter(gone).map(f => f.name);
+            if (kept.length) {
+                e.excludedFields = [...new Set([...excluded, ...kept])];
+            }
+        }
+        else {
+            e.fields = (e.fields ?? []).filter(f => !gone(f));
+        }
+        if (inheritedUnavailable.length) {
+            e.excludedFields =
+                [...new Set([...(e.excludedFields ?? []), ...inheritedUnavailable])];
+        }
+    }
+    // A relationship's join columns are its own binding, so pruning fields never
+    // removes one.
+    const keptRels = clone.relationships ?? [];
+    // A metric is available only when the profile does not exclude it, every
+    // field it reads is available, and -- when it spans entities -- a
+    // relationship connects them.
+    const excludedMetrics = new Set(clone.excludedMetrics ?? []);
+    delete clone.excludedMetrics;
+    const keptMetrics = [];
+    for (const mt of clone.metrics ?? []) {
+        if (excludedMetrics.has(mt.name)) {
+            report.droppedMetrics.push({ name: mt.name, reason: 'excluded' });
+            continue;
+        }
+        const columns = [];
+        // A text with no SQL has nothing to read.
+        const sources = textsFor(mt, dialect)
+            .filter(s => (0, loader_1.noSqlReason)(s.text, s.dialect) === undefined);
+        let unread = 0;
+        for (const { text, dialect } of sources) {
+            const read = (0, sql_expr_utils_1.columnReferences)(text, dialect);
+            if (read) {
+                columns.push(...read);
+            }
+            else {
+                unread++;
+            }
+        }
+        const hit = firstUnboundReferenced(columns, unavailable);
+        if (hit) {
+            report.droppedMetrics.push({
+                name: mt.name,
+                reason: `field ${hit} is ${unbound.has(hit) ? 'unbound' : 'unavailable'}`,
+                field: hit,
+            });
+            continue;
+        }
+        const refs = (0, sql_expr_utils_1.entitiesReached)(columns, allEntityNames);
+        if (refs.length > 1 && !connectingRelationshipKept(refs, keptRels)) {
+            report.droppedMetrics.push({
+                name: mt.name,
+                reason: `no available relationship connects ${refs.join(', ')}`,
+            });
+            continue;
+        }
+        // A text the parser cannot read is skipped, so what it reads is unknown.
+        if (unread) {
+            report.warnings.push(unread === sources.length ?
+                `metric '${mt.name}': kcmd could not read its SQL, so the ` +
+                    `fields it reads were not checked` :
+                `metric '${mt.name}': kcmd could not read some of its SQL, so ` +
+                    `the fields that SQL reads were not checked`);
+        }
+        keptMetrics.push(mt);
+    }
+    clone.metrics = keptMetrics;
+    // An action is available only where a binding performs it. The executor is
+    // the action's binding, so an action without one is unavailable for the same
+    // reason a column-less field is: it is declared, and there is nothing here to
+    // carry it out.
+    const keptActions = [];
+    for (const a of clone.actions ?? []) {
+        if (a.executor === undefined) {
+            report.droppedActions.push({ name: a.name, reason: 'no executor is bound under this profile' });
+            continue;
+        }
+        keptActions.push(a);
+    }
+    clone.actions = keptActions;
+    return { model: clone, report };
+}
+// `model` without the exclusions a profile marked on it.
+function withoutExclusions(model) {
+    const out = structuredClone(model);
+    for (const e of out.entities ?? [])
+        delete e.excludedFields;
+    delete out.excludedMetrics;
+    return out;
+}
+// Each entity resolved for inheritance, or as declared when the hierarchy is
+// broken, which push reports elsewhere. `extends` is expanded to every
+// ancestor.
+function resolvedEntities(model) {
+    const entities = model.entities ?? [];
+    if (!entities.some(e => e.extends?.length))
+        return entities;
+    try {
+        return (0, resolve_inheritance_1.resolveInheritance)(model).model.entities ?? entities;
+    }
+    catch (err) {
+        if (!(err instanceof resolve_inheritance_1.InheritanceError))
+            throw err;
+        return entities;
+    }
+}
+// The names of the fields `entityName` inherits from every ancestor its
+// `extends` reaches. A caller asking for many entities passes `byName`, the
+// model's entities by name, built once.
+function inheritedNamesOf(model, entityName, byName = new Map((model.entities ?? []).map(e => [e.name, e]))) {
+    return new Set(ancestorsOf(entityName, byName)
+        .flatMap(a => (a.fields ?? []).map(f => f.name)));
+}
+// Every ancestor `entityName`'s `extends` reaches, each once. `byName` is the
+// model's entities by name.
+function ancestorsOf(entityName, byName) {
+    const ancestors = [];
+    const seen = new Set([entityName]);
+    const queue = [...(byName.get(entityName)?.extends ?? [])];
+    while (queue.length) {
+        const name = queue.shift();
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const ancestor = byName.get(name);
+        if (!ancestor)
+            continue;
+        ancestors.push(ancestor);
+        queue.push(...(ancestor.extends ?? []));
+    }
+    return ancestors;
+}
+// The first unbound "Entity.field" among the columns a metric expression
+// reads, or null.
+function firstUnboundReferenced(columns, unbound) {
+    for (const key of unbound) {
+        const dot = key.indexOf('.');
+        if ((0, sql_expr_utils_1.fieldsReadOn)(columns, key.slice(0, dot)).includes(key.slice(dot + 1))) {
+            return key;
+        }
+    }
+    return null;
+}
+// The dialect `text` is written in on `f`: the dialect of the list entry that
+// holds it, the imported dialect for the imported text, and BigQuery
+// otherwise, since the loader fills `expression` from a `BIGQUERY` or
+// `ANSI_SQL` entry.
+function dialectOf(f, text) {
+    const entry = f.dialects?.find(d => d.expression === text);
+    if (entry)
+        return entry.dialect;
+    if (text === f.importedExpression && f.importedDialect) {
+        return f.importedDialect;
+    }
+    return 'BIGQUERY';
+}
+// Whether any relationship directly connects two of the referenced entities --
+// the minimal check that a cross-entity metric has a join path.
+function connectingRelationshipKept(refEntities, kept) {
+    const set = new Set(refEntities);
+    return kept.some(r => set.has(r.source.entity) && set.has(r.destination.entity));
+}
+/**
+ * Reads a profile file into the IR's `ProfileSpec`. Throws on anything a
+ * profile may not say: an unknown key at any level, a value of the wrong shape,
+ * a field in both `fields` and `fields_exclude`, `"*"` inside a
+ * `metrics_exclude` list, or a `name` other than `profileName`. A field
+ * expression and an action's executor are read by the loader's own readers, so
+ * each follows the rules it follows in a model file. A source is kept as
+ * written, and applyProfile reads it with the loader's reader too. A field
+ * expression's short form means `ANSI_SQL` in either flavor. Actions are out of
+ * scope for the preview, so nothing more is checked. With `skipActions`, the
+ * profile's actions are not read.
+ */
+function loadProfileFile(text, profileName, opts = {}) {
+    let doc;
+    try {
+        doc = yaml.parse(text, yaml_options_1.YAML_OPTIONS);
+    }
+    catch (err) {
+        throw new loader_1.SemanticModelError(`profile '${profileName}' does not parse: ${err?.message ?? err}`);
+    }
+    if (opts.skipActions && doc && typeof doc === 'object' &&
+        !Array.isArray(doc)) {
+        const { actions: _, ...rest } = doc;
+        doc = rest;
+    }
+    return profileSpecOf(doc, profileName);
+}
+/**
+ * Returns a copy of `model` with `profile` applied: each named entity's
+ * source, its keys where the profile states them, its field bindings, as a
+ * binding-only redeclaration for a field the entity inherits, and its
+ * `fields_exclude`; each relationship's join columns; `metrics_exclude`; and
+ * each action's executor, which is taken as given, since actions are out of
+ * preview scope. A field a profile binds keeps every dialect text the profile
+ * wrote. An excluded field is marked in `excludedFields`, and loses its
+ * binding when no entity inherits it. The input is never mutated.
+ *
+ * Throws, naming the profile, when the profile repeats a name, leaves a field
+ * entry with nothing to bind, both binds and excludes a field, puts "*" inside
+ * a list, names something the model does not declare, binds an abstract
+ * entity, states one of a relationship's join column lists without the
+ * other or gives both lists with different lengths, gives a source or
+ * expression the loader's readers reject, or is applied to a model that
+ * declares a `sql` executor, which belongs in each profile.
+ */
+function applyProfile(model, profile, opts = {}) {
+    const res = applyProfileSpec(model, profile, opts);
+    if ('error' in res)
+        throw new loader_1.SemanticModelError(res.error);
+    if (opts.warnings) {
+        // With no `from`, these are the applied model's entity and metric
+        // warnings, judged on its tables in the load dialect, as the callers
+        // judge them. Keep those the model did not give already.
+        const before = new Set((0, loader_1.entityAndMetricWarnings)(model, opts.load?.dialect ?? loader_1.DEFAULT_DIALECT));
+        opts.warnings.push(...res.warnings.filter(w => !before.has(w)));
+    }
+    return res.model;
+}
+/**
+ * Reads the profile file `text` and applies it to `model`, or returns the
+ * error that stops it, naming the profile. The warnings are those of the
+ * model file's load (`opts.from`), less the ones about values the profile
+ * replaces, followed by those for the values it sets, each prefixed with the
+ * document name.
+ */
+function applyProfileFile(model, text, profileName, opts = {}) {
+    // Checked before the profile is read, so a model with a `sql` executor
+    // reports that first even when the profile file does not parse.
+    // profileApplyError checks it again for a profile built in memory.
+    const sql = logicalSqlExecutorError(model, profileName);
+    if (sql)
+        return { error: sql };
+    let profile;
+    try {
+        profile = loadProfileFile(text, profileName);
+    }
+    catch (err) {
+        if (!(err instanceof loader_1.SemanticModelError))
+            throw err;
+        return { error: err.message };
+    }
+    return applyProfileSpec(model, profile, opts);
+}
+// applyProfile and applyProfileFile's shared work: the reasons a profile
+// cannot apply, the bindings, and the warnings that follow.
+function applyProfileSpec(model, profile, opts) {
+    const error = profileApplyError(model, profile);
+    if (error)
+        return { error };
+    const applied = applyBindings(model, profile, opts);
+    if (applied.errors.length) {
+        return { error: `profile '${profile.name}': ${applied.errors[0]}` };
+    }
+    // A field the profile binds is checked on each entity that inherits it, as
+    // a load checks a model file's. A model whose inheritance does not resolve
+    // is reported by validation instead.
+    let concepts;
+    try {
+        concepts = (0, resolve_inheritance_1.declaredConceptFields)(applied.model);
+    }
+    catch (err) {
+        if (!(err instanceof resolve_inheritance_1.InheritanceError))
+            throw err;
+    }
+    const inherited = concepts && (0, loader_1.inheritedNoSqlProblems)(applied.model.entities, concepts)[0];
+    if (inherited)
+        return { error: `profile '${profile.name}': ${inherited}` };
+    return {
+        model: applied.model,
+        warnings: warningsAfterProfile(model, applied.model, opts),
+    };
+}
+/**
+ * Loads the model document `doc` on its own and applies `profile` to it. An
+ * error says whether the document failed to load or the profile failed to
+ * apply, since the callers word the two differently.
+ */
+function applyProfileToDocument(doc, profile, load) {
+    return applyToDocument(doc, (base, from) => applyProfileSpec(base, profile, { from, load }), load);
+}
+/** applyProfileToDocument for the profile file `text`. */
+function applyProfileFileToDocument(doc, text, profileName, load) {
+    return applyToDocument(doc, (base, from) => applyProfileFile(base, text, profileName, { from, load }), load);
+}
+function applyToDocument(doc, apply, load) {
+    const loaded = (0, loader_1.loadSemanticModels)([{ name: doc.name, text: doc.text }], { bindingOptional: true, ...load });
+    if (loaded.error)
+        return { error: loaded.error, stage: 'load' };
+    const res = apply(loaded.models[0].model, { document: doc.name, warnings: loaded.warnings });
+    if ('error' in res)
+        return { error: res.error, stage: 'apply' };
+    return { model: res.model, warnings: res.warnings };
+}
+/**
+ * The profiles the model document `doc` declares: `files`, its profile files,
+ * then the profiles a vanilla model carries in its GOOGLE block, by name, as
+ * the layout orders profile files. Push, `kcmd profiles` and the runtime all
+ * read them here, so they agree. Throws SemanticModelError, naming the
+ * document as a load does, when googleBlockProfiles throws, such as on block
+ * profiles a load rejects.
+ */
+function declaredProfiles(doc, files) {
+    let blockProfiles;
+    try {
+        blockProfiles = (0, loader_1.googleBlockProfiles)(doc.text);
+    }
+    catch (err) {
+        if (!(err instanceof loader_1.SemanticModelError))
+            throw err;
+        throw new loader_1.SemanticModelError(`Model document '${doc.name}': ${err.message}`);
+    }
+    return [
+        ...files,
+        ...blockProfiles.map(spec => ({ name: spec.name, spec }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+    ];
+}
+/**
+ * Finds the profile `profileName` among `profiles`, the ones the model
+ * document `doc` declares, and applies it, as push, `kcmd profiles` and the
+ * runtime do. It applies to the document loaded on its own.
+ */
+function profileForDocument(doc, profiles, profileName, load = {}) {
+    const chosen = profiles.find(p => p.name === profileName);
+    if (!chosen)
+        return { kind: 'missing', declared: profiles.map(p => p.name) };
+    const res = 'spec' in chosen ?
+        applyProfileToDocument(doc, chosen.spec, load) :
+        applyProfileFileToDocument(doc, chosen.text, profileName, load);
+    return 'error' in res ? { kind: 'error', ...res } : { kind: 'file', ...res };
+}
+/**
+ * `error`, from loading a model document on its own before a profile file
+ * applies to it, with a note that says so. A model file that a profile used to
+ * complete, such as one with a half-given join, fails that load. Names
+ * `profileName` when one profile is selected.
+ */
+function modelFileAloneMessage(error, profileName) {
+    return profileName === undefined ?
+        `${error} (the model file must load on its own before a profile file ` +
+            `applies)` :
+        `${error} (under profile '${profileName}', the model file must load ` +
+            `on its own before the profile applies)`;
+}
+/**
+ * The error a command gives when a profile cannot be applied to the model
+ * document `docName`, whose profile files are `profileFiles`. An error applying
+ * a profile file names that file, as the profile checks do. An error applying
+ * a profile from a GOOGLE block names the model document.
+ */
+function profileErrorMessage(docName, res, profileName, profileFiles) {
+    if (res.stage === 'load') {
+        return modelFileAloneMessage(res.error, profileName);
+    }
+    const file = profileFiles.find(p => p.name === profileName);
+    return `[${file?.fileName ?? docName}] ${res.error}`;
+}
+/** The error for a profile name a model document does not declare. */
+function unknownProfileMessage(profileName, model, declared) {
+    return `unknown binding profile '${profileName}' for model '${model}'; ` +
+        (declared.length ? `defined profiles: ${declared.join(', ')}.` :
+            `no profiles are defined for this model.`);
+}
+/**
+ * The error for a model document `docName` whose `profiles` include one named
+ * `default` in any letter case. Push refuses every graph push of such a
+ * model, and the runtime refuses the model too. Undefined when no profile has
+ * that name.
+ */
+function reservedProfileNameError(docName, profiles) {
+    if (!profiles.some(p => p.name.toLowerCase() === exports.DEFAULT_PROFILE)) {
+        return undefined;
+    }
+    return `[${docName}] a binding profile may not be named '${exports.DEFAULT_PROFILE}' -- that name refers to the model's inline ` +
+        `bindings. Rename the profile.`;
+}
+// The warnings a load of the applied model would give, each prefixed with the
+// document name: those about its entities and metrics, from
+// entityAndMetricWarnings, which builds them with the helpers the load uses,
+// then the model file's other load warnings, about actions, which a profile
+// does not change. That is the order a load gives them. The applied model is
+// judged on its own tables, in the load's dialect.
+function warningsAfterProfile(model, applied, opts) {
+    const from = opts.from;
+    const prefix = from ? `[${from.document}] ` : '';
+    const preferred = opts.load?.dialect ?? loader_1.DEFAULT_DIALECT;
+    const before = new Set((0, loader_1.entityAndMetricWarnings)(model, preferred).map(w => prefix + w));
+    const kept = (from?.warnings ?? []).filter(w => !before.has(w));
+    const after = (0, loader_1.entityAndMetricWarnings)(applied, preferred, true).map(w => prefix + w);
+    return [...new Set([...after, ...kept])];
+}
+// Every reason `profile` names something `model` cannot take, in this order:
+// a `sql` executor in the model, the profile's own
+// structure, and each action, entity, field, relationship and metric it names
+// that the model does not declare or a profile cannot bind. applyProfile
+// throws the first, and validateProfileCompleteness lists them all.
+function profileProblems(model, profile) {
+    const at = `profile '${profile.name}'`;
+    const problems = [];
+    const sql = logicalSqlExecutorError(model, profile.name);
+    if (sql)
+        problems.push(sql);
+    problems.push(...profileStructureErrors(profile));
+    const actions = new Set((model.actions ?? []).map(a => a.name));
+    for (const pa of profile.actions ?? []) {
+        if (!actions.has(pa.name)) {
+            problems.push(`${at}: action '${pa.name}' is not in the logical model`);
+        }
+    }
+    const byName = new Map((model.entities ?? []).map(e => [e.name, e]));
+    for (const pe of profile.entities) {
+        const e = byName.get(pe.name);
+        if (!e) {
+            problems.push(`${at}: entity '${pe.name}' is not in the logical model`);
+            continue;
+        }
+        if (e.abstract) {
+            problems.push(`${at}: entity '${pe.name}' is abstract, so a profile cannot ` +
+                `bind it`);
+            continue;
+        }
+        const declared = new Set(e.fields.map(f => f.name));
+        const inherited = inheritedNamesOf(model, e.name, byName);
+        for (const pf of pe.fields ?? []) {
+            if (!declared.has(pf.name) && !inherited.has(pf.name)) {
+                problems.push(`${at}: field '${pe.name}.${pf.name}' is not in the logical model`);
+            }
+        }
+        for (const name of pe.fieldsExclude ?? []) {
+            if (!declared.has(name) && !inherited.has(name)) {
+                problems.push(`${at}: field '${pe.name}.${name}' in 'fields_exclude' is not in the logical model`);
+            }
+        }
+    }
+    const relationships = new Set((model.relationships ?? []).map(r => r.name));
+    for (const pr of profile.relationships) {
+        if (!relationships.has(pr.name)) {
+            problems.push(`${at}: relationship '${pr.name}' is not in the logical model`);
+        }
+    }
+    if (Array.isArray(profile.metricsExclude)) {
+        const metrics = new Set((model.metrics ?? []).map(m => m.name));
+        for (const name of profile.metricsExclude) {
+            if (!metrics.has(name)) {
+                problems.push(`${at}: metric '${name}' in 'metrics_exclude' is not in the logical model`);
+            }
+        }
+    }
+    return problems;
+}
+// Why `profile` cannot apply to `model`, or undefined: the first of
+// profileProblems, then the join columns the profile states for each
+// relationship. One list without the other gets the completeness check's
+// error, and two lists must have equal length. A relationship the profile
+// gives neither list keeps the model file's join columns, which the
+// completeness check reports.
+function profileApplyError(model, profile) {
+    const problems = profileProblems(model, profile);
+    if (problems.length)
+        return problems[0];
+    const at = `profile '${profile.name}'`;
+    for (const { name, fromColumns: from, toColumns: to } of profile.relationships) {
+        if (!from.length !== !to.length) {
+            return `${at}: ${profileJoinMessage(name)}`;
+        }
+        if (from.length !== to.length) {
+            return `${at}: ${(0, loader_1.joinLengthMessage)(name, from.length, to.length)}`;
+        }
+    }
+    return undefined;
+}
+// The error for a relationship a named profile does not bind with both
+// 'from_columns' and 'to_columns'.
+function profileJoinMessage(relationship) {
+    return `relationship '${relationship}' has no join columns in this ` +
+        `profile; a named profile states both 'from_columns' and ` +
+        `'to_columns' itself`;
+}
+// What loadProfileFile rejects in a profile's structure, in the order it
+// checks, with its messages: a repeated name, a field entry with nothing to
+// bind, a repeated dialect, a field both bound and excluded, and `"*"` inside
+// a list. A profile file never has these; a profile built in memory may.
+function profileStructureErrors(profile) {
+    const at = `profile '${profile.name}'`;
+    const errors = [];
+    const twice = (names) => names.find((n, i) => names.indexOf(n) !== i);
+    const dupEntity = twice(profile.entities.map(e => e.name));
+    if (dupEntity)
+        errors.push(`${at} 'entities' lists '${dupEntity}' twice`);
+    for (const pe of profile.entities) {
+        const where = `${at}: entity '${pe.name}'`;
+        const bound = (pe.fields ?? []).map(f => f.name);
+        const dupField = twice(bound);
+        if (dupField)
+            errors.push(`${where} 'fields' lists '${dupField}' twice`);
+        for (const pf of pe.fields ?? []) {
+            const fat = `${where}: field '${pf.name}'`;
+            if (!(0, ir_1.isFieldBound)(pf)) {
+                errors.push(`${fat} has no 'expression'; bind it with one, or list it in ` +
+                    `'fields_exclude'`);
+            }
+            // Checked by the loader's reader, as a profile file's is. A binding
+            // with no dialect list, which only a profile built in memory has, is
+            // read as parseFieldBinding reads it.
+            if ((0, loader_1.expressionDocOf)(pf) !== undefined) {
+                try {
+                    (0, loader_1.parseFieldBinding)(pf, fat, loader_1.DEFAULT_DIALECT, pe.name);
+                }
+                catch (err) {
+                    if (!(err instanceof loader_1.SemanticModelError))
+                        throw err;
+                    errors.push(err.message);
+                }
+            }
+        }
+        const both = (pe.fieldsExclude ?? []).find(n => bound.includes(n));
+        if (both) {
+            errors.push(`${where}: field '${both}' is in both 'fields' and ` +
+                `'fields_exclude'`);
+        }
+    }
+    const dupRel = twice(profile.relationships.map(r => r.name));
+    if (dupRel)
+        errors.push(`${at} 'relationships' lists '${dupRel}' twice`);
+    if (Array.isArray(profile.metricsExclude) &&
+        profile.metricsExclude.includes('*')) {
+        errors.push(`${at}: 'metrics_exclude' takes "*" on its own, not inside a list`);
+    }
+    return errors;
+}
+// The error for a model that declares a `sql` executor when a profile binds
+// it: a statement names one database's tables, so it belongs in the profile.
+function logicalSqlExecutorError(model, profileName) {
+    const action = (model.actions ?? []).find(a => a.executor?.kind === 'sql');
+    return action && sqlExecutorMessage(profileName, action.name, model.name);
+}
+// The error for a `sql` executor in a model that a profile applies to.
+function sqlExecutorMessage(profileName, action, model) {
+    return `profile '${profileName}': action '${action}' in model '${model}' declares a 'sql' executor. A statement names one ` +
+        `database's own tables and columns, so it belongs in the profile that ` +
+        `binds them, not in the model. Move the executor into each profile ` +
+        `that performs this write as DML.`;
+}
+// Applies what `profile` sets on the names `model` declares, and skips any
+// name it does not. applyProfile checks the names first; the profile checks
+// report each unknown name themselves. With `noSqlAsWritten`, a field binding
+// the reader rejects only for holding no SQL is applied as a valid one is.
+function applyBindings(model, profile, opts) {
+    const errors = [];
+    const out = structuredClone(model);
+    const load = opts.load ?? {};
+    const preferred = load.dialect ?? loader_1.DEFAULT_DIALECT;
+    // A source or expression the loader's readers reject is left unapplied. A
+    // rejected source is listed in `errors`. A rejected expression is not:
+    // profileStructureErrors reports it first, in the words a profile file gets,
+    // and every caller runs it before this.
+    const read = (readValue, list) => {
+        try {
+            return readValue();
+        }
+        catch (err) {
+            if (!(err instanceof loader_1.SemanticModelError))
+                throw err;
+            if (list)
+                errors.push(readerMessage(err));
+            return undefined;
+        }
+    };
+    // An executor the profile leaves out stays as the model declares it; `null`
+    // withdraws it.
+    for (const pa of profile.actions ?? []) {
+        const a = (out.actions ?? []).find(x => x.name === pa.name);
+        if (!a || pa.executor === undefined)
+            continue;
+        if (pa.executor === null) {
+            delete a.executor;
+        }
+        else {
+            a.executor = structuredClone(pa.executor);
+        }
+    }
+    const byName = new Map((out.entities ?? []).map(e => [e.name, e]));
+    const extended = entitiesWithDescendants(out);
+    for (const pe of profile.entities) {
+        const e = byName.get(pe.name);
+        if (!e || e.abstract)
+            continue;
+        const parsed = pe.source === undefined ?
+            undefined :
+            read(() => (0, loader_1.parseSource)(pe.source, load, `entity '${e.name}'`), true);
+        if (parsed) {
+            e.dataSource = parsed.dataSource;
+            e.authoredSource = parsed.authoredSource;
+            // The profile's source replaces the model file's, and so does its
+            // looked-up dialect, or the lack of one.
+            if (parsed.sourceDialect) {
+                e.sourceDialect = parsed.sourceDialect;
+            }
+            else {
+                delete e.sourceDialect;
+            }
+        }
+        if (pe.primaryKey !== undefined) {
+            e.keys = [...pe.primaryKey];
+        }
+        if (pe.uniqueKeys !== undefined) {
+            if (pe.uniqueKeys.length) {
+                e.uniqueKeys = pe.uniqueKeys.map(k => [...k]);
+            }
+            else {
+                delete e.uniqueKeys;
+            }
+        }
+        const inherited = inheritedNamesOf(out, e.name, byName);
+        for (const pf of pe.fields ?? []) {
+            // An entry with nothing to bind leaves the field as it is. applyProfile
+            // rejects one, and validateProfileCompleteness reports it, through
+            // profileStructureErrors.
+            if (!(0, ir_1.isFieldBound)(pf))
+                continue;
+            // Read as a load reads the same expression in a model file. One the
+            // reader rejects is left unapplied, also when a profile built in memory
+            // gives it with no dialect list. Under `noSqlAsWritten`, one the reader
+            // rejects only for holding no SQL is read as the schema accepts it.
+            const where = `field '${e.name}.${pf.name}'`;
+            const binding = read(() => (0, loader_1.parseFieldBinding)(pf, where, preferred, e.name), false) ??
+                (opts.noSqlAsWritten ?
+                    read(() => (0, loader_1.readFieldExpression)((0, loader_1.expressionDocOf)(pf), where, preferred, () => undefined), false) :
+                    undefined);
+            if (!binding)
+                continue;
+            let f = e.fields.find(x => x.name === pf.name);
+            if (!f) {
+                if (!inherited.has(pf.name))
+                    continue;
+                // Binding an inherited field redeclares it on this entity with only a
+                // binding, which inheritance merges over the ancestor's definition.
+                f = { name: pf.name };
+                e.fields.push(f);
+            }
+            for (const k of ir_1.FIELD_BINDING_KEYS)
+                delete f[k];
+            if (pf.dialects?.length) {
+                Object.assign(f, binding);
+            }
+            else {
+                // A profile built in memory may carry a binding with no dialect list,
+                // which is applied as written.
+                for (const k of ir_1.FIELD_BINDING_KEYS) {
+                    if (pf[k] !== undefined)
+                        f[k] = structuredClone(pf[k]);
+                }
+            }
+        }
+        // An exclusion applies to this entity only. A field no entity inherits
+        // from this one also loses its binding; one a descendant inherits keeps
+        // the binding the descendant reads.
+        const below = extended.has(e.name);
+        for (const name of pe.fieldsExclude ?? []) {
+            const f = e.fields.find(x => x.name === name);
+            if (!f || below)
+                continue;
+            if (inherited.has(name)) {
+                // A line that only redeclares an inherited field goes with its
+                // binding. The entity still inherits the declaration.
+                e.fields = e.fields.filter(x => x !== f);
+            }
+            else {
+                for (const k of ir_1.FIELD_BINDING_KEYS)
+                    delete f[k];
+            }
+        }
+        if (pe.fieldsExclude?.length) {
+            e.excludedFields =
+                [...new Set([...(e.excludedFields ?? []), ...pe.fieldsExclude])];
+        }
+    }
+    // A side the profile leaves empty keeps the model file's columns.
+    for (const pr of profile.relationships) {
+        const r = (out.relationships ?? []).find(x => x.name === pr.name);
+        if (!r)
+            continue;
+        if (pr.fromColumns.length)
+            r.source.columns = [...pr.fromColumns];
+        if (pr.toColumns.length)
+            r.destination.columns = [...pr.toColumns];
+    }
+    if (profile.metricsExclude !== undefined) {
+        const names = profile.metricsExclude === '*' ?
+            (out.metrics ?? []).map(m => m.name) :
+            profile.metricsExclude;
+        if (names.length) {
+            out.excludedMetrics =
+                [...new Set([...(out.excludedMetrics ?? []), ...names])];
+        }
+    }
+    // The load read each ANSI_SQL metric in the dialect the model file's sources
+    // imply, or with the generic parser when they imply none. The profile's
+    // sources can imply another dialect, so each metric with no authored entity
+    // is inferred again, as a load of the model file with these sources would
+    // infer it. A metric whose new reading does not pin exactly one entity has
+    // none.
+    const entityNames = (out.entities ?? []).map(e => e.name);
+    const impliedDialect = sourcesDialect(out);
+    for (const m of out.metrics ?? []) {
+        if (m.authoredEntity !== undefined)
+            continue;
+        const { referenced } = (0, loader_1.inferMetricEntities)(m, entityNames, preferred, impliedDialect, out.version);
+        if (referenced.length === 1) {
+            m.entity = referenced[0];
+        }
+        else {
+            delete m.entity;
+        }
+    }
+    return { model: out, errors };
+}
+// The message of an error the loader's source or expression reader throws,
+// without the prefix a model file's load gives it.
+function readerMessage(err) {
+    return err.message.replace(/^Semantic model load error: /, '');
+}
+// The entities another entity extends, directly or through others: exactly
+// those named in some other entity's `extends`.
+function entitiesWithDescendants(model) {
+    return new Set((model.entities ?? []).flatMap(e => (e.extends ?? []).filter(p => p !== e.name)));
+}
+// Reads a parsed profile file into a ProfileSpec, throwing on anything a
+// profile may not say. Shared by loadProfileFile and the loader's reading of a
+// vanilla GOOGLE block's profiles, so the two agree on what a valid profile is.
+function profileSpecOf(doc, profileName) {
+    const where = `profile '${profileName}'`;
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc) ||
+        doc.semantic_model !== undefined) {
+        throw new loader_1.SemanticModelError(`${where} is not a profile file`);
+    }
+    if (doc.version !== undefined) {
+        throw new loader_1.SemanticModelError(`${where} sets 'version'; a profile file takes its version from the ` +
+            `model file beside it, so remove the line`);
+    }
+    if (doc.datasets !== undefined) {
+        throw new loader_1.SemanticModelError(`${where} lists its bindings under 'datasets'; a profile lists them ` +
+            `under 'entities'`);
+    }
+    // The profile's own name is checked against the file name below.
+    requireKeys(doc, PROFILE_FILE_KEYS, where, false);
+    if (doc.name !== profileName) {
+        throw new loader_1.SemanticModelError(`${where} declares name '${doc.name ?? ''}', which does not match ` +
+            `its file's profile name '${profileName}'`);
+    }
+    const spec = {
+        name: profileName,
+        entities: listOf(doc.entities, `${where} 'entities'`)
+            .map(e => profileEntity(e, where)),
+        relationships: listOf(doc.relationships, `${where} 'relationships'`).map(r => {
+            requireKeys(r, PROFILE_RELATIONSHIP_KEYS, `${where}: relationship`);
+            const at = `${where}: relationship '${r.name}'`;
+            // An empty list is rejected as a load rejects one, so an empty side
+            // here can only mean a side the profile leaves out.
+            for (const key of ['from_columns', 'to_columns']) {
+                if (Array.isArray(r[key]) && !r[key].length) {
+                    throw new loader_1.SemanticModelError(`${at} '${key}' lists no column`);
+                }
+            }
+            // A side the profile leaves out is empty, which completeness
+            // rejects: a named profile states both join column lists itself.
+            const binding = {
+                name: r.name,
+                fromColumns: stringList(r.from_columns, `${at} 'from_columns'`),
+                toColumns: stringList(r.to_columns, `${at} 'to_columns'`),
+            };
+            return binding;
+        }),
+    };
+    if (doc.metrics_exclude !== undefined) {
+        const ex = doc.metrics_exclude;
+        if (ex !== '*' &&
+            !(Array.isArray(ex) &&
+                ex.every((n) => typeof n === 'string'))) {
+            throw new loader_1.SemanticModelError(`${where}: 'metrics_exclude' must be "*" or a list of metric names`);
+        }
+        spec.metricsExclude = ex;
+    }
+    if (doc.actions !== undefined) {
+        // Actions are out of preview scope and gain no new checks, so when a
+        // profile lists an action twice, the last entry wins.
+        spec.actions = listOf(doc.actions, `${where} 'actions'`).map(a => {
+            requireKeys(a, PROFILE_ACTION_KEYS, `${where}: action`);
+            if (a.executor === undefined)
+                return { name: a.name };
+            return {
+                name: a.name,
+                executor: a.executor === null ?
+                    null :
+                    (0, loader_1.parseExecutor)(a.executor, `${where}: action '${a.name}'`),
+            };
+        });
+    }
+    // A repeated name, a field with nothing to bind, a field both bound and
+    // excluded, and "*" inside a list, judged as for a profile held in memory.
+    const problems = profileStructureErrors(spec);
+    if (problems.length)
+        throw new loader_1.SemanticModelError(problems[0]);
+    return spec;
+}
+function profileEntity(e, where) {
+    requireKeys(e, PROFILE_ENTITY_KEYS, `${where}: entity`);
+    const at = `${where}: entity '${e.name}'`;
+    const binding = { name: e.name };
+    if (e.source !== undefined) {
+        if (typeof e.source !== 'string') {
+            throw new loader_1.SemanticModelError(`${at} 'source' must be a string`);
+        }
+        binding.source = e.source;
+    }
+    if (e.primary_key !== undefined) {
+        binding.primaryKey = stringList(e.primary_key, `${at} 'primary_key'`);
+    }
+    if (e.unique_keys !== undefined) {
+        binding.uniqueKeys = listOf(e.unique_keys, `${at} 'unique_keys'`)
+            .map(k => stringList(k, `${at} 'unique_keys'`));
+    }
+    if (e.fields !== undefined) {
+        binding.fields = listOf(e.fields, `${at} 'fields'`).map(f => {
+            requireKeys(f, PROFILE_FIELD_KEYS, `${at}: field`);
+            const fat = `${at}: field '${f.name}'`;
+            return f.expression === undefined ?
+                { name: f.name } :
+                {
+                    name: f.name,
+                    ...(0, loader_1.parseFieldExpression)(f.expression, fat, loader_1.DEFAULT_DIALECT, e.name),
+                };
+        });
+    }
+    if (e.fields_exclude !== undefined) {
+        binding.fieldsExclude =
+            stringList(e.fields_exclude, `${at} 'fields_exclude'`);
+    }
+    return binding;
+}
+// Checks that `obj` is a mapping carrying only `allowed` keys and, unless
+// `named` is false, a string `name`.
+function requireKeys(obj, allowed, where, named = true) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        throw new loader_1.SemanticModelError(`${where} is not a mapping`);
+    }
+    if (named && typeof obj.name !== 'string') {
+        throw new loader_1.SemanticModelError(`${where} has no 'name'`);
+    }
+    for (const k of Object.keys(obj)) {
+        if (!allowed.has(k)) {
+            throw new loader_1.SemanticModelError(notAllowed(named && obj.name !== undefined ? `${where} '${obj.name}'` : where, k));
+        }
+    }
+}
+function listOf(value, where) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        throw new loader_1.SemanticModelError(`${where} must be a list`);
+    }
+    return value;
+}
+function stringList(value, where) {
+    const list = listOf(value, where);
+    if (!list.every(v => typeof v === 'string')) {
+        throw new loader_1.SemanticModelError(`${where} must be a list of names`);
+    }
+    return list;
+}
+// ---------------------------------------------------------------------------
+// Whether a profile can be deployed.
+// ---------------------------------------------------------------------------
+// The dialect each system's sources infer, keyed by the
+// system databaseOf puts first.
+const DIALECT_OF_SYSTEM = {
+    bigquery: 'BIGQUERY',
+    spanner: 'SPANNER',
+    alloydb: 'ALLOYDB',
+    cloudsql_mysql: 'MYSQL',
+    cloudsql_postgresql: 'POSTGRES',
+};
+// Each text a field's or metric's expression carries, with the dialect it is
+// written in.
+function expressionSources(f) {
+    const out = (f.dialects ?? []).map(d => ({ text: d.expression, dialect: d.dialect }));
+    for (const text of [f.expression, f.importedExpression]) {
+        if (text !== undefined && !out.some(o => o.text === text)) {
+            out.push({ text, dialect: dialectOf(f, text) });
+        }
+    }
+    return out;
+}
+// The texts a profile of `dialect` evaluates for a field or metric, each with
+// the dialect to read it in. A profile has one dialect, so it evaluates the
+// entry for that dialect, or the ANSI_SQL entry when there is none, and its
+// database runs an ANSI_SQL text as its own SQL. A field held without a
+// dialect list offers its imported text when that is in the profile's dialect,
+// and otherwise the text the loader picked. With no known dialect, every text
+// counts, each read in the dialect it is written in.
+function textsFor(f, dialect) {
+    if (dialect === undefined)
+        return expressionSources(f);
+    // The text a database of this dialect runs: its own entry, or the
+    // ANSI_SQL one.
+    const text = (0, ir_1.expressionForDialect)(f, dialect);
+    return text !== undefined ? [{ text, dialect }] : [];
+}
+// Whether a field or metric holds SQL but has no text in any of `dialects`
+// and no ANSI_SQL text, so no table of those dialects runs it.
+function noTextFor(f, dialects) {
+    return (0, ir_1.isFieldBound)(f) && dialects.every(d => !textsFor(f, d).length);
+}
+// The table of `entity`, or undefined when the load does not know its
+// dialect. With `withUnread`, a Cloud SQL or third-party table no lookup has
+// read is given too, and a Cloud SQL name with no schema gives MySQL.
+function tableDialects(entity, withUnread) {
+    const dialect = sourcesDialect({ entities: [entity] });
+    if (dialect)
+        return { name: dialect, dialects: [dialect] };
+    if (!withUnread)
+        return undefined;
+    const source = (0, loader_1.writtenSource)(entity);
+    const table = (0, loader_1.cloudSqlTableOf)(source);
+    if (table) {
+        // Only a MySQL table's name has no schema.
+        const mysql = DIALECT_OF_SYSTEM.cloudsql_mysql;
+        if (!table.inSchema)
+            return { name: mysql, dialects: [mysql] };
+        const dialects = [...new Set(Object.values(loader_1.DIALECT_OF_ENTRY_TYPE))].filter(d => d !== mysql);
+        return { name: 'Cloud SQL', dialects, unread: true };
+    }
+    if ((0, loader_1.thirdPartyEntryOf)(source)) {
+        const dialects = [...loader_1.DIALECT_OF_FQN_PREFIX.values()];
+        return { name: 'third-party', dialects, unread: true };
+    }
+    return undefined;
+}
+// Each field of each entity whose table `tableDialects(entity, withUnread)`
+// gives, with that table. An inherited field is listed on each entity that
+// inherits it.
+function fieldsOnTables(model, withUnread = false) {
+    return resolvedEntities(model).flatMap(entity => {
+        const table = tableDialects(entity, withUnread);
+        if (!table)
+            return [];
+        return (entity.fields ?? []).map(field => ({ entity, field, table }));
+    });
+}
+// The import command that adds BigQuery SQL to a model file. Push reads only
+// files written for kcmd, so `--input first-party` fits each of them.
+exports.IMPORT_TRANSPILE_COMMAND = 'kcmd import <file> --input first-party --flavor <ossie|google> --transpile';
+// Whether `kcmd import --transpile` gives BigQuery SQL to a field or metric
+// with no text for `dialect`: true when `dialect` is BIGQUERY and its only
+// text is an imported one, in a dialect the translator reads.
+function importTranspiles(f, dialect) {
+    return dialect === 'BIGQUERY' && !!f.importedExpression &&
+        (0, transpile_1.transpilesFrom)(f.importedDialect ?? '');
+}
+// The dialect a model's sources imply: that of the one database every concrete
+// entity reads from, or undefined when they name several, or a source names
+// none. A legacy bare name, which the loader completes into
+// `project.dataset.table` in `dataSource`, names BigQuery however many parts it
+// was written with.
+function sourcesDialect(model) {
+    return dialectOfSources((model.entities ?? [])
+        .filter(e => !e.abstract)
+        .map(e => ({
+        source: (0, loader_1.writtenSource)(e),
+        lookedUp: e.sourceDialect,
+    })));
+}
+// The dialect every one of `sources` implies, or undefined when one names no
+// database in an accepted form or two imply different dialects. Two databases
+// of one system, such as two Spanner databases, imply that system's dialect.
+// A three-part dotted name, which is how the loader completes a legacy bare
+// name, names BigQuery.
+//
+// A Cloud SQL table written as its resource name, and a third-party table,
+// imply the dialect their catalog entry gives, which a lookup read into
+// `lookedUp` (LoadOptions.sourceDialects).
+function dialectOfSources(sources) {
+    const dialects = new Set(sources.map(({ source, lookedUp }) => {
+        const s = source.trim();
+        if ((0, loader_1.dialectLookupKey)(s))
+            return lookedUp;
+        const db = (0, loader_1.databaseOf)(s) ??
+            (/^[^./:\s`]+\.[^./:\s`]+\.[^./:\s`]+$/.test(s) ? 'bigquery' :
+                undefined);
+        return db ? DIALECT_OF_SYSTEM[db.split('/')[0]] : undefined;
+    }));
+    if (dialects.size !== 1)
+        return undefined;
+    return [...dialects][0];
+}
+/**
+ * Returns one message per reason `profile` cannot be deployed against
+ * `baseModel`, or an empty list. Checks a single profile: nothing unknown,
+ * every field it binds holding SQL on each entity that inherits it, every
+ * concrete entity bound and all in one database, its own keys where the model
+ * file states keys, every relationship bound, every field the model file
+ * leaves unbound accounted for, every field whose expression reads a column
+ * restated or excluded, and exclusions closed under dependency, metrics
+ * included. The check that join columns cover a key of the target is in
+ * validateProfileConsistency. An expression the SQL parser cannot read
+ * is skipped by the rules that read references, with a message in `warnings`.
+ * `opts` says what the caller checks itself, so that nothing is reported
+ * twice.
+ */
+function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {}) {
+    const errors = [];
+    // Each field or metric whose SQL the parser cannot read, reported once, by
+    // the label fieldLabel or metricLabel gives it.
+    const unreadable = new Set();
+    const at = `profile '${profile.name}'`;
+    // What a profile file could not say, for a profile built in memory, and
+    // every name the model does not take, as applyProfile judges them.
+    errors.push(...profileProblems(baseModel, profile));
+    const entities = baseModel.entities ?? [];
+    const byName = new Map(entities.map(e => [e.name, e]));
+    // Declared plus inherited fields, in the model file and as this profile sees
+    // the model: the profile applied as push applies it, and each excluded field
+    // left off the entity that names it. Push reports a broken hierarchy in the
+    // model file. A profile breaks the hierarchy itself when it binds a field on
+    // two unrelated branches. That is reported here once the model file's
+    // hierarchy resolves. The rules below still run on a broken hierarchy, apart
+    // from the check that each inherited field holds SQL, which push also skips
+    // then. An entity whose own ancestors do not resolve shows only its declared
+    // fields, so the rules that need what it inherits leave it out.
+    const fieldsOf = fieldsByEntity(baseModel);
+    // The entities whose own ancestors do not resolve in the model file, so
+    // what they inherit is not known.
+    const unknownAncestry = unresolvedEntities(baseModel);
+    const { model: profiled, errors: unread } = applyBindings(baseModel, profile, { load: { sourceDialects: opts.sourceDialects } });
+    errors.push(...unread.map(e => `${at}: ${e}`));
+    const profiledError = inheritanceErrorOf(profiled);
+    if (profiledError && !inheritanceErrorOf(baseModel)) {
+        errors.push(`${at}: ${profiledError}`);
+    }
+    // A field the profile binds is checked on each entity that inherits it, as
+    // applyProfile checks it. A binding the reader rejects only for holding no
+    // SQL is reported where the profile writes it and left unapplied above.
+    // Applied here, it is also reported on an entity where its expression, read
+    // as a document writes it, has a further problem.
+    if (!profiledError) {
+        const asWritten = applyBindings(baseModel, profile, { noSqlAsWritten: true }).model;
+        const checked = inheritanceErrorOf(asWritten) ? profiled : asWritten;
+        const inherited = (0, loader_1.inheritedNoSqlProblems)(checked.entities, (0, resolve_inheritance_1.declaredConceptFields)(checked));
+        errors.push(...inherited.map(p => `${at}: ${p}`));
+    }
+    const seenOf = fieldsByEntity(profiled);
+    const bindingOf = new Map(profile.entities.map(e => [e.name, e]));
+    // Every concrete entity bound, all in one database. The profile's dialect
+    // is the one its own sources imply, so a source the model file states for an
+    // entity the profile leaves out does not decide it.
+    const databases = new Map();
+    const stated = [];
+    const profiledByName = new Map((profiled.entities ?? []).map(e => [e.name, e]));
+    // The entities whose source the loader's reader rejects.
+    const rejected = new Set();
+    for (const e of entities) {
+        if (e.abstract)
+            continue;
+        const pe = bindingOf.get(e.name);
+        if (pe?.source === undefined) {
+            errors.push(`${at}: entity '${e.name}' has no source in this profile`);
+            continue;
+        }
+        // A source the loader's reader rejects is already reported, and its
+        // entity keeps the model file's table and dialect. databaseOf still reads
+        // some rejected sources, such as one with a leading `//`. An entity whose
+        // source is rejected or names no database is left out of the one-database
+        // and dialect rules.
+        const db = (0, loader_1.databaseOf)(pe.source.trim());
+        const profiledEntity = profiledByName.get(e.name);
+        if (!db || profiledEntity?.authoredSource !== pe.source.trim()) {
+            rejected.add(e.name);
+            continue;
+        }
+        const lookedUp = profiledEntity.sourceDialect;
+        stated.push({ source: pe.source, lookedUp });
+        // One query reaches every database of a SQL Server instance. A third-party
+        // table is in the database its entry's fullyQualifiedName names.
+        const table = lookedUp === 'SQLSERVER' && (0, loader_1.cloudSqlTableOf)(pe.source);
+        const key = table ? table.resourceName.split('/databases/')[0] :
+            db !== 'thirdparty' ? db :
+                opts.sourceDatabases?.get(pe.source.trim()) ?? `thirdparty/${lookedUp}`;
+        if (!databases.has(key))
+            databases.set(key, e.name);
+    }
+    // A third-party table whose entry names no database is in the database of
+    // the other tables of its system.
+    for (const [prefix, systemDialect] of loader_1.DIALECT_OF_FQN_PREFIX) {
+        if ([...databases.keys()].some(k => k.startsWith(`${prefix}/`))) {
+            databases.delete(`thirdparty/${systemDialect}`);
+        }
+    }
+    if (databases.size > 1) {
+        const named = [...databases.values()].map(n => `'${n}'`).join(', ');
+        errors.push(`${at} binds entities in more than one database (${named}); a ` +
+            `profile reads from one system a single query can reach`);
+    }
+    const dialect = dialectOfSources(stated);
+    // The expressions of each entity the profile may bind.
+    for (const pe of profile.entities) {
+        const e = byName.get(pe.name);
+        if (!e || e.abstract)
+            continue;
+        const known = fieldsOf.get(pe.name);
+        // A profile field's expression may be anything the model file's could be:
+        // its own table's columns and its own entity's fields, never another
+        // entity's fields, with each qualifier in its entity's case.
+        // A name after a dot is a struct path segment, such as `customer` in
+        // `details.customer.id`, and reads no entity.
+        // These rules check every text the profile wrote, since each must be a
+        // valid field expression wherever it runs; the dependency rules below read
+        // only the text the profile's dialect evaluates. An ANSI_SQL text is read
+        // as the profile's own SQL.
+        const others = entities.map(x => x.name).filter(n => n !== pe.name);
+        for (const pf of pe.fields ?? []) {
+            // A text with no SQL is reported above, and has nothing to read.
+            const readable = expressionSources(pf).filter(s => (0, loader_1.noSqlReason)(s.text, s.dialect, pe.name) === undefined);
+            for (const { text, dialect: written } of readable) {
+                const columns = (0, sql_expr_utils_1.columnReferences)(text, written === 'ANSI_SQL' && dialect ? dialect : written);
+                if (!columns) {
+                    unreadable.add(fieldLabel(pe.name, pf.name));
+                    continue;
+                }
+                for (const other of others) {
+                    if ((0, sql_expr_utils_1.fieldsReadOn)(columns, other).length) {
+                        errors.push(`${at}: field '${pe.name}.${pf.name}' reads entity '${other}'; a field expression reads only its own entity`);
+                    }
+                }
+                errors.push(...new Set(columns.flatMap(c => (0, names_1.qualifierCaseError)(`${at}: field '${pe.name}.${pf.name}'`, c, entities.map(x => x.name)) ?? [])));
+                for (const ref of (0, sql_expr_utils_1.fieldsReadOn)(columns, pe.name)) {
+                    if (!known.has(ref) && !unknownAncestry.has(pe.name)) {
+                        errors.push(`${at}: field '${pe.name}.${pf.name}' reads '${pe.name}.${ref}', which is not a field of '${pe.name}'`);
+                    }
+                }
+            }
+        }
+    }
+    // A profile's key columns are physical column names.
+    for (const pe of profile.entities) {
+        const keyColumns = [...(pe.primaryKey ?? []), ...(pe.uniqueKeys ?? []).flat()];
+        const bad = keyColumns.filter(c => !(0, sql_expr_utils_1.isColumnName)(c));
+        if (bad.length) {
+            errors.push(`${at}: entity '${pe.name}' key column ${bad.map(c => `'${c}'`).join(', ')} is not a physical column ` +
+                `name`);
+        }
+    }
+    // The profile's own keys, where the model file states keys: those name
+    // columns of the model file's table.
+    for (const e of entities) {
+        const pe = bindingOf.get(e.name);
+        if (!pe || e.abstract)
+            continue;
+        const missing = [];
+        if (e.keys.length && !pe.primaryKey?.length)
+            missing.push('primary_key');
+        if (nonEmptyKeys(e.uniqueKeys).length &&
+            !nonEmptyKeys(pe.uniqueKeys).length) {
+            missing.push('unique_keys');
+        }
+        if (missing.length) {
+            errors.push(`${at}: entity '${e.name}' has no ${missing.join(' or ')} in this ` +
+                `profile; the model file's keys are columns of its own table, so ` +
+                `state this profile's keys`);
+        }
+    }
+    // Every relationship bound, by the profile itself: a named profile states
+    // both join column lists, and the model file's do not stand in for them.
+    for (const r of baseModel.relationships ?? []) {
+        if (r.association)
+            continue;
+        const pr = profile.relationships.find(x => x.name === r.name);
+        const from = pr?.fromColumns ?? [];
+        const to = pr?.toColumns ?? [];
+        if (!from.length || !to.length) {
+            errors.push(`${at}: ${profileJoinMessage(r.name)}`);
+        }
+        else if (from.length !== to.length) {
+            errors.push(`${at}: ${(0, loader_1.joinLengthMessage)(r.name, from.length, to.length)}`);
+        }
+        else {
+            const bad = [...from, ...to].filter(c => !(0, sql_expr_utils_1.isColumnName)(c));
+            if (bad.length) {
+                errors.push(`${at}: relationship '${r.name}' join column ${bad.map(c => `'${c}'`).join(', ')} is not a physical ` +
+                    `column name`);
+            }
+        }
+    }
+    // Every field the model file leaves unbound is accounted for, and exclusions
+    // are closed under dependency. An exclusion applies to the entity that names
+    // it, not to that entity's descendants.
+    const excluded = new Set();
+    // The entities whose own ancestors do not resolve with the profile applied.
+    // A line on one that restates an inherited field is not judged unbound.
+    const unknownProfiled = unresolvedEntities(profiled);
+    for (const e of entities) {
+        if (e.abstract)
+            continue;
+        const pe = bindingOf.get(e.name);
+        for (const name of pe?.fieldsExclude ?? []) {
+            excluded.add(`${e.name}.${name}`);
+        }
+        // A field the profile lists in `fields`, on this entity or on a concrete
+        // ancestor that has the field, is bound by it. One whose expression the
+        // reader rejected is reported once, as that, where the profile lists it.
+        const listedOn = [e, ...ancestorsOf(e.name, byName).filter(a => !a.abstract)];
+        const rebound = new Set(listedOn.flatMap(x => (bindingOf.get(x.name)?.fields ?? [])
+            .map(f => f.name)
+            .filter(n => x === e || fieldsOf.get(x.name)?.has(n))));
+        for (const f of seenOf.get(e.name)?.values() ?? []) {
+            if (!(0, ir_1.isFieldBound)(f) && !rebound.has(f.name) &&
+                !(unknownProfiled.has(e.name) &&
+                    inheritedNamesOf(profiled, e.name).has(f.name))) {
+                errors.push(`${at}: field '${e.name}.${f.name}' has no binding in the model ` +
+                    `file; bind it in 'fields' or leave it out in 'fields_exclude'`);
+            }
+        }
+    }
+    // A profile restates or excludes each field whose binding reads a column,
+    // since that column belongs to another table. seenOf leaves out excluded
+    // fields.
+    for (const e of entities) {
+        const pe = bindingOf.get(e.name);
+        if (!pe || e.abstract || unknownProfiled.has(e.name))
+            continue;
+        const restated = new Set((pe.fields ?? []).map(f => f.name));
+        for (const name of seenOf.get(e.name)?.keys() ?? []) {
+            const read = !restated.has(name) &&
+                columnBinding(profiled, e.name, name, dialect);
+            if (!read)
+                continue;
+            const through = read.owner === e.name ?
+                'its model file expression' :
+                `the expression it inherits from '${read.owner}'`;
+            errors.push(`${at}: field '${e.name}.${name}' reads column '${read.column}' ` +
+                `through ${through}; bind it in 'fields' for this profile, or ` +
+                `leave it out in 'fields_exclude'`);
+        }
+    }
+    // Each field or metric, as "field 'Entity.field'" or "metric 'name'", with
+    // a text this check cannot read that push reads in another dialect: an
+    // ANSI_SQL text, which push reads in its own dialect. Push reads every
+    // other entry in the dialect it is written in, as this check does.
+    const readOtherwise = new Set();
+    const noteUnread = (what, owner, text) => {
+        const asWritten = text.dialect !== 'ANSI_SQL' &&
+            (owner.dialects ?? []).some(d => d.dialect === text.dialect && d.expression === text.text);
+        // The caller warns about an ANSI_SQL text it cannot read either.
+        const callerFails = !!opts.ownSqlOnly &&
+            !(0, sql_expr_utils_1.columnsForSource)(text.text, 'ANSI_SQL', opts.ownSqlOnly.dialect);
+        if (!asWritten && !callerFails)
+            readOtherwise.add(what);
+    };
+    // Every bound field, and every metric the profile keeps, has a text this
+    // profile's database can run, checked once its sources name one database.
+    if (dialect) {
+        for (const e of entities) {
+            if (e.abstract || rejected.has(e.name))
+                continue;
+            for (const f of seenOf.get(e.name)?.values() ?? []) {
+                // validateInlineDialects reports a field inherited unchanged.
+                const asInModelFile = fieldsOf.get(e.name)?.get(f.name);
+                const reported = !!asInModelFile &&
+                    JSON.stringify(expressionSources(f)) ===
+                        JSON.stringify(expressionSources(asInModelFile)) &&
+                    sourcesDialect({ entities: [e] }) === dialect;
+                if (noTextFor(f, [dialect]) && !reported) {
+                    errors.push(`${at}: field '${e.name}.${f.name}' has no expression for ${dialect} or ANSI_SQL, and this profile's sources are ${dialect}`);
+                }
+            }
+        }
+        if (profile.metricsExclude !== '*') {
+            const excludedMetrics = new Set(profile.metricsExclude ?? []);
+            for (const m of baseModel.metrics ?? []) {
+                if (!excludedMetrics.has(m.name) && noTextFor(m, [dialect])) {
+                    const viaImport = importTranspiles(m, dialect) ?
+                        ` add one with '${exports.IMPORT_TRANSPILE_COMMAND}',` : '';
+                    errors.push(`${at}: metric '${m.name}' has no expression for ${dialect} or ` +
+                        `ANSI_SQL, and this profile's sources are ${dialect}; give it ` +
+                        `one,${viaImport} or add it to 'metrics_exclude'`);
+                }
+            }
+        }
+    }
+    // Each field that depends on an excluded one, and the excluded field it
+    // reaches.
+    const dangling = new Map();
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const e of entities) {
+            if (e.abstract)
+                continue;
+            for (const f of seenOf.get(e.name)?.values() ?? []) {
+                const key = `${e.name}.${f.name}`;
+                if (excluded.has(key) || dangling.has(key))
+                    continue;
+                // A field reads only its own entity's fields. An
+                // inherited field is read in the form its declaring ancestor wrote it,
+                // because inheritance strips the qualifier when it copies one down.
+                for (const dep of fieldDependencies(profiled, e.name, f.name, unreadable, dialect, noteUnread)) {
+                    const target = `${e.name}.${dep}`;
+                    if (excluded.has(target) || dangling.has(target)) {
+                        dangling.set(key, dangling.get(target) ?? target);
+                        grew = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    for (const [field, reached] of dangling) {
+        errors.push(`${at}: field '${field}' depends on '${reached}', which this ` +
+            `profile excludes; exclude '${field}' too, or rebind it`);
+    }
+    const why = (target) => excluded.has(target) ?
+        'which this profile excludes' :
+        `which depends on '${dangling.get(target)}', an excluded field`;
+    if (profile.metricsExclude !== '*') {
+        const metricExcluded = new Set(profile.metricsExclude ?? []);
+        for (const m of baseModel.metrics ?? []) {
+            if (metricExcluded.has(m.name))
+                continue;
+            const read = [];
+            for (const text of textsFor(m, dialect)) {
+                // A text with no SQL has nothing to read.
+                if ((0, loader_1.noSqlReason)(text.text, text.dialect) !== undefined)
+                    continue;
+                const columns = (0, sql_expr_utils_1.columnReferences)(text.text, text.dialect);
+                if (columns) {
+                    read.push(columns);
+                }
+                else {
+                    unreadable.add(metricLabel(m.name));
+                    noteUnread(metricLabel(m.name), m, text);
+                }
+            }
+            const reached = [...excluded, ...dangling.keys()].filter(target => {
+                const [te, tf] = target.split('.');
+                return read.some(columns => (0, sql_expr_utils_1.fieldsReadOn)(columns, te).includes(tf));
+            });
+            if (reached.length) {
+                errors.push(`${at}: metric '${m.name}' reaches ${reached.map(r => `'${r}', ${why(r)}`).join('; ')}; add '${m.name}' to 'metrics_exclude'`);
+            }
+        }
+    }
+    // The fields this profile binds, whose SQL the profile writes.
+    const own = new Set(profile.entities.flatMap(pe => (pe.fields ?? []).map(pf => fieldLabel(pe.name, pf.name))));
+    // Whether the caller warns itself about this model file SQL.
+    const caller = opts.ownSqlOnly;
+    const callerWarns = (what) => !!caller &&
+        (caller.dialect === dialect || !readOtherwise.has(what));
+    for (const what of unreadable) {
+        if (!own.has(what) && callerWarns(what)) {
+            continue;
+        }
+        warnings.push(`${at}: kcmd could not read the SQL of ${what}, so the fields it ` +
+            `reads were not checked`);
+    }
+    return errors;
+}
+/**
+ * Returns one message for each binding, the model file's included, whose
+ * `to_columns` for a relationship cover no primary or unique key of its
+ * target, or an empty list. A superset of a key covers it (see coversKey).
+ * Keys and join columns are compared as written. A binding whose key or join
+ * columns are not all column names (isColumnName) is left out. `applied` names
+ * the profile the push applies. The "covers no key" check then leaves out that
+ * profile's join, or the model file's when the profile states none.
+ */
+function validateProfileConsistency(baseModel, profiles, applied) {
+    const errors = [];
+    const entities = baseModel.entities ?? [];
+    const byName = new Map(entities.map(e => [e.name, e]));
+    for (const r of baseModel.relationships ?? []) {
+        if (r.association)
+            continue;
+        const target = byName.get(r.destination.entity);
+        if (!target || target.abstract)
+            continue;
+        const appliedJoin = profiles.find(p => p.name === applied)
+            ?.relationships.find(x => x.name === r.name);
+        // Push's own key check reports this binding's join, so it is left out here.
+        const checkedByPush = applied === undefined ? undefined :
+            appliedJoin?.toColumns.length ? `profile '${applied}'` :
+                'the model file';
+        // A binding that states no keys is checked against the model file's,
+        // since completeness reports the missing keys. A binding with no join
+        // columns is left out; completeness reports it for a named profile.
+        const record = (who, to, pk, uks) => {
+            // The column name checks report a value that is not a column name.
+            if (!to.length || ![...to, ...pk, ...uks.flat()].every(sql_expr_utils_1.isColumnName)) {
+                return;
+            }
+            if (!(0, ir_1.coversKey)(to, pk, uks) && who !== checkedByPush) {
+                errors.push(`relationship '${r.name}': ${who} joins on to_columns ${JSON.stringify(to)}, which cover no primary or unique key ` +
+                    `of '${target.name}'`);
+            }
+        };
+        record('the model file', r.destination.columns, target.keys, target.uniqueKeys ?? []);
+        for (const p of profiles) {
+            const pr = p.relationships.find(x => x.name === r.name);
+            const pe = p.entities.find(e => e.name === target.name);
+            record(`profile '${p.name}'`, pr?.toColumns ?? [], pe?.primaryKey?.length ? pe.primaryKey : target.keys, nonEmptyKeys(pe?.uniqueKeys).length ? pe.uniqueKeys :
+                target.uniqueKeys ?? []);
+        }
+    }
+    return errors;
+}
+// Each entity's fields, declared plus inherited, by name. Resolution throws on a
+// broken hierarchy, which push reports elsewhere. Each entity is then resolved
+// with only its own ancestors, and one whose own ancestors do not resolve
+// keeps its declared fields.
+function fieldsByEntity(model) {
+    let resolved = model.entities ?? [];
+    if (resolved.some(e => e.extends?.length)) {
+        try {
+            resolved = (0, resolve_inheritance_1.resolveInheritance)(model).model.entities ?? resolved;
+        }
+        catch (err) {
+            // Anything but a broken hierarchy is a bug.
+            if (!(err instanceof resolve_inheritance_1.InheritanceError))
+                throw err;
+            resolved = resolved.map(e => resolvedAlone(model, e.name) ?? e);
+        }
+    }
+    // Resolution already leaves excluded fields off; this covers a model with no
+    // inheritance, which is not resolved, and a broken one.
+    return new Map(resolved.map(e => {
+        const excluded = new Set(e.excludedFields ?? []);
+        return [
+            e.name,
+            new Map(e.fields.filter(f => !excluded.has(f.name)).map(f => [f.name, f])),
+        ];
+    }));
+}
+// The entity `name` resolved with only its ancestors, or undefined when its
+// own ancestors do not resolve.
+function resolvedAlone(model, name) {
+    const byName = new Map((model.entities ?? []).map(e => [e.name, e]));
+    const line = new Set();
+    const queue = [name];
+    while (queue.length) {
+        const n = queue.shift();
+        if (line.has(n))
+            continue;
+        line.add(n);
+        queue.push(...(byName.get(n)?.extends ?? []));
+    }
+    try {
+        const entities = (model.entities ?? []).filter(e => line.has(e.name));
+        return (0, resolve_inheritance_1.resolveInheritance)({ ...model, entities })
+            .model.entities?.find(e => e.name === name);
+    }
+    catch (err) {
+        if (!(err instanceof resolve_inheritance_1.InheritanceError))
+            throw err;
+        return undefined;
+    }
+}
+// The entities of `model` whose own ancestors do not resolve, so what they
+// inherit is not known. Empty when the hierarchy resolves.
+function unresolvedEntities(model) {
+    if (!inheritanceErrorOf(model))
+        return new Set();
+    return new Set((model.entities ?? [])
+        .filter(e => e.extends?.length &&
+        !resolvedAlone(model, e.name))
+        .map(e => e.name));
+}
+// The message of the inheritance error resolving `model` throws, or undefined
+// when it resolves.
+function inheritanceErrorOf(model) {
+    if (!(model.entities ?? []).some(e => e.extends?.length))
+        return undefined;
+    try {
+        (0, resolve_inheritance_1.resolveInheritance)(model);
+        return undefined;
+    }
+    catch (err) {
+        if (!(err instanceof resolve_inheritance_1.InheritanceError))
+            throw err;
+        return err.message;
+    }
+}
+// How a warning names a field, "field 'Entity.field'". The checks that skip a
+// warning compare these labels, so each label comes from here.
+function fieldLabel(entity, field) {
+    return `field '${entity}.${field}'`;
+}
+// How a warning names a metric, "metric 'name'".
+function metricLabel(name) {
+    return `metric '${name}'`;
+}
+// The declaration of `field` whose binding `entityName` uses, and the entity
+// that declares it: the entity's own when it binds the field, otherwise, of
+// the ancestors that bind it, the one with the most ancestors. Undefined when
+// none binds it.
+function boundDeclaration(model, entityName, field) {
+    const byName = new Map((model.entities ?? []).map(e => [e.name, e]));
+    const bindingOn = (name) => byName.get(name)?.fields.find(f => f.name === field && (0, ir_1.isFieldBound)(f));
+    let owner = bindingOn(entityName) ? entityName : undefined;
+    if (!owner) {
+        let depth = -1;
+        for (const a of ancestorsOf(entityName, byName)) {
+            const d = bindingOn(a.name) ? ancestorsOf(a.name, byName).length : -1;
+            if (d > depth)
+                [owner, depth] = [a.name, d];
+        }
+    }
+    return owner ? { owner, field: bindingOn(owner) } : undefined;
+}
+// The first column `entityName`'s binding of `field` reads, as written, and
+// the entity that declares it (see boundDeclaration), or undefined when that
+// entity is abstract. A column is a reference no entity name qualifies, and an
+// ANSI_SQL text is read in `dialect` if set.
+function columnBinding(model, entityName, field, dialect) {
+    const byName = new Map((model.entities ?? []).map(e => [e.name, e]));
+    const bound = boundDeclaration(model, entityName, field);
+    if (!bound || byName.get(bound.owner)?.abstract)
+        return undefined;
+    for (const { text, dialect: written } of expressionSources(bound.field)) {
+        const c = (0, sql_expr_utils_1.columnsForSource)(text, written, dialect)
+            ?.find(c => !byName.has(c.qualifier ?? ''));
+        if (c) {
+            return {
+                owner: bound.owner,
+                column: c.qualifier ? `${c.qualifier}.${c.name}` : c.name,
+            };
+        }
+    }
+    return undefined;
+}
+// The fields of its own entity that `field` reads on `entityName`, from the
+// texts a profile of `dialect` evaluates (see textsFor) as written. The
+// declaration read is the one boundDeclaration gives, read with its entity's
+// qualifier.
+function fieldDependencies(model, entityName, field, unreadable, dialect, onUnread) {
+    const bound = boundDeclaration(model, entityName, field);
+    if (!bound)
+        return [];
+    const name = bound.owner;
+    const deps = new Set();
+    for (const text of textsFor(bound.field, dialect)) {
+        // A text with no SQL has nothing to read.
+        if ((0, loader_1.noSqlReason)(text.text, text.dialect, name) !== undefined)
+            continue;
+        const columns = (0, sql_expr_utils_1.columnReferences)(text.text, text.dialect);
+        if (!columns) {
+            unreadable.add(fieldLabel(name, field));
+            onUnread?.(fieldLabel(name, field), bound.field, text);
+            continue;
+        }
+        for (const dep of (0, sql_expr_utils_1.fieldsReadOn)(columns, name))
+            deps.add(dep);
+    }
+    return [...deps];
+}
+// Whether a primary key and unique keys state a key. An empty unique key
+// counts as none.
+function statesKey(primaryKey, uniqueKeys) {
+    return !!primaryKey?.length || nonEmptyKeys(uniqueKeys).length > 0;
+}
+// The unique keys in `keys` that hold a column. An empty unique key counts as
+// none.
+function nonEmptyKeys(keys) {
+    return (keys ?? []).filter(k => k.length > 0);
+}