dbgate-api-premium 7.1.13 → 7.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api-premium",
   "main": "src/index.js",
-  "version": "7.1.13",
+  "version": "7.2.0",
   "homepage": "https://www.dbgate.io/",
   "repository": {
     "type": "git",
@@ -30,11 +30,11 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "7.1.13",
+    "dbgate-datalib": "7.2.0",
     "dbgate-query-splitter": "^4.12.0",
-    "dbgate-rest": "7.1.13",
-    "dbgate-sqltree": "7.1.13",
-    "dbgate-tools": "7.1.13",
+    "dbgate-rest": "7.2.0",
+    "dbgate-sqltree": "7.2.0",
+    "dbgate-tools": "7.2.0",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -96,7 +96,7 @@
     "@types/fs-extra": "^9.0.11",
     "@types/jest": "^30.0.0",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "7.1.13",
+    "dbgate-types": "7.2.0",
     "env-cmd": "^10.1.0",
     "jest": "^30.4.2",
     "jsdoc-to-markdown": "^9.0.5",

package/src/controllers/databaseConnections.js

@@ -517,6 +517,21 @@ module.exports = {
     return res.result || null;
   },
 
+  saveQueryResultData_meta: true,
+  async saveQueryResultData({ conid, database, changeSet, sql }, req) {
+    await testConnectionPermission(conid, req);
+    await testDatabaseRolePermission(conid, database, 'run_script', req);
+
+    const opened = await this.ensureOpened(conid, database);
+    const res = await this.sendRequest(opened, { msgtype: 'saveQueryResultData', changeSet, sql });
+    if (res.errorMessage) {
+      return {
+        errorMessage: res.errorMessage,
+      };
+    }
+    return res.result || { state: 'ok' };
+  },
+
   multiCallMethod_meta: true,
   async multiCallMethod({ conid, database, callList }, req) {
     await testConnectionPermission(conid, req);

package/src/controllers/sessions.js

@@ -21,6 +21,7 @@ const logger = getLogger('sessions');
 module.exports = {
   /** @type {import('dbgate-types').OpenedSession[]} */
   opened: [],
+  requests: {},
 
   // handle_error(sesid, props) {
   //   const { error } = props;
@@ -115,6 +116,44 @@ module.exports = {
 
   handle_ping() {},
 
+  handle_response(sesid, props) {
+    const { msgid } = props;
+    const request = this.requests[msgid];
+    if (!request) return;
+    delete this.requests[msgid];
+    request.resolve(_.omit(props, ['msgtype', 'msgid', 'sesid']));
+  },
+
+  sendRequest(session, message) {
+    const msgid = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        session.subprocess.off('exit', handleExit);
+        delete this.requests[msgid];
+      };
+      const handleExit = () => {
+        cleanup();
+        reject(new Error('DBGM-00000 Session process exited before response was received'));
+      };
+      this.requests[msgid] = {
+        resolve: value => {
+          cleanup();
+          resolve(value);
+        },
+        reject: error => {
+          cleanup();
+          reject(error);
+        },
+      };
+      session.subprocess.once('exit', handleExit);
+      session.subprocess.send({ ...message, msgid }, err => {
+        if (err && this.requests[msgid]) {
+          this.requests[msgid].reject(err);
+        }
+      });
+    });
+  },
+
   create_meta: true,
   async create({ conid, database }) {
     const sesid = crypto.randomUUID();
@@ -202,6 +241,12 @@ module.exports = {
       message: 'Query execution started',
       sql,
     });
+    let dbinfo = null;
+    try {
+      dbinfo = (await require('./databaseConnections').ensureOpened(session.conid, session.database))?.structure;
+    } catch (err) {
+      logger.warn(extractErrorLogData(err), 'DBGM-00000 Error loading structure for query result metadata');
+    }
     session.subprocess.send({
       msgtype: 'executeQuery',
       sql,
@@ -209,6 +254,7 @@ module.exports = {
       autoDetectCharts: autoDetectCharts || !!frontMatter?.['selected-chart'],
       limitRows,
       frontMatter,
+      dbinfo,
     });
 
     return { state: 'ok' };
@@ -228,6 +274,24 @@ module.exports = {
     return { state: 'ok' };
   },
 
+  saveQueryResultData_meta: true,
+  async saveQueryResultData({ sesid, changeSet, sql, autoCommit }, req) {
+    await testStandardPermission('dbops/query', req);
+    const session = this.opened.find(x => x.sesid == sesid);
+    if (!session) {
+      throw new Error('Invalid session');
+    }
+    await testDatabaseRolePermission(session.conid, session.database, 'run_script', req);
+
+    const res = await this.sendRequest(session, { msgtype: 'saveQueryResultData', changeSet, sql, autoCommit });
+    if (res.errorMessage) {
+      return {
+        errorMessage: res.errorMessage,
+      };
+    }
+    return res.result || { state: 'ok' };
+  },
+
   setIsolationLevel_meta: true,
   async setIsolationLevel({ sesid, level }) {
     const session = this.opened.find(x => x.sesid == sesid);

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '7.1.13',
-  buildTime: '2026-05-27T11:36:05.885Z'
+  version: '7.2.0',
+  buildTime: '2026-06-08T11:54:20.800Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -19,12 +19,14 @@ const { handleProcessCommunication } = require('../utility/processComm');
 const generateDeploySql = require('../shell/generateDeploySql');
 const { dumpSqlSelect, scriptToSql } = require('dbgate-sqltree');
 const { allowExecuteCustomScript, handleQueryStream } = require('../utility/handleQueryStream');
+const { enrichQueryResultColumns } = require('../utility/queryResultMetadata');
 const dbgateApi = require('../shell');
 const requirePlugin = require('../shell/requirePlugin');
 const path = require('path');
 const { rundir } = require('../utility/directories');
 const fs = require('fs-extra');
 const { changeSetToSql } = require('dbgate-datalib');
+const _ = require('lodash');
 
 const logger = getLogger('dbconnProcess');
 
@@ -253,6 +255,9 @@ async function handleQueryData({ msgid, sql, range, commandTimeout }, skipReadon
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
     const res = await driver.query(dbhan, sql, { range, commandTimeout });
+    if (res?.columns) {
+      res.columns = await enrichQueryResultColumns({ dbhan, driver, sql, columns: res.columns, dbinfo: analysedStructure });
+    }
     process.send({ msgtype: 'response', msgid, ...serializeJsTypesForJsonStringify(res) });
   } catch (err) {
     process.send({
@@ -381,6 +386,55 @@ async function handleSaveTableData({ msgid, changeSet }) {
   }
 }
 
+function validateQueryResultChangeSet(driver, changeSet) {
+  if (!driver.databaseEngineTypes?.includes('sql') || !driver.supportsEditableQueryResults) {
+    throw new Error('DBGM-00000 Editable query results are not supported by this driver');
+  }
+  if (changeSet?.inserts?.length > 0 || changeSet?.deletes?.length > 0) {
+    throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+  }
+  for (const update of changeSet?.updates || []) {
+    if (!update.pureName) {
+      throw new Error('DBGM-00000 Query result update is missing target table');
+    }
+    if (_.isEmpty(update.fields)) {
+      throw new Error('DBGM-00000 Query result update is missing changed fields');
+    }
+    if (_.isEmpty(update.condition)) {
+      throw new Error('DBGM-00000 Query result update is missing row condition');
+    }
+    if (Object.values(update.condition).some(value => value === null || value === undefined)) {
+      throw new Error('DBGM-00000 Query result update has incomplete row condition');
+    }
+  }
+}
+
+async function handleSaveQueryResultData({ msgid, changeSet, sql }) {
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+  try {
+    ensureExecuteCustomScript(driver);
+    validateQueryResultChangeSet(driver, changeSet);
+    if (!sql) {
+      const script = changeSetToSql({ ...changeSet, inserts: [], deletes: [] }, null, driver.dialect);
+      if (script.some(command => command.commandType != 'update')) {
+        throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+      }
+      sql = scriptToSql(driver, script);
+    }
+    if (sql) {
+      await driver.script(dbhan, sql, { useTransaction: false });
+    }
+    process.send({ msgtype: 'response', msgid, result: { state: 'ok' } });
+  } catch (err) {
+    process.send({
+      msgtype: 'response',
+      msgid,
+      errorMessage: extractErrorMessage(err, 'DBGM-00000 Error saving query result data'),
+    });
+  }
+}
+
 async function handleMultiCallMethod({ msgid, callList }) {
   try {
     const driver = requireEngineDriver(storedConnection);
@@ -557,7 +611,7 @@ async function handleExecuteSessionQuery({ sesid, sql }) {
     ...driver.getQuerySplitterOptions('stream'),
     returnRichInfo: true,
   })) {
-    await handleQueryStream(dbhan, driver, queryStreamInfoHolder, sqlItem, sesid);
+    await handleQueryStream(dbhan, driver, queryStreamInfoHolder, sqlItem, sesid, undefined, undefined, false, analysedStructure);
     if (queryStreamInfoHolder.canceled) {
       break;
     }
@@ -599,6 +653,7 @@ const messageHandlers = {
   runOperation: handleRunOperation,
   updateCollection: handleUpdateCollection,
   saveTableData: handleSaveTableData,
+  saveQueryResultData: handleSaveQueryResultData,
   collectionData: handleCollectionData,
   loadKeys: handleLoadKeys,
   scanKeys: handleScanKeys,

package/src/proc/sessionProcess.js

@@ -10,7 +10,9 @@ const requireEngineDriver = require('../utility/requireEngineDriver');
 const { decryptConnection } = require('../utility/crypting');
 const { connectUtility } = require('../utility/connectUtility');
 const { handleProcessCommunication } = require('../utility/processComm');
-const { getLogger, extractIntSettingsValue, extractBoolSettingsValue } = require('dbgate-tools');
+const { getLogger, extractIntSettingsValue, extractBoolSettingsValue, extractErrorMessage } = require('dbgate-tools');
+const { changeSetToSql } = require('dbgate-datalib');
+const { scriptToSql } = require('dbgate-sqltree');
 const { handleQueryStream, QueryStreamTableWriter, allowExecuteCustomScript } = require('../utility/handleQueryStream');
 
 const logger = getLogger('sessionProcess');
@@ -119,7 +121,7 @@ async function handleExecuteControlCommand({ command }) {
     process.send({
       msgtype: 'info',
       info: {
-        message: 'Connection without read-only sessions is read only',
+        message: 'Connection is read-only',
         severity: 'error',
       },
     });
@@ -149,7 +151,7 @@ async function handleExecuteControlCommand({ command }) {
   }
 }
 
-async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows, frontMatter }) {
+async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows, frontMatter, dbinfo }) {
   lastActivity = new Date().getTime();
 
   await waitConnected();
@@ -159,7 +161,7 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
     process.send({
       msgtype: 'info',
       info: {
-        message: 'Connection without read-only sessions is read only',
+        message: 'Connection is read-only',
         severity: 'error',
       },
     });
@@ -186,7 +188,8 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
         undefined,
         limitRows,
         frontMatter,
-        autoDetectCharts
+        autoDetectCharts,
+        dbinfo
       );
       // const handler = new StreamHandler(resultIndex);
       // const stream = await driver.stream(systemConnection, sqlItem, handler);
@@ -203,6 +206,69 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
   }
 }
 
+function validateQueryResultChangeSet(driver, changeSet) {
+  if (!driver.databaseEngineTypes?.includes('sql') || !driver.supportsEditableQueryResults) {
+    throw new Error('DBGM-00000 Editable query results are not supported by this driver');
+  }
+  if (changeSet?.inserts?.length > 0 || changeSet?.deletes?.length > 0) {
+    throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+  }
+  for (const update of changeSet?.updates || []) {
+    if (!update.pureName) {
+      throw new Error('DBGM-00000 Query result update is missing target table');
+    }
+    if (_.isEmpty(update.fields)) {
+      throw new Error('DBGM-00000 Query result update is missing changed fields');
+    }
+    if (_.isEmpty(update.condition)) {
+      throw new Error('DBGM-00000 Query result update is missing row condition');
+    }
+    if (Object.values(update.condition).some(value => value === null || value === undefined)) {
+      throw new Error('DBGM-00000 Query result update has incomplete row condition');
+    }
+  }
+}
+
+async function handleSaveQueryResultData({ msgid, changeSet, sql, autoCommit }) {
+  lastActivity = new Date().getTime();
+
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+  try {
+    if (!allowExecuteCustomScript(storedConnection, driver)) {
+      throw new Error('DBGM-00000 Connection is read-only');
+    }
+    validateQueryResultChangeSet(driver, changeSet);
+    if (!sql) {
+      const script = changeSetToSql({ ...changeSet, inserts: [], deletes: [] }, null, driver.dialect);
+      if (script.some(command => command.commandType != 'update')) {
+        throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+      }
+      sql = scriptToSql(driver, script);
+    }
+    if (sql) {
+      executingScripts++;
+      try {
+        await driver.script(dbhan, sql, { useTransaction: false });
+        if (autoCommit) {
+          const dmp = driver.createDumper();
+          dmp.commitTransaction();
+          await driver.query(dbhan, dmp.s, { discardResult: true });
+        }
+      } finally {
+        executingScripts--;
+      }
+    }
+    process.send({ msgtype: 'response', msgid, result: { state: 'ok' } });
+  } catch (err) {
+    process.send({
+      msgtype: 'response',
+      msgid,
+      errorMessage: extractErrorMessage(err, 'DBGM-00000 Error saving query result data'),
+    });
+  }
+}
+
 async function handleExecuteReader({ jslid, sql, fileName }) {
   lastActivity = new Date().getTime();
 
@@ -244,6 +310,7 @@ const messageHandlers = {
   executeControlCommand: handleExecuteControlCommand,
   setIsolationLevel: handleSetIsolationLevel,
   executeReader: handleExecuteReader,
+  saveQueryResultData: handleSaveQueryResultData,
   startProfiler: handleStartProfiler,
   stopProfiler: handleStopProfiler,
   ping: handlePing,

package/src/utility/handleQueryStream.js

@@ -4,9 +4,12 @@ const fs = require('fs');
 const _ = require('lodash');
 
 const { jsldir } = require('../utility/directories');
-const { serializeJsTypesReplacer } = require('dbgate-tools');
+const { serializeJsTypesReplacer, getLogger } = require('dbgate-tools');
 const { ChartProcessor } = require('dbgate-datalib');
 const { isProApp } = require('./checkLicense');
+const { enrichQueryResultColumns } = require('./queryResultMetadata');
+
+const logger = getLogger('handleQueryStream');
 
 class QueryStreamTableWriter {
   constructor(sesid = undefined) {
@@ -144,13 +147,21 @@ class StreamHandler {
     sesid = undefined,
     limitRows = undefined,
     frontMatter = undefined,
-    autoDetectCharts = false
+    autoDetectCharts = false,
+    supportsEditableQueryResults = false,
+    dbhan = null,
+    driver = null,
+    dbinfo = null
   ) {
     this.recordset = this.recordset.bind(this);
     this.startLine = startLine;
     this.sesid = sesid;
     this.frontMatter = frontMatter;
     this.autoDetectCharts = autoDetectCharts;
+    this.supportsEditableQueryResults = supportsEditableQueryResults;
+    this.dbhan = dbhan;
+    this.driver = driver;
+    this.dbinfo = dbinfo;
     this.limitRows = limitRows;
     this.rowsLimitOverflow = false;
     this.row = this.row.bind(this);
@@ -165,7 +176,8 @@ class StreamHandler {
     this.plannedStats = false;
     this.queryStreamInfoHolder = queryStreamInfoHolder;
     this.resolve = resolve;
-    this.rowCounter = 0;
+    this.currentRecordset = null;
+    this.recordsetQueuePromise = Promise.resolve();
     // currentHandlers = [...currentHandlers, this];
   }
 
@@ -180,21 +192,37 @@ class StreamHandler {
     process.send({ msgtype: 'changedCurrentDatabase', database, sesid: this.sesid });
   }
 
-  recordset(columns, options) {
+  async prepareRecordset(recordsetContext, columns, options) {
     if (this.rowsLimitOverflow) {
       return;
     }
     this.closeCurrentWriter();
-    this.currentWriter = new QueryStreamTableWriter(this.sesid);
-    this.currentWriter.initializeFromQuery(
-      Array.isArray(columns) ? { columns } : columns,
-      this.queryStreamInfoHolder.resultIndex,
-      this.frontMatter?.[`chart-${this.queryStreamInfoHolder.resultIndex + 1}`],
+    const writer = new QueryStreamTableWriter(this.sesid);
+    const structure = Array.isArray(columns) ? { columns } : columns;
+    const enrichedColumns = await enrichQueryStreamColumns(
+      structure?.columns,
+      this.sql,
+      this.supportsEditableQueryResults,
+      this.driver,
+      this.dbhan,
+      this.dbinfo
+    );
+    writer.initializeFromQuery(
+      {
+        ...structure,
+        columns: enrichedColumns,
+      },
+      recordsetContext.resultIndex,
+      this.frontMatter?.[`chart-${recordsetContext.resultIndex + 1}`],
       this.autoDetectCharts,
       options
     );
-    this.queryStreamInfoHolder.resultIndex += 1;
-    this.rowCounter = 0;
+    recordsetContext.writer = writer;
+    this.currentWriter = writer;
+    for (const row of recordsetContext.pendingRows) {
+      this.writeRow(recordsetContext, row, false);
+    }
+    recordsetContext.pendingRows = [];
 
     // this.writeCurrentStats();
 
@@ -204,15 +232,50 @@ class StreamHandler {
     //   }
     // }, 500);
   }
+
+  recordset(columns, options) {
+    const recordsetContext = {
+      pendingRows: [],
+      resultIndex: this.queryStreamInfoHolder.resultIndex,
+      rowCounter: 0,
+      writer: null,
+    };
+    this.queryStreamInfoHolder.resultIndex += 1;
+    this.currentRecordset = recordsetContext;
+
+    const recordsetReadyPromise = this.recordsetQueuePromise
+      .then(() => this.prepareRecordset(recordsetContext, columns, options))
+      .catch(err => {
+        recordsetContext.pendingRows = [];
+        this.info({
+          message: err?.message || `${err}`,
+          severity: 'error',
+        });
+      })
+      .finally(() => {
+        if (this.recordsetReadyPromise == recordsetReadyPromise) {
+          this.recordsetReadyPromise = null;
+        }
+      });
+    this.recordsetReadyPromise = recordsetReadyPromise;
+    this.recordsetQueuePromise = recordsetReadyPromise;
+  }
+
+  writeRow(recordsetContext, row, incrementCounter = true) {
+    recordsetContext.writer.row(row);
+    if (incrementCounter) recordsetContext.rowCounter += 1;
+  }
+
   row(row) {
     if (this.rowsLimitOverflow) {
       return;
     }
 
-    if (this.limitRows && this.rowCounter >= this.limitRows) {
+    const recordsetContext = this.currentRecordset;
+    if (this.limitRows && recordsetContext?.rowCounter >= this.limitRows) {
       process.send({
         msgtype: 'info',
-        info: { message: `Rows limit overflow, loaded ${this.rowCounter} rows, canceling query`, severity: 'error' },
+        info: { message: `Rows limit overflow, loaded ${recordsetContext.rowCounter} rows, canceling query`, severity: 'error' },
         sesid: this.sesid,
       });
       this.rowsLimitOverflow = true;
@@ -229,9 +292,11 @@ class StreamHandler {
       return;
     }
 
-    if (this.currentWriter) {
-      this.currentWriter.row(row);
-      this.rowCounter += 1;
+    if (recordsetContext?.writer) {
+      this.writeRow(recordsetContext, row);
+    } else if (recordsetContext) {
+      recordsetContext.pendingRows.push(row);
+      recordsetContext.rowCounter += 1;
     } else if (row.message) {
       process.send({ msgtype: 'info', info: { message: row.message }, sesid: this.sesid });
     }
@@ -241,9 +306,12 @@ class StreamHandler {
   //   process.send({ msgtype: 'error', error });
   // }
   done(result) {
-    this.closeCurrentWriter();
-    // currentHandlers = currentHandlers.filter((x) => x != this);
-    this.resolve();
+    const finish = () => {
+      this.closeCurrentWriter();
+      // currentHandlers = currentHandlers.filter((x) => x != this);
+      this.resolve();
+    };
+    this.recordsetQueuePromise.then(finish);
   }
   info(info) {
     if (info && info.line != null) {
@@ -259,6 +327,19 @@ class StreamHandler {
   }
 }
 
+async function enrichQueryStreamColumns(columns, sql, supportsEditableQueryResults, driver, dbhan, dbinfo) {
+  if (!supportsEditableQueryResults) return columns;
+  return enrichQueryResultColumns({
+    columns,
+    sql,
+    driver,
+    dbhan,
+    dbinfo,
+    onNativeMetadataError: err => logger.warn('Error enriching query stream columns', err),
+    onFallbackMetadataError: err => logger.warn('Error parsing query stream column metadata', err),
+  });
+}
+
 function handleQueryStream(
   dbhan,
   driver,
@@ -267,7 +348,8 @@ function handleQueryStream(
   sesid = undefined,
   limitRows = undefined,
   frontMatter = undefined,
-  autoDetectCharts = false
+  autoDetectCharts = false,
+  dbinfo = null
 ) {
   return new Promise((resolve, reject) => {
     const start = sqlItem.trimStart || sqlItem.start;
@@ -278,8 +360,13 @@ function handleQueryStream(
       sesid,
       limitRows,
       frontMatter,
-      autoDetectCharts
+      autoDetectCharts,
+      driver.databaseEngineTypes?.includes('sql') && driver.supportsEditableQueryResults,
+      dbhan,
+      driver,
+      dbinfo
     );
+    handler.sql = sqlItem.text;
     driver.stream(dbhan, sqlItem.text, handler);
   });
 }

package/src/utility/queryResultMetadata.js

@@ -0,0 +1,70 @@
+const {
+  extractSingleTableFromSql,
+  extractColumnSourcesFromSql,
+  extractColumnMetadataFromSql,
+} = require('dbgate-tools');
+
+function getColumnSourceName(columnSources, columnName) {
+  if (!columnSources || !columnName) return null;
+  if (columnSources[columnName]) return columnSources[columnName];
+
+  const matchingKeys = Object.keys(columnSources).filter(key => key.toLowerCase() == columnName.toLowerCase());
+  return matchingKeys.length == 1 ? columnSources[matchingKeys[0]] : null;
+}
+
+function getColumnMetadata(columnMetadata, columnName) {
+  if (!columnMetadata || !columnName) return null;
+  if (columnMetadata[columnName]) return columnMetadata[columnName];
+
+  const matchingKeys = Object.keys(columnMetadata).filter(key => key.toLowerCase() == columnName.toLowerCase());
+  return matchingKeys.length == 1 ? columnMetadata[matchingKeys[0]] : null;
+}
+
+async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, onNativeMetadataError, onFallbackMetadataError }) {
+  if (!columns?.length || !driver?.databaseEngineTypes?.includes('sql') || !driver?.supportsEditableQueryResults) {
+    return columns;
+  }
+
+  if (driver.enrichColumnMetadata) {
+    try {
+      const enriched = await driver.enrichColumnMetadata(dbhan, sql, columns, dbinfo);
+      if (enriched?.every(column => column.tableName && column.sourceColumnName)) return enriched;
+      if (enriched?.length == columns.length) columns = enriched;
+    } catch (err) {
+      onNativeMetadataError?.(err);
+    }
+  }
+
+  try {
+    const columnMetadata = extractColumnMetadataFromSql(sql);
+    if (columnMetadata) {
+      return columns.map(column => {
+        const metadata = getColumnMetadata(columnMetadata, column.columnName);
+        return {
+          ...column,
+          tableName: column.tableName || metadata?.tableName,
+          tableSchema: column.tableSchema || metadata?.schemaName,
+          sourceColumnName: column.sourceColumnName || metadata?.sourceColumnName,
+        };
+      });
+    }
+
+    const table = extractSingleTableFromSql(sql);
+    if (!table) return columns;
+    const columnSources = extractColumnSourcesFromSql(sql);
+
+    return columns.map(column => ({
+      ...column,
+      tableName: column.tableName || table.tableName,
+      tableSchema: column.tableSchema || table.schemaName,
+      sourceColumnName: column.sourceColumnName || getColumnSourceName(columnSources, column.columnName) || column.columnName,
+    }));
+  } catch (err) {
+    onFallbackMetadataError?.(err);
+    return columns;
+  }
+}
+
+module.exports = {
+  enrichQueryResultColumns,
+};