@malloydata/db-bigquery 0.0.414 → 0.0.415

package/dist/bigquery_connection.d.ts

@@ -84,6 +84,7 @@ export declare class BigQueryConnection extends BaseConnection implements Connec
     downloadMalloyQuery(sqlCommand: string): Promise<ResourceStream<RowMetadata>>;
     private dryRunSQLQuery;
     estimateQueryCost(sqlCommand: string): Promise<QueryRunStats>;
+    private decodeTablePath;
     private decodeTablePathSegments;
     getTableFieldSchema(tablePath: string): Promise<SchemaInfo>;
     executeSQLRaw(sqlCommand: string): Promise<QueryData>;
@@ -92,6 +93,8 @@ export declare class BigQueryConnection extends BaseConnection implements Connec
     manifestPermanentTable(sqlCommand: string, datasetName: string, tableName: string, overwriteExistingTable?: boolean, createDataset?: boolean): Promise<string>;
     private addFieldsToStructDef;
     fetchSelectSchema(sqlSource: SQLSourceRequest): Promise<SQLSourceDef | string>;
+    private qualifyTablePath;
+    private encodeProjectSegment;
     fetchTableSchema(tableName: string, tablePath: string): Promise<TableSourceDef | string>;
     private getSQLBlockSchema;
     private createBigQueryJobAndGetResults;

package/dist/bigquery_connection.js

@@ -221,16 +221,19 @@ class BigQueryConnection extends connection_1.BaseConnection {
             queryCostBytes: Number(dryRunResults.metadata.statistics.totalBytesProcessed),
         };
     }
-    // The whole-backtick form `` `proj.dataset.table` `` parses as one
-    // quoted segment, but the metadata API still wants the parts
-    // separately — split its decoded body on `.` to recover them.
-    decodeTablePathSegments(tablePath) {
-        const result = (0, malloy_1.decodeDottedTablePath)(tablePath, {
+    decodeTablePath(tablePath) {
+        return (0, malloy_1.decodeDottedTablePath)(tablePath, {
             quoteChar: '`',
             escapeStyle: 'backslash',
             bareIdentRegex: this.dialect.tablePathBareIdentRegex,
             dialectName: 'BigQuery',
         });
+    }
+    // The whole-backtick form `` `proj.dataset.table` `` parses as one
+    // quoted segment, but the metadata API still wants the parts
+    // separately — split its decoded body on `.` to recover them.
+    decodeTablePathSegments(tablePath) {
+        const result = this.decodeTablePath(tablePath);
         if (!result.ok)
             return [tablePath];
         if (result.segments.length === 1 && result.segments[0].quoted) {
@@ -423,18 +426,41 @@ class BigQueryConnection extends connection_1.BaseConnection {
             return error.message;
         }
     }
+    // tablePath is pasted into the FROM clause verbatim — we never edit the
+    // characters the user wrote. The default project is the one sanctioned
+    // addition: BigQuery resolves an unqualified `dataset.table` against the
+    // job's billing/ambient project, so when the user omits the project we
+    // prepend it as a new leading segment. We do this exactly when the user
+    // wrote a two-segment path; anything else (a single segment, an already-
+    // qualified path, or a path wrapped entirely in backticks — which decodes
+    // to one segment) is left as written, and the user supplies the project.
+    // The project is the one segment we render ourselves, so we quote it if
+    // BigQuery requires it (e.g. a legacy `domain.com:project` id).
+    qualifyTablePath(tablePath) {
+        const decoded = this.decodeTablePath(tablePath);
+        if (!decoded.ok || decoded.segments.length !== 2) {
+            return tablePath;
+        }
+        return `${this.encodeProjectSegment(this.projectId)}.${tablePath}`;
+    }
+    encodeProjectSegment(project) {
+        // Leave it bare only if the whole id is a bare table-path segment (the
+        // regex anchors the start, so require it to match end to end); otherwise
+        // quote it the way BigQuery would any other identifier.
+        const bare = this.dialect.tablePathBareIdentRegex.exec(project);
+        if (bare && bare[0] === project) {
+            return project;
+        }
+        return this.dialect.sqlQuoteIdentifier(project);
+    }
     async fetchTableSchema(tableName, tablePath) {
-        // Keep the canonical tablePath (which may be backtick-wrapped for
-        // wildcard tables) for downstream SQL emission. The metadata lookup
-        // wants the unwrapped form, which `getTableFieldSchema` handles via
-        // `normalizeTablePath`.
         try {
             const tableFieldSchema = await this.getTableFieldSchema(tablePath);
             const tableDef = {
                 type: 'table',
                 name: tableName,
                 dialect: this.dialectName,
-                tablePath,
+                tablePath: this.qualifyTablePath(tablePath),
                 connection: this.name,
                 fields: [],
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-bigquery",
-  "version": "0.0.414",
+  "version": "0.0.415",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,7 +26,7 @@
     "@google-cloud/bigquery": "^7.3.0",
     "@google-cloud/common": "^5.0.1",
     "@google-cloud/paginator": "^5.0.0",
-    "@malloydata/malloy": "0.0.414",
+    "@malloydata/malloy": "0.0.415",
     "gaxios": "^4.2.0"
   }
 }