Added Optimizer, fixed sort and in SubQuery (#215)

Author: thiren

docs/docs/overrides/home.html

@@ -344,7 +344,7 @@ <h2>
         <div class="md-footer-meta__inner md-grid">
             <div class="md-copyright">
                 <div class="md-copyright__highlight">
-                    Copyright © 2023
+                    Copyright © 2025
                     <a href="https://synatic.com">Synatic Inc.</a>
                 </div>
 

lib/SQLParser.js

@@ -2,6 +2,7 @@ const {parseSQLtoAST} = require('./parseSQLtoAST');
 const {canQuery} = require('./canQuery');
 const {makeMongoAggregate, makeMongoQuery} = require('./make');
 const {getResultSchemaForStatement} = require('./metadata');
+const optimizer = require('./optimizer');
 
 /**
  * @typedef {import('./types').ParserOptions} ParserOptions
@@ -128,6 +129,16 @@ class SQLParser {
             options
         );
     }
+
+    /**
+     * Optimizes a Mongo Aggregate
+     *
+     * @param {Object[]} mongoAggregate - the mongo aggregate to optimize
+     * @param {Object} options - the optimization options
+     */
+    static optimizeMongoAggregate(mongoAggregate, options = {}) {
+        return optimizer.optimizeMongoAggregate(mongoAggregate, options);
+    }
 }
 
 module.exports = SQLParser;

lib/arraySequenceIndexOf.js

@@ -0,0 +1,46 @@
+/**
+ * Finds the starting index of the first occurrence of a sequence within an array, using a custom comparison function.
+ * @param {Array} sequenceArr - The sequence of elements to search for.
+ * @param {Array} inArray - The array in which to search for the sequence.
+ * @param {number} startIndex - the index to start searching from
+ * @param {Function} [compareFn] - Optional custom comparison function that takes two arguments and returns a boolean indicating whether they are equal.
+ * @returns {number} The starting index of the first occurrence of the sequence in the array or -1 if the sequence is not found.
+ */
+function arraySequenceIndexOf(sequenceArr, inArray, startIndex = 0, compareFn) {
+    compareFn =
+        compareFn ||
+        function (a, b) {
+            return a === b;
+        };
+    if (sequenceArr.length === 0) return 0;
+    if (sequenceArr.length === 1) {
+        return inArray.findIndex((a) => compareFn(a, sequenceArr[0]));
+    }
+    if (sequenceArr.length > inArray.length - startIndex) return -1;
+
+    let i = startIndex;
+    while (i < inArray.length) {
+        if (!compareFn(sequenceArr[0], inArray[i])) {
+            i++;
+            continue;
+        }
+        if (inArray.length < i + sequenceArr.length) {
+            return -1;
+        }
+        let j = 0;
+        let seqTrue = true;
+        while (seqTrue && j < sequenceArr.length) {
+            seqTrue = seqTrue && compareFn(sequenceArr[j], inArray[i + j]);
+            j++;
+        }
+        if (seqTrue) {
+            return i;
+        }
+
+        i++;
+    }
+
+    return -1;
+}
+
+module.exports = arraySequenceIndexOf;

lib/canQuery.js

@@ -180,7 +180,28 @@ function checkWhereContainsOtherTable(expr) {
     return false;
 }
 
+function checkWhereExpressionIsSubQuery(expr) {
+    if (!expr) {
+        return false;
+    }
+    if (expr.type === 'binary_expr') {
+        if (!['IN', 'NOT IN', '='].includes(expr.operator)) {
+            return false;
+        }
+        return (
+            checkWhereExpressionIsSubQuery(expr.left) ||
+            checkWhereExpressionIsSubQuery(expr.right)
+        );
+    }
+    if (expr.type === 'expr_list') {
+        return expr.value.reduce((a, v) => a || (v && v.ast), false);
+    }
+
+    return false;
+}
+
 module.exports = {
     canQuery,
     whereContainsOtherTable: checkWhereContainsOtherTable,
+    checkWhereExpressionIsSubQuery: checkWhereExpressionIsSubQuery,
 };

lib/make/filter-queries.js

@@ -9,7 +9,7 @@ function getWhereAstQueries(where, context) {
     if (where.right.value) {
         return [
             {
-                column: where.left.column,
+                column: where.left.table?(where.left.table + '.' + where.left.column) : where.left.column,
                 ast: where.right.value.filter(notAStandardValue),
             },
         ];

lib/make/index.js

@@ -4,6 +4,8 @@ const {createResultObject} = require('./createResultObject');
 const makeQueryPartModule = require('./makeQueryPart');
 const projectColumnParserModule = require('./projectColumnParser');
 const makeAggregatePipelineModule = require('./makeAggregatePipeline');
+const arraySequenceIndexOf = require('../arraySequenceIndexOf');
+const lodash = require('lodash');
 /**
  * Parses a sql statement into a mongo aggregate pipeline
  *
@@ -22,13 +24,34 @@ function makeMongoAggregate(sqlOrAST, options = {unwindJoins: false}, context) {
         context = newContext;
     }
     // todo fix sub select table return
+
+    const pipeline = makeAggregatePipelineModule.makeAggregatePipeline(
+        ast,
+        context
+    );
+    const tables = context.tables.filter((x, i, a) => a.indexOf(x) === i);
+    if (
+        context &&
+        context._reorderedTables &&
+        context._reorderedTables.length > 0
+    ) {
+        const tablesIndexOf = arraySequenceIndexOf(
+            lodash.reverse(context._reorderedTables),
+            tables
+        );
+        if (tablesIndexOf > -1) {
+            tables.splice(
+                tablesIndexOf,
+                context._reorderedTables.length,
+                ...lodash.reverse(context._reorderedTables)
+            );
+        }
+    }
+
     return {
-        pipeline: makeAggregatePipelineModule.makeAggregatePipeline(
-            ast,
-            context
-        ),
+        pipeline: pipeline,
         // subselect for arrays need to remove the collections since theyre actually arrays
-        collections: context.tables.filter((x, i, a) => a.indexOf(x) === i),
+        collections: tables,
         type: 'aggregate',
     };
 }