properly parse select subqueries

Author: jsumners-nr

lib/db/query-parsers/sql.js

@@ -5,19 +5,29 @@
 
 'use strict'
 
-const logger = require('../../logger').child({ component: 'sql_query_parser' })
+const defaultLogger = require('../../logger').child({ component: 'sql_query_parser' })
 const stringify = require('json-stringify-safe')
 
+/**
+ * In a query like `select * from (select * from foo)`, extract the subquery
+ * as the statement to retrieve the target identifier from.
+ *
+ * @type {RegExp}
+ */
+const selectSubquery = /from\s+?\((?<subquery>select.*?)\)(?:\s+?)?/gi
+
 /**
  * Parses a SQL statement into the parts we want to report as metadata in
  * database transactions.
  *
  * @param {string} sql The statement to parse.
+ * @param {object} [deps] A set of optional dependencies.
+ * @param {object} [deps.logger] A logger instance.
  *
  * @returns {{query: string, collection: null|string, operation: string}} Parsed
  * metadata.
  */
-module.exports = function parseSql(sql) {
+module.exports = function parseSql(sql, { logger = defaultLogger } = {}) {
   // Sometimes we get an object here from MySQL. We have been unable to
   // reproduce it, so we'll just log what that object is and return a statement
   // type of `other`.
@@ -27,7 +37,7 @@ module.exports = function parseSql(sql) {
   if (typeof sql !== 'string') {
     if (logger.traceEnabled()) {
       try {
-        logger.trace('parseSQL got an a non-string sql that looks like: %s', stringify(sql))
+        logger.trace('parseSQL got a non-string sql that looks like: %s', stringify(sql))
       } catch (err) {
         logger.debug(err, 'Unable to stringify SQL')
       }
@@ -166,10 +176,17 @@ function parseStatement(statement, kind = 'insert') {
     }
 
     case 'select': {
+      const subqueryMatch = selectSubquery.exec(statement)
+      if (subqueryMatch !== null) {
+        statement = subqueryMatch.groups.subquery
+      }
+
       if (/\bfrom\b/i.test(statement) === false) {
         // Statement does not specify a table. We don't need further processing.
+        // E.g., we have a statement like `select 1 + 1 as added`.
         return { collection: 'unknown', table: 'unknown' }
       }
+
       splitter = /\s*?\bfrom\b\s*?/i
       break
     }
@@ -240,7 +257,6 @@ function normalizeTableName(tableIdentifier) {
     if (parts.length === 1) {
       return parts[0]
     }
-    return '(subquery)'
   }
 
   const parenPos = tableIdentifier.indexOf('(')

test/unit/db/query-parsers/sql.test.js

@@ -164,6 +164,35 @@ test('database query parser', async (t) => {
   })
 })
 
+test('logs correctly if input is incorrect', () => {
+  let logs = []
+  const logger = {
+    traceEnabled() {
+      return true
+    },
+    trace(msg, data) {
+      logs.push([msg, data])
+    },
+    debug(error, msg) {
+      logs.push([error, msg])
+    }
+  }
+
+  let result = parseSql({ an: 'invalid object' }, { logger })
+  assert.deepStrictEqual(result, { operation: 'other', collection: null, query: '' })
+  assert.deepStrictEqual(logs, [
+    ['parseSQL got a non-string sql that looks like: %s', `{"an":"invalid object"}`]
+  ])
+
+  logs = []
+  logger.trace = () => {
+    throw Error('boom')
+  }
+  result = parseSql({ an: 'invalid object' }, { logger })
+  assert.deepStrictEqual(result, { operation: 'other', collection: null, query: '' })
+  assert.equal(logs[0][1], 'Unable to stringify SQL')
+})
+
 // test('reports correct info if inline comments present', () => {
 //   const statement = `--insert into`
 // })
@@ -299,3 +328,10 @@ test('handles odd characters attached to table names', () => {
   found = parseSql(statement)
   match(found, expected)
 })
+
+test('handles subqueries in place of table identifiers', () => {
+  const expected = { operation: 'select', collection: 'foo', table: 'foo' }
+  const statement = 'select * from (select foo from foo) where bar = "baz"'
+  const found = parseSql(statement)
+  match(found, expected)
+})