@google-cloud/kcmd 0.1.0 → 0.2.1

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

@@ -1,5 +1,5 @@
 import { Entity, Field, ProfileSpec, SemanticModel } from './ir';
-import { LoadOptions } from './loader';
+import { LoadOptions, SemanticModelError } from './loader';
 export declare const DEFAULT_PROFILE = "default";
 export declare function plainCopy(value: unknown): any;
 export interface AvailabilityReport {
@@ -38,12 +38,13 @@ export interface AvailabilityReport {
  * 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.
+ * no system, there is no dialect and every text counts. When no lookup read
+ * the dialect, it is null and no 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.
  */
-export declare function pruneUnavailable(model: SemanticModel, profileName: string, dialect?: string | undefined): {
+export declare function pruneUnavailable(model: SemanticModel, profileName: string, dialect?: string | null | undefined): {
     model: SemanticModel;
     report: AvailabilityReport;
 };
@@ -116,7 +117,9 @@ export interface AppliedProfile {
 }
 /**
  * A profile a model declares: the text of a profile file, or a profile already
- * read, such as one a vanilla model carries in its GOOGLE block.
+ * read, such as one a vanilla model carries in its GOOGLE block. A profile
+ * already read may carry `label`, the file that holds it, which
+ * namedProfileErrors names in place of the model document.
  */
 export type DeclaredProfile = {
     name: string;
@@ -124,7 +127,17 @@ export type DeclaredProfile = {
 } | {
     name: string;
     spec: ProfileSpec;
+    label?: string;
 };
+export type DeclaredProfiles = (doc: {
+    name: string;
+    text: string;
+}) => DeclaredProfile[];
+export type ProfileFiles = (model: string) => Array<{
+    name: string;
+    text: string;
+    fileName: string;
+}>;
 /**
  * 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
@@ -160,6 +173,16 @@ export declare function profileForDocument(doc: {
     name: string;
     text: string;
 }, profiles: DeclaredProfile[], profileName: string, load?: DialectLoad): DocumentProfile;
+/**
+ * The warnings that applying the profile `profileName` among `profiles` to the
+ * model document `doc` gives, each labeled with the profile. The warnings in
+ * `own`, which the document's own load gives, are left out. Empty unless
+ * profileForDocument applies the profile as a profile file.
+ */
+export declare function appliedProfileWarnings(doc: {
+    name: string;
+    text: string;
+}, profiles: DeclaredProfile[], profileName: string, own: string[], load?: DialectLoad): string[];
 /**
  * The error a command gives when a profile cannot be applied to the model
  * document `docName`, whose profile files are `profileFiles`. An error applying
@@ -173,6 +196,12 @@ export declare function profileErrorMessage(docName: string, res: Extract<Docume
     text: string;
     fileName: string;
 }>): string;
+/**
+ * Why `model` cannot be used because a deployment names a binding profile
+ * `declared` does not hold, or undefined when each names `default` or a
+ * declared profile. `document` is the model's document, for the message.
+ */
+export declare function undeclaredProfileError(document: string, model: SemanticModel, declared: string[]): string | undefined;
 /** The error for a profile name a model document does not declare. */
 export declare function unknownProfileMessage(profileName: string, model: string, declared: string[]): string;
 /**
@@ -184,12 +213,13 @@ export declare function unknownProfileMessage(profileName: string, model: string
 export declare function reservedProfileNameError(docName: string, profiles: {
     name: string;
 }[]): string | undefined;
+export declare function readerMessage(err: SemanticModelError): string;
 export declare function profileSpecOf(doc: any, profileName: string): ProfileSpec;
 export declare function expressionSources(f: Pick<Field, 'expression' | 'dialects' | 'importedExpression' | 'importedDialect'>): Array<{
     text: string;
     dialect: string;
 }>;
-declare function textsFor(f: Pick<Field, 'expression' | 'dialects' | 'importedExpression' | 'importedDialect'>, dialect: string | undefined): Array<{
+declare function textsFor(f: Pick<Field, 'expression' | 'dialects' | 'importedExpression' | 'importedDialect'>, dialect: string | null | undefined): Array<{
     text: string;
     dialect: string;
 }>;
@@ -198,6 +228,7 @@ export interface TableDialects {
     name: string;
     dialects: string[];
     unread?: boolean;
+    guessed?: boolean;
 }
 export declare function tableDialects(entity: Pick<Entity, 'abstract' | 'authoredSource' | 'dataSource' | 'sourceDialect'>, withUnread: boolean): TableDialects | undefined;
 export declare function fieldsOnTables(model: SemanticModel, withUnread?: boolean): Array<{
@@ -205,15 +236,16 @@ export declare function fieldsOnTables(model: SemanticModel, withUnread?: boolea
     field: Field;
     table: TableDialects;
 }>;
-export declare const IMPORT_TRANSPILE_COMMAND = "kcmd import <file> --input first-party --flavor <ossie|google> --transpile";
-export declare function importTranspiles(f: Parameters<typeof textsFor>[0], dialect: string | undefined): boolean;
+export declare function importCommand(flags: string, version?: string): string;
+export declare function importTranspiles(f: Parameters<typeof textsFor>[0], dialect: string | undefined, model: Pick<SemanticModel, 'entities'>): boolean;
+export declare function importHint(f: Parameters<typeof textsFor>[0], dialect: string, model: Pick<SemanticModel, 'entities' | 'version'>): string;
 export declare function sourcesDialect(model: {
     entities?: ReadonlyArray<Pick<Entity, 'abstract' | 'authoredSource' | 'dataSource' | 'sourceDialect'>>;
-}): string | undefined;
+}): string | null | undefined;
 /** What the caller of validateProfileCompleteness checks itself. */
 export interface CompletenessOptions extends DialectLoad {
     ownSqlOnly?: {
-        dialect?: string;
+        dialect?: string | null;
     };
 }
 /**
@@ -241,8 +273,17 @@ export declare function validateProfileCompleteness(baseModel: SemanticModel, pr
  * profile's join, or the model file's when the profile states none.
  */
 export declare function validateProfileConsistency(baseModel: SemanticModel, profiles: ProfileSpec[], applied?: string): string[];
+export interface LocalCheckError {
+    error: string;
+    document?: string;
+    profile?: string;
+}
+export declare function namedProfileErrors(docs: Array<{
+    name: string;
+    text: string;
+}>, baseByDoc: Map<string, SemanticModel>, profileDocs: ProfileFiles, declared: DeclaredProfiles, warnings: string[], load: DialectLoad): LocalCheckError[];
 export declare function inheritanceErrorOf(model: SemanticModel): string | undefined;
-export declare function columnBinding(model: SemanticModel, entityName: string, field: string, dialect?: string): {
+export declare function columnBinding(model: SemanticModel, entityName: string, field: string, dialect?: string | null): {
     owner: string;
     column: string;
 } | undefined;

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

@@ -61,7 +61,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMPORT_TRANSPILE_COMMAND = exports.DEFAULT_PROFILE = void 0;
+exports.DEFAULT_PROFILE = void 0;
 exports.plainCopy = plainCopy;
 exports.pruneUnavailable = pruneUnavailable;
 exports.withoutExclusions = withoutExclusions;
@@ -72,18 +72,24 @@ exports.applyProfile = applyProfile;
 exports.applyProfileFile = applyProfileFile;
 exports.declaredProfiles = declaredProfiles;
 exports.profileForDocument = profileForDocument;
+exports.appliedProfileWarnings = appliedProfileWarnings;
 exports.profileErrorMessage = profileErrorMessage;
+exports.undeclaredProfileError = undeclaredProfileError;
 exports.unknownProfileMessage = unknownProfileMessage;
 exports.reservedProfileNameError = reservedProfileNameError;
+exports.readerMessage = readerMessage;
 exports.profileSpecOf = profileSpecOf;
 exports.expressionSources = expressionSources;
 exports.noTextFor = noTextFor;
 exports.tableDialects = tableDialects;
 exports.fieldsOnTables = fieldsOnTables;
+exports.importCommand = importCommand;
 exports.importTranspiles = importTranspiles;
+exports.importHint = importHint;
 exports.sourcesDialect = sourcesDialect;
 exports.validateProfileCompleteness = validateProfileCompleteness;
 exports.validateProfileConsistency = validateProfileConsistency;
+exports.namedProfileErrors = namedProfileErrors;
 exports.inheritanceErrorOf = inheritanceErrorOf;
 exports.columnBinding = columnBinding;
 exports.statesKey = statesKey;
@@ -135,7 +141,8 @@ function notAllowed(where, key) {
  * 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.
+ * no system, there is no dialect and every text counts. When no lookup read
+ * the dialect, it is null and no 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.
@@ -579,6 +586,19 @@ function profileForDocument(doc, profiles, profileName, load = {}) {
         applyProfileFileToDocument(doc, chosen.text, profileName, load);
     return 'error' in res ? { kind: 'error', ...res } : { kind: 'file', ...res };
 }
+/**
+ * The warnings that applying the profile `profileName` among `profiles` to the
+ * model document `doc` gives, each labeled with the profile. The warnings in
+ * `own`, which the document's own load gives, are left out. Empty unless
+ * profileForDocument applies the profile as a profile file.
+ */
+function appliedProfileWarnings(doc, profiles, profileName, own, load = {}) {
+    const res = profileForDocument(doc, profiles, profileName, load);
+    if (res.kind !== 'file')
+        return [];
+    return res.warnings.filter(w => !own.includes(w))
+        .map(w => `profile '${profileName}': ${w}`);
+}
 /**
  * `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
@@ -605,6 +625,22 @@ function profileErrorMessage(docName, res, profileName, profileFiles) {
     const file = profileFiles.find(p => p.name === profileName);
     return `[${file?.fileName ?? docName}] ${res.error}`;
 }
+/**
+ * Why `model` cannot be used because a deployment names a binding profile
+ * `declared` does not hold, or undefined when each names `default` or a
+ * declared profile. `document` is the model's document, for the message.
+ */
+function undeclaredProfileError(document, model, declared) {
+    for (const d of model.deployments ?? []) {
+        const profile = d.profile ?? exports.DEFAULT_PROFILE;
+        if (profile === exports.DEFAULT_PROFILE || declared.includes(profile))
+            continue;
+        return `[${document}] model '${model.name}': deployment '${d.name}' names unknown binding profile '${profile}'; ` +
+            (declared.length ? `defined profiles: ${declared.join(', ')}.` :
+                `no profiles are defined for this model.`);
+    }
+    return undefined;
+}
 /** 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}'; ` +
@@ -1147,8 +1183,11 @@ function expressionSources(f) {
 // 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.
+// counts, each read in the dialect it is written in. With a null dialect, which
+// no lookup read, the text the database runs is not known, and none counts.
 function textsFor(f, dialect) {
+    if (dialect === null)
+        return [];
     if (dialect === undefined)
         return expressionSources(f);
     // The text a database of this dialect runs: its own entry, or the
@@ -1162,8 +1201,9 @@ 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.
+// dialect. With `withUnread`, a Cloud SQL, Spanner 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)
@@ -1176,7 +1216,7 @@ function tableDialects(entity, withUnread) {
         // Only a MySQL table's name has no schema.
         const mysql = DIALECT_OF_SYSTEM.cloudsql_mysql;
         if (!table.inSchema)
-            return { name: mysql, dialects: [mysql] };
+            return { name: mysql, dialects: [mysql], guessed: true };
         const dialects = [...new Set(Object.values(loader_1.DIALECT_OF_ENTRY_TYPE))].filter(d => d !== mysql);
         return { name: 'Cloud SQL', dialects, unread: true };
     }
@@ -1184,6 +1224,9 @@ function tableDialects(entity, withUnread) {
         const dialects = [...loader_1.DIALECT_OF_FQN_PREFIX.values()];
         return { name: 'third-party', dialects, unread: true };
     }
+    if ((0, loader_1.spannerDatabaseOf)(source)) {
+        return { name: 'Spanner', dialects: ['SPANNER', 'POSTGRES'], unread: true };
+    }
     return undefined;
 }
 // Each field of each entity whose table `tableDialects(entity, withUnread)`
@@ -1197,21 +1240,34 @@ function fieldsOnTables(model, withUnread = false) {
         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';
+// The import command, ending in `flags`, that keeps a model file of `version`
+// in its own flavor: `--flavor google` for a Google model, `--flavor ossie` for
+// a vanilla one, and both flavors when no model is known. Push reads only files
+// written for kcmd, so `--input first-party` fits each of them.
+function importCommand(flags, version) {
+    const flavor = version === loader_1.GOOGLE_VERSION ? 'google' :
+        version === loader_1.OSSIE_VERSION ? 'ossie' :
+            '<ossie|google>';
+    return `kcmd import <file> --input first-party --flavor ${flavor} ${flags}`;
+}
 // 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) {
+// of `model` with no text for `dialect`: true when `dialect` is BIGQUERY and
+// import's translator turns its imported text into BigQuery SQL.
+function importTranspiles(f, dialect, model) {
     return dialect === 'BIGQUERY' && !!f.importedExpression &&
-        (0, transpile_1.transpilesFrom)(f.importedDialect ?? '');
+        (0, transpile_1.translatesToBigQuery)(f, (model.entities ?? []).map(e => e.name));
+}
+// The hint that import can add a text in `dialect` to `f`, a field of
+// `model`, or ''.
+function importHint(f, dialect, model) {
+    if (!importTranspiles(f, dialect, model))
+        return '';
+    return `; give it one, or add one with '${importCommand('--transpile', model.version)}'`;
 }
 // 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.
+// none. It is null when every source is a table whose dialect no lookup read
+// (see dialectOfSources).
 function sourcesDialect(model) {
     return dialectOfSources((model.entities ?? [])
         .filter(e => !e.abstract)
@@ -1222,14 +1278,20 @@ function sourcesDialect(model) {
 }
 // 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.
+// of one system, such as two AlloyDB databases, imply that system's dialect.
+// A three-part dotted 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).
+// A Cloud SQL table written as its resource name, a third-party table and a
+// Spanner table imply the dialect a lookup gave in `lookedUp`
+// (LoadOptions.sourceDialects): the one their catalog entry or Spanner
+// database gives. When every source is such a table and none was looked up,
+// as when `kcmd import` cannot read them, the dialect is null: how their
+// database reads an ANSI_SQL text is not known, so a check reads no such text.
 function dialectOfSources(sources) {
+    if (sources.length &&
+        sources.every(s => (0, loader_1.dialectLookupKey)(s.source.trim()) && !s.lookedUp)) {
+        return null;
+    }
     const dialects = new Set(sources.map(({ source, lookedUp }) => {
         const s = source.trim();
         if ((0, loader_1.dialectLookupKey)(s))
@@ -1304,6 +1366,13 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
     // 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();
+    // Each table whose entry no lookup read, with the keys of the databases it
+    // may be in: its PostgreSQL database or its SQL Server instance for a Cloud
+    // SQL table in a schema, and any third-party database for a third-party
+    // table. `key` is the one it takes when it counts as a database of its own.
+    const unreadTables = [];
+    const isThirdParty = (k) => k.startsWith('thirdparty/') ||
+        [...loader_1.DIALECT_OF_FQN_PREFIX.keys()].some(p => k.startsWith(`${p}/`));
     const stated = [];
     const profiledByName = new Map((profiled.entities ?? []).map(e => [e.name, e]));
     // The entities whose source the loader's reader rejects.
@@ -1329,10 +1398,24 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
         }
         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] :
+        // One query reaches every database of a SQL Server instance, so a SQL
+        // Server table is keyed by its instance. A third-party table is in the
+        // database its entry's fullyQualifiedName names. A Cloud SQL table in a
+        // schema may be either engine's, so for it and for a third-party table
+        // the entry decides which database of its system it is in. A table whose
+        // entry no lookup read is compared after the loop.
+        const table = (0, loader_1.cloudSqlTableOf)(pe.source);
+        const instance = table?.resourceName.split('/databases/')[0];
+        if (lookedUp === undefined && table?.inSchema) {
+            const fits = (k) => k === db || k === instance;
+            unreadTables.push({ entity: e.name, key: instance, fits });
+            continue;
+        }
+        if (lookedUp === undefined && db === 'thirdparty') {
+            unreadTables.push({ entity: e.name, key: 'thirdparty/', fits: isThirdParty });
+            continue;
+        }
+        const key = table && lookedUp === 'SQLSERVER' ? instance :
             db !== 'thirdparty' ? db :
                 opts.sourceDatabases?.get(pe.source.trim()) ?? `thirdparty/${lookedUp}`;
         if (!databases.has(key))
@@ -1345,6 +1428,14 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
             databases.delete(`thirdparty/${systemDialect}`);
         }
     }
+    // A table whose entry no lookup read counts as another database only when
+    // none of the databases it may be in holds another table. Tables of two
+    // systems are never in one database, so it always counts beside a table of
+    // another system.
+    for (const u of unreadTables) {
+        if (![...databases.keys()].some(u.fits))
+            databases.set(u.key, u.entity);
+    }
     if (databases.size > 1) {
         const named = [...databases.values()].map(n => `'${n}'`).join(', ');
         errors.push(`${at} binds entities in more than one database (${named}); a ` +
@@ -1365,11 +1456,13 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
         // 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.
+        // as the profile's own SQL, and not at all when no lookup read its
+        // dialect.
         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);
+            const readable = expressionSources(pf).filter(s => (0, loader_1.noSqlReason)(s.text, s.dialect, pe.name) === undefined &&
+                !(s.dialect === 'ANSI_SQL' && dialect === null));
             for (const { text, dialect: written } of readable) {
                 const columns = (0, sql_expr_utils_1.columnReferences)(text, written === 'ANSI_SQL' && dialect ? dialect : written);
                 if (!columns) {
@@ -1386,6 +1479,9 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
                     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}'`);
                     }
+                    else if (ref === pf.name) {
+                        errors.push(`${at}: ${(0, sql_expr_utils_1.selfReferenceMessage)(pe.name, [pf.name])}`);
+                    }
                 }
             }
         }
@@ -1519,7 +1615,7 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
                         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}`);
+                    errors.push(`${at}: field '${e.name}.${f.name}' has no expression for ${dialect} or ANSI_SQL, and this profile's sources are ${dialect}${importHint(f, dialect, baseModel)}`);
                 }
             }
         }
@@ -1527,8 +1623,9 @@ function validateProfileCompleteness(baseModel, profile, warnings = [], opts = {
             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}',` : '';
+                    const viaImport = importTranspiles(m, dialect, baseModel) ?
+                        ` add one with '${importCommand('--transpile', baseModel.version)}',` :
+                        '';
                     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'`);
@@ -1661,6 +1758,90 @@ function validateProfileConsistency(baseModel, profiles, applied) {
     }
     return errors;
 }
+// The errors the named profiles of each model in `docs` give: each profile
+// file, and each profile a vanilla model carries in its GOOGLE block, checked
+// on its own for completeness. An error about a profile file names that file,
+// and one about a block profile names its label or the model document.
+// A model's profiles are checked against its model file as loaded on its own,
+// which `baseByDoc` holds. A file under the reserved name 'default', which no
+// push deploys, is not read here. Push also checks the
+// keys and join columns of the model file and of each named profile. The
+// warnings go to `warnings`. `profileDocs` gives a model's profile files, and
+// `declared` the profiles a document declares, as push reads them.
+function namedProfileErrors(docs, baseByDoc, profileDocs, declared, warnings, load) {
+    const errors = [];
+    for (const d of docs) {
+        // Each named profile, with the label its errors carry and a function that
+        // reads it. declared() lists the profile files too, so only its block
+        // profiles are taken from it. A block profile is already read. Its actions
+        // are dropped, as loadProfileFile skips a profile file's.
+        let named;
+        try {
+            named = [
+                ...profileDocs(d.name).map(p => ({
+                    name: p.name,
+                    label: p.fileName,
+                    read: () => loadProfileFile(p.text, p.name, { skipActions: true }),
+                })),
+                ...declared(d).flatMap(p => 'spec' in p ? [{
+                        name: p.name,
+                        label: p.label ?? d.name,
+                        read: () => {
+                            const { actions: _, ...spec } = p.spec;
+                            return spec;
+                        },
+                    }] : []),
+            ].filter(p => p.name.toLowerCase() !== exports.DEFAULT_PROFILE);
+        }
+        catch (err) {
+            // A profile file that breaks one of the layout's file rules, or block
+            // profiles a load rejects.
+            errors.push({ error: `${err.message || err}`, document: d.name });
+            continue;
+        }
+        // A document that holds no model has nothing to check its profiles
+        // against.
+        const base = baseByDoc.get(d.name);
+        if (!base)
+            continue;
+        // Actions are out of scope for the preview. Push checks a profile's
+        // actions only when it applies the profile, so these checks leave them
+        // out.
+        const logical = { ...base, actions: [] };
+        // Push warns about the SQL it cannot read in the model file, so these
+        // checks leave out a warning about model file SQL that push reads in the
+        // same dialect. Push stops reading what the SQL reads when the model's
+        // hierarchy does not resolve, and these checks then give every warning.
+        const ownSqlOnly = !inheritanceErrorOf(base) ?
+            { dialect: sourcesDialect(base) } :
+            undefined;
+        const specs = [];
+        for (const p of named) {
+            const at = (m) => `[${p.label}] ${m}`;
+            const tag = (m) => ({ error: at(m), document: d.name, profile: p.name });
+            let spec;
+            try {
+                spec = p.read();
+            }
+            catch (err) {
+                if (!(err instanceof loader_1.SemanticModelError))
+                    throw err;
+                errors.push(tag(err.message));
+                continue;
+            }
+            specs.push(spec);
+            const profileWarnings = [];
+            errors.push(...validateProfileCompleteness(logical, spec, profileWarnings, {
+                ownSqlOnly,
+                ...load,
+            }).map(tag));
+            warnings.push(...profileWarnings.map(at));
+        }
+        errors.push(...validateProfileConsistency(logical, specs, exports.DEFAULT_PROFILE)
+            .map(e => ({ error: `[${d.name}] ${e}`, document: d.name })));
+    }
+    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
@@ -1767,7 +1948,7 @@ function boundDeclaration(model, entityName, field) {
 // 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.
+// ANSI_SQL text is read in `dialect` if set, and not at all if it is null.
 function columnBinding(model, entityName, field, dialect) {
     const byName = new Map((model.entities ?? []).map(e => [e.name, e]));
     const bound = boundDeclaration(model, entityName, field);

package/build/ts/kcmd/semantic/runtime/runtime.d.ts

@@ -23,17 +23,15 @@ export interface SemanticRuntime {
      * profile's several targets may leave the store ambiguous, the model may
      * bind a table outside its Spanner or AlloyDB store, or finding how to
      * connect may fail, such as the lookup of an AlloyDB cluster's primary
-     * instance. Also set when a GOOGLE block's data is not valid JSON, so its
-     * targets cannot be read. `storeError` says why.
+     * instance. `storeError` says why.
      */
     storeFailed?: boolean;
     /**
      * Set with `storeFailed` when the model's deployments give no store
      * whatever the model is used for. One such case is a target in
-     * no accepted form in any deployment. Another is a GOOGLE block that is not
-     * valid JSON. A third is several targets for the profile with no single
-     * store. A table bound outside the store and a failed AlloyDB lookup are
-     * not such cases.
+     * no accepted form in any deployment. Another is several targets for the
+     * profile with no single store. A table bound outside the store and a failed
+     * AlloyDB lookup are not such cases.
      */
     deploymentsRejected?: boolean;
     /** Which binding profile produced this. Provenance, for messages. */
@@ -86,9 +84,3 @@ export interface CreateRuntimeOptions {
 export declare function createSemanticRuntimes(options?: CreateRuntimeOptions): Promise<SemanticRuntime[] | {
     error: string;
 }>;
-/**
- * Why `model` cannot be used because a deployment names a binding profile
- * `declared` does not hold, or undefined when each names `default` or a
- * declared profile. `document` is the model's document, for the message.
- */
-export declare function undeclaredProfileError(document: string, model: SemanticModel, declared: string[]): string | undefined;

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

@@ -50,7 +50,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runtimeStoreError = runtimeStoreError;
 exports.createSemanticRuntimes = createSemanticRuntimes;
-exports.undeclaredProfileError = undeclaredProfileError;
 const alloydb_1 = require("../../gcp/alloydb");
 const context = __importStar(require("../../gcp/context"));
 const dataplex_1 = require("../../gcp/dataplex");
@@ -143,7 +142,8 @@ async function createSemanticRuntimes(options = {}) {
     // A Cloud SQL table written as its resource name takes its dialect from its
     // Knowledge Catalog entry, looked up once for the scope before anything
     // loads. A table whose entry cannot be read stops the scope, as push does.
-    // A third-party table is not looked up, since no runtime reads one.
+    // A third-party table is not looked up, since no runtime reads one, and a
+    // Spanner table is SPANNER, the dialect the runtime's Spanner store speaks.
     const lookup = await (0, source_dialect_1.sourceDialects)([...docs.map(d => d.text),
         ...[...filesByDoc.values()].flat().map(f => f.text)], new dataplex_1.CatalogClient(ctx), { thirdParty: false });
     if (lookup.errors.length)
@@ -156,7 +156,6 @@ async function createSemanticRuntimes(options = {}) {
     const appliedByDoc = new Map();
     // The warnings applying each profile gave.
     const fileWarnings = new Map();
-    const defaultProject = source.project ?? ctx.project;
     for (const doc of docs) {
         if (profile === resolve_profiles_1.DEFAULT_PROFILE) {
             inline.push({ name: doc.name, text: doc.text });
@@ -174,7 +173,7 @@ async function createSemanticRuntimes(options = {}) {
         fileWarnings.set(doc.name, res.warnings);
         appliedByDoc.set(doc.name, res.model);
     }
-    const loaded = (0, loader_1.loadSemanticModels)(inline, { defaultProject, bindingOptional: true, ...load });
+    const loaded = (0, loader_1.loadSemanticModels)(inline, { bindingOptional: true, ...load });
     if (loaded.error)
         return { error: loaded.error };
     // In the order of the documents, as one load of them all gives. The load
@@ -194,7 +193,7 @@ async function createSemanticRuntimes(options = {}) {
     // used by no profile. Push refuses it too.
     for (const { document, model } of models) {
         const declared = (profilesByDoc.get(document) ?? []).map(p => p.name);
-        const error = undeclaredProfileError(document, model, declared);
+        const error = (0, resolve_profiles_1.undeclaredProfileError)(document, model, declared);
         if (error)
             return { error };
     }
@@ -300,19 +299,3 @@ async function createSemanticRuntimes(options = {}) {
     }
     return runtimes;
 }
-/**
- * Why `model` cannot be used because a deployment names a binding profile
- * `declared` does not hold, or undefined when each names `default` or a
- * declared profile. `document` is the model's document, for the message.
- */
-function undeclaredProfileError(document, model, declared) {
-    for (const d of model.deployments ?? []) {
-        const profile = d.profile ?? resolve_profiles_1.DEFAULT_PROFILE;
-        if (profile === resolve_profiles_1.DEFAULT_PROFILE || declared.includes(profile))
-            continue;
-        return `[${document}] model '${model.name}': deployment '${d.name}' names unknown binding profile '${profile}'; ` +
-            (declared.length ? `defined profiles: ${declared.join(', ')}.` :
-                `no profiles are defined for this model.`);
-    }
-    return undefined;
-}