@malloydata/db-bigquery 0.0.49-dev230626172855 → 0.0.49-dev230626192330

package/dist/bigquery_connection.d.ts

@@ -69,17 +69,16 @@ export declare class BigQueryConnection implements Connection, PersistSQLResults
     downloadMalloyQuery(sqlCommand: string): Promise<ResourceStream<RowMetadata>>;
     private dryRunSQLQuery;
     estimateQueryCost(sqlCommand: string): Promise<QueryRunStats>;
-    structDefFromSQL(sqlCommand: string): Promise<StructDef>;
-    getTableFieldSchema(tableURL: string): Promise<SchemaInfo>;
+    private normalizeTablePath;
+    getTableFieldSchema(tablePath: string): Promise<SchemaInfo>;
     executeSQLRaw(sqlCommand: string): Promise<QueryData>;
     test(): Promise<void>;
     manifestTemporaryTable(sqlCommand: string): Promise<string>;
     manifestPermanentTable(sqlCommand: string, datasetName: string, tableName: string, overwriteExistingTable?: boolean, createDataset?: boolean): Promise<string>;
     private addFieldsToStructDef;
-    private tableURLtoTablePath;
     private structDefFromTableSchema;
     private structDefFromSQLSchema;
-    fetchSchemaForTables(missing: string[]): Promise<{
+    fetchSchemaForTables(missing: Record<string, string>): Promise<{
         schemas: Record<string, StructDef>;
         errors: Record<string, string>;
     }>;

package/dist/bigquery_connection.js

@@ -219,26 +219,21 @@ class BigQueryConnection {
             queryCostBytes: Number(dryRunResults.metadata.statistics.totalBytesProcessed),
         };
     }
-    async structDefFromSQL(sqlCommand) {
-        const dryRunResults = await this.dryRunSQLQuery(sqlCommand);
-        const destinationTable = dryRunResults.metadata.configuration.query.destinationTable;
-        return this.structDefFromTableSchema(`${destinationTable.projectId}.${destinationTable.datasetId}.${destinationTable.tableId}`, dryRunResults.metadata.statistics.query.schema);
+    normalizeTablePath(tablePath) {
+        if (tablePath.split('.').length === 2) {
+            return `${this.defaultProject}.${tablePath}`;
+        }
+        else {
+            return tablePath;
+        }
     }
-    async getTableFieldSchema(tableURL) {
+    async getTableFieldSchema(tablePath) {
         var _a, _b, _c, _d;
-        const { tablePath: tableName } = (0, malloy_1.parseTableURI)(tableURL);
-        const segments = tableName.split('.');
-        // paths can have two or three segments
-        // if there are only two segments, assume the dataset is "local" to the current billing project
-        let projectId, datasetNamePart, tableNamePart;
-        if (segments.length === 2) {
-            [datasetNamePart, tableNamePart] = segments;
-            projectId = this.defaultProject;
+        const segments = this.normalizeTablePath(tablePath).split('.');
+        if (segments.length !== 3) {
+            throw new Error(`Improper table path: ${tablePath}. A table path requires 2 or 3 segments`);
         }
-        else if (segments.length === 3)
-            [projectId, datasetNamePart, tableNamePart] = segments;
-        else
-            throw new Error(`Improper table path: ${tableName}. A table path requires 2 or 3 segments`);
+        const [projectId, datasetNamePart, tableNamePart] = segments;
         try {
             // TODO The `dataset` API has no way to set a different `projectId` than the one stored in the BQ
             //      instance. So we hack it until a better way exists: we set the `this.bigQuery.projectId`
@@ -247,7 +242,8 @@ class BigQueryConnection {
             //      this is better than creating a new BQ instance every time we need to get a table schema.
             if (projectId)
                 this.bigQuery.projectId = projectId;
-            const needTableSuffixPseudoColumn = tableNamePart && tableNamePart[tableNamePart.length - 1] === '*';
+            const needTableSuffixPseudoColumn = tableNamePart !== undefined &&
+                tableNamePart[tableNamePart.length - 1] === '*';
             const table = this.bigQuery.dataset(datasetNamePart).table(tableNamePart);
             const metadataPromise = table.getMetadata();
             this.bigQuery.projectId = this.projectId;
@@ -405,23 +401,14 @@ class BigQueryConnection {
             }
         }
     }
-    tableURLtoTablePath(tableURL) {
-        const { tablePath } = (0, malloy_1.parseTableURI)(tableURL);
-        if (tablePath.split('.').length === 2) {
-            return `${this.defaultProject}.${tablePath}`;
-        }
-        else {
-            return tablePath;
-        }
-    }
-    structDefFromTableSchema(tableURL, schemaInfo) {
+    structDefFromTableSchema(tableKey, tablePath, schemaInfo) {
         const structDef = {
             type: 'struct',
-            name: tableURL,
+            name: tableKey,
             dialect: this.dialectName,
             structSource: {
                 type: 'table',
-                tablePath: this.tableURLtoTablePath(tableURL),
+                tablePath,
             },
             structRelationship: {
                 type: 'basetable',
@@ -472,25 +459,26 @@ class BigQueryConnection {
     async fetchSchemaForTables(missing) {
         const schemas = {};
         const errors = {};
-        for (const tableURL of missing) {
-            let inCache = this.schemaCache.get(tableURL);
+        for (const tableKey in missing) {
+            let inCache = this.schemaCache.get(tableKey);
             if (!inCache) {
+                const tablePath = this.normalizeTablePath(missing[tableKey]);
                 try {
-                    const tableFieldSchema = await this.getTableFieldSchema(tableURL);
+                    const tableFieldSchema = await this.getTableFieldSchema(tablePath);
                     inCache = {
-                        schema: this.structDefFromTableSchema(tableURL, tableFieldSchema),
+                        schema: this.structDefFromTableSchema(tableKey, tablePath, tableFieldSchema),
                     };
-                    this.schemaCache.set(tableURL, inCache);
+                    this.schemaCache.set(tableKey, inCache);
                 }
                 catch (error) {
                     inCache = { error: error.message };
                 }
             }
             if (inCache.schema !== undefined) {
-                schemas[tableURL] = inCache.schema;
+                schemas[tableKey] = inCache.schema;
             }
             else {
-                errors[tableURL] = inCache.error || 'Unknown schema fetch error';
+                errors[tableKey] = inCache.error || 'Unknown schema fetch error';
             }
         }
         return { schemas, errors };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-bigquery",
-  "version": "0.0.49-dev230626172855",
+  "version": "0.0.49-dev230626192330",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
     "@google-cloud/bigquery": "^5.5.0",
     "@google-cloud/common": "^3.6.0",
     "@google-cloud/paginator": "^4.0.1",
-    "@malloydata/malloy": "^0.0.49-dev230626172855",
+    "@malloydata/malloy": "^0.0.49-dev230626192330",
     "gaxios": "^4.2.0"
   }
 }