@corva/ui 0.38.0-1 → 0.38.0-6

package/src/utils/sqlParser.js

@@ -0,0 +1,1401 @@
+// /* eslint-disable
+//   no-underscore-dangle,
+//   no-param-reassign,
+//   no-restricted-globals
+// */
+// import { lexer, parser } from 'sql-parser';
+// import { List } from 'immutable';
+// import uuidV1 from 'uuid/v1';
+// import moment from 'moment';
+// import { find } from 'lodash';
+
+// /**
+// **
+// ** getDataType is helper function to get the javascript data type as string.
+// **
+// * */
+// function getDataType(obj) {
+//   return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
+// }
+
+// /*
+//  * _toTitleCase
+//  * It capitalizes the first character of the word
+//  * @param {*} originName
+//  *
+//  */
+// function _toTitleCase(originName) {
+//   originName = originName.replace(/_|-/g, ' ');
+//   const tokens = originName.split(' ');
+//   return tokens.map(token => token.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())).join(' ');
+// }
+
+// /**
+// ** _getFieldAlias function generates the alias for field name
+// ** This function will be used when you are missing "AS" keyword in "select fieldname as"
+// **
+// ** examples
+// ** data.mud.id  => MudID
+// **
+// ** steps to generate alias
+// ** 1. get rid of "data" prefix if exists.
+// ** 2. capitalize each letter in field path
+// **
+// ** TODO: suggest more clever alias generate algorithm
+// ** It doesn't make sense for e.g data.top_depth => Top_depth
+// **
+// * */
+// function _getFieldAlias(fieldName) {
+//   const fieldPath = fieldName.split('.');
+//   let alias = '';
+//   for (let i = 0; i < fieldPath.length; i += 1) {
+//     if (fieldPath[i] !== 'data') {
+//       alias += `${_toTitleCase(fieldPath[i])} `;
+//     }
+//   }
+//   return alias.trim(); // remove last space;
+// }
+
+// /**
+//  * _getFunctionAlias is mainly used for naming functional field
+//  * e.g sum(data.operation_time), round(data.duration)
+// * */
+// function _getFunctionAlias(funcName) {
+//   if (!funcName) {
+//     return null;
+//   }
+//   switch (funcName) {
+//     case 'sum':
+//       return 'Total';
+//     case 'avg':
+//       return 'Average';
+//     case 'min':
+//       return 'Min';
+//     case 'max':
+//       return 'Max';
+//     case 'count':
+//       return 'Number of';
+//     case 'round':
+//       return ''; // give empty function alias for round
+//     default:
+//       return _toTitleCase(funcName);
+//   }
+// }
+
+// /*
+// **
+// ** _analyzeObject traverses the object in any nested level
+// ** It generates the list of field name and possible alias name of field
+// **
+// */
+// function _analyzeObjectHelper(pKeys, key, val) {
+//   const valType = getDataType(val);
+//   let fullKey;
+//   if (pKeys && pKeys.length > 0) {
+//     fullKey = `${pKeys.join('.')}.${key}`;
+//   } else {
+//     fullKey = key;
+//   }
+//   return { fullKey, valType };
+// }
+
+// function _analyzeObject(obj, pKeys = [], results = []) {
+//   const keys = Object.keys(obj);
+//   for (let i = 0; i < keys.length; i += 1) {
+//     const key = keys[i];
+//     const { fullKey, valType } = _analyzeObjectHelper.apply(this, [pKeys, key, obj[key]]);
+
+//     if (valType === 'string' || valType === 'number' || valType === 'boolean') {
+//       results.push({ name: fullKey, alias: _getFieldAlias(fullKey), dataType: valType });
+//     }
+
+//     if (obj[key] !== null && getDataType(obj[key]) === 'object') {
+//       // going one step down in the object tree!!
+//       pKeys.push(key);
+//       _analyzeObject(obj[key], pKeys, results);
+//     }
+//   }
+//   pKeys.pop();
+//   return results;
+// }
+
+// /*
+// function _analyzeObject(obj, pKeys = [], results = []) {
+//   for (const key in obj) {
+//     const { fullKey, valType } = _analyzeObjectHelper.apply(this, [pKeys, key, obj[key]]);
+
+//     if (valType === 'string' || valType === 'number') {
+//       results.push({ name: fullKey, alias: _getFieldAlias(fullKey), dataType: valType });
+//     }
+
+//     if (obj[key] !== null && getDataType(obj[key]) === 'object') {
+//       // going one step down in the object tree!!
+//       pKeys.push(key);
+//       _analyzeObject(obj[key], pKeys, results);
+//     }
+//   }
+//   pKeys.pop();
+//   return results;
+// }
+// */
+
+// /**
+//  * Returns all indexes of certain character
+//  * @param  {String} string
+//  * @param  {String} character
+//  * @return {Array}
+//  */
+// function indexesOf(string, character) {
+//   return string
+//     .split('')
+//     .reduce(
+//       (indexes, value, index) => (value === character ? [...indexes, index] : indexes),
+//       [],
+//     );
+// }
+
+// /**
+//  * Substitutes characters on certain indexes in string to passed character
+//  * @param  {String} string
+//  * @param  {Array} indexes
+//  * @param  {String} character
+//  * @return {String}
+//  */
+// function substituteCharacters(string, indexes, character) {
+//   return string
+//     .split('')
+//     .map((value, index) => (indexes.includes(index) ? character : value))
+//     .join('');
+// }
+
+// /*
+// **
+// ** preProcessQueryString function accetps the raw sql query
+// ** It replaces some special characters the way sql parser can read
+// **
+// ** For example, sqlparser can't parse the '-' in table name (from table-name)
+// **
+//  */
+// function _preProcessQueryString(rawString) {
+//   // split the query based on 'from' keyword
+//   const matches = rawString.match(/from\s/i);
+//   const fromKeyword = matches[0];
+//   const rawQueryParts = rawString.split(fromKeyword);
+//   const afterFromTokens = rawQueryParts[1].trim().split(' ');
+
+//   const tableName = afterFromTokens[0];
+//   // NOTE: Save indexes of '-' to replaces them back later
+//   const indexesOfDash = indexesOf(tableName, '-');
+//   // replace '-' with '_' for tablename
+//   afterFromTokens[0] = tableName.replace(new RegExp('-', 'g'), '_');
+
+//   const safeQuery = `${rawQueryParts[0]} from ${afterFromTokens.join(' ')}`;
+
+//   return { safeQuery, indexesOfDash };
+// }
+
+// /**
+// ** shouldInterpolate function checks if
+// ** right operand is keyword that we need to interpolate
+// ** It can be filter or It can be time value
+// **
+// ** filter example "[WC=surface]"
+// ** time example "::25_days_ago"
+// **
+// ** TODO implement regular expression to check its validity as a filter.
+// **
+// * */
+// function _shouldInterpolate(operand) {
+//   if (operand.indexOf('[') > -1 && operand.indexOf(']') > -1) {
+//     return 'filter';
+//   } else if (operand.indexOf('::') > -1) {
+//     return 'time';
+//   } else if (operand.indexOf(':-') > -1) {
+//     return 'neg';
+//   }
+//   return null;
+// }
+
+// function _parseVal(val, mustBeNumber, quote) {
+//   if (isNaN(val)) {
+//     if (mustBeNumber) {
+//       return 0;
+//     }
+//     return quote + val.replace(/"/g, '\\"').replace(/'/g, "\\'") + quote; // escape to pass json.parse
+//   }
+
+//   return parseFloat(val);
+// }
+
+// /**
+// **
+// ** parse date keyword and get timezone(server) considered unix timestamp
+// ** parse keyword string including x_days x_hrs x_weeks x_years, 2016-07-05
+// ** returns unix timestamp
+// **
+// * */
+// function _getTimestampByKeyword(dateKeyword) {
+//   const timezoneDiff = (new Date().getTimezoneOffset()) * 60 * 1000;
+//   const now = new Date(new Date().getTime() + timezoneDiff);
+
+//   if (dateKeyword === 'now') {
+//     return now.getTime() / 1000;
+//   }
+
+//   const timeVal = dateKeyword.split('_')[0];
+//   const timeUnit = dateKeyword.split('_')[1];
+//   const timeDirection = dateKeyword.split('_')[2];
+//   const direction = (timeDirection === 'later') ? 1 : -1;
+//   switch (timeUnit) {
+//     case 'hours':
+//       return now.setHours(now.getHours() + (timeVal * direction)) && now.getTime() / 1000;
+//     case 'days':
+//       return now.setDate(now.getDate() + (timeVal * direction)) && now.getTime() / 1000;
+//     case 'weeks':
+//       return now.setDate(now.getDate() + (timeVal * 7 * direction)) && now.getTime() / 1000;
+//     case 'months':
+//       return now.setMonth(now.getMonth() + (timeVal * direction)) && now.getTime() / 1000;
+//     case 'years':
+//       return now.setYear(now.getYear() + (timeVal * direction)) && now.getTime() / 1000;
+//     default: // real date like 2016-05-07
+//       return (new Date(new Date(timeVal).getTime() + timezoneDiff)).getTime() / 1000;
+//   }
+// }
+
+// /**
+// **
+// ** _getMongoQuery function is utility function to get the query section of mongo query
+// ** It generates the mongo compatible "query" section
+// **
+// ** example
+// ** {$or: [{data.operation_name: "Connection"}, {data.operation_time:{$gte:20}}] }
+// **
+// * */
+// let _mMatch = '';
+
+// function _getMongoOperation(op) {
+//   op = op.toLowerCase();
+//   switch (op) {
+//     case 'and':
+//       return '$and';
+//     case 'or':
+//       return '$or';
+//     case '=':
+//       return '$eq';
+//     case '!=':
+//       return '$ne';
+//     case '>':
+//       return '$gt';
+//     case '>=':
+//       return '$gte';
+//     case '<':
+//       return '$lt';
+//     case '<=':
+//       return '$lte';
+//     default:
+//       return '';
+//   }
+// }
+
+// function _quotify(str, quote = '"') {
+//   return quote + str + quote;
+// }
+
+// function _procQueryNode(obj, filters) {
+//   const leftOperand = obj.left.values.join('.');
+//   const interpolation = obj.right.quoteType && _shouldInterpolate(obj.right.value);
+
+//   if (obj.operation === '=' && obj.right.quoteType && interpolation === 'filter') { // used filter
+//     const rightValue = obj.right.value.replace(/\[|\]/g, '');
+//     const tokens = rightValue.split('=');
+//     const filterName = tokens[0];
+//     const filterKey = tokens[1];
+//     const matchingFilter = filters && filters.find(f => f.get('name') === filterName);
+
+//     if (matchingFilter) {
+//       let matchingFilterDetailItems = List([]);
+//       let nothingChecked;
+//       if (filterKey) {
+//         matchingFilterDetailItems = matchingFilter.get('details').filter(detail => detail.get('key') === filterKey);
+//       } else if (matchingFilter.getIn(['options', 'selection']) === 'single') {
+//         matchingFilterDetailItems = matchingFilter.get('details').filter(detail => detail.get('key') === matchingFilter.getIn(['options', 'selected_key']));
+//       } else {
+//         matchingFilterDetailItems = matchingFilter.get('details').filter(detail => detail.get('checked'));
+//         nothingChecked = true;
+//       }
+//       if (matchingFilterDetailItems.size > 0) {
+//         _mMatch += '"$or":[';
+
+//         matchingFilterDetailItems.map((matchingFilterDetailItem, index) => {
+//           const filterValue = matchingFilterDetailItem.get('value');
+//           if (filterName === 'DateRange') {
+//             if (filterValue === 'all') {
+//               _mMatch += `{ "${leftOperand}" : { "$exists" : true } }`; // /just dumb condition
+//             } else {
+//               const dateKeywords = filterValue.split('~');
+//               let dateMin = dateKeywords[0] || 'now';
+//               let dateMax = dateKeywords[1] || 'now';
+//               dateMin = _getTimestampByKeyword(dateMin);
+//               dateMax = _getTimestampByKeyword(dateMax);
+//               _mMatch += `{"$and":[ {"${leftOperand}": {"$gt": ${dateMin}}}, {"${leftOperand}": {"$lt": ${dateMax}}} ] }`;
+//             }
+//           } else if (isNaN(filterValue) && filterValue.indexOf('~') > -1) { // range values
+//             const ranges = filterValue.split('~');
+//             const min = _parseVal(ranges[0], true);
+//             const max = _parseVal(ranges[1], true);
+//             // $and: [{leftOperand:{$gt:min}}, {leftOperand:{$lt:max}}]
+//             _mMatch += `{"$and":[ {"${leftOperand}": {"$gt": ${min}}}, {"${leftOperand}": {"$lt": ${max}}} ] }`;
+//           } else { // single value;
+//             const val = _parseVal(filterValue, false, '"');
+//             _mMatch += `{ "${leftOperand}" : { "$eq" : ${val}} }`;
+//           }
+
+//           if (index < matchingFilterDetailItems.size - 1) {
+//             _mMatch += ',';
+//           }
+
+//           return null;
+//         });
+//         _mMatch += ']';
+//         return;
+//       }
+
+//       // where used filter but no checkbox was checked. in this case don't apply filter.
+//       if (nothingChecked) {
+//         _mMatch += '"$or":[';
+//         _mMatch += `{ "${leftOperand}" : { "$exists" : true } }`; // /just dumb condition
+//         _mMatch += ']';
+//         return;
+//       }
+//     }
+//   }
+
+//   if (obj.right.quoteType && interpolation === 'time') {
+//     // time interpolation
+//     const rightValue = obj.right.value.replace(/::/g, '');
+//     const timestamp = _getTimestampByKeyword(rightValue);
+//     _mMatch += '"$or":[';
+//     _mMatch += `{ "${leftOperand}" : { ${_quotify(_getMongoOperation(obj.operation))} : ${timestamp}} }`;
+//     _mMatch += ']';
+//     return;
+//   }
+
+//   if (obj.right.quoteType && interpolation === 'neg') {
+//     const rightValue = -1 * Number(obj.right.value.replace(/:-/g, ''));
+//     _mMatch += `"${leftOperand}" : { ${_quotify(_getMongoOperation(obj.operation))} : ${rightValue}}`;
+//     return;
+//   }
+
+//   // normal value
+//   const rightOperand = (obj.right.quoteType) ? _quotify(obj.right.value) : obj.right.value;
+//   _mMatch += `"${leftOperand}" : { ${_quotify(_getMongoOperation(obj.operation))} : ${rightOperand}}`;
+// }
+
+// function _getMongoQuery(obj, filters) {
+//   if (!obj) { return; }
+//   if (obj.operation.toLowerCase() === 'and' || obj.operation.toLowerCase() === 'or') {
+//     // always follow left branch first
+//     _mMatch += `${_quotify(_getMongoOperation(obj.operation))}:[`;
+//     if (obj.left) {
+//       _mMatch += '{';
+//       _getMongoQuery(obj.left, filters);
+//       _mMatch += '},';
+//     }
+//     // then the right branch if it exists
+//     if (obj.right) {
+//       _mMatch += '{';
+//       _getMongoQuery(obj.right, filters);
+//       _mMatch += '}';
+//     }
+//     _mMatch += ']';
+//   } else {
+//     // do stuff for leaf nodes
+//     _procQueryNode(obj, filters);
+//   }
+// }
+
+// /**
+// **
+// ** [Every X] syntax is special syntax that's parsed outside of SQLParser.
+// ** [Every] syntax must be at the end of sql string to get rid of any confusion.
+// **
+// ** TODO It msut be integrated into SQLParser npm module we're using.
+// **
+// * */
+// function _getEveryClause(rawString) {
+//   const aryEveryClause = rawString.match(/\[every.*\]/ig);
+//   if (!aryEveryClause) {
+//     return null;
+//   }
+//   if (aryEveryClause.length > 1) {
+//     throw new Error('Only one every clause allowed');
+//   }
+//   const everyKeyword = aryEveryClause[0];
+//   if (!rawString.endsWith(everyKeyword)) {
+//     throw new Error('Every clause should be at the end.');
+//   }
+//   return everyKeyword;
+// }
+
+// function _parseEveryKeyword(everyKeyword) {
+//   everyKeyword = everyKeyword.replace(/\[|\]/ig, '');
+//   const everyElems = everyKeyword.split(' ');
+//   const everyVal = parseInt(everyElems[1].trim(), 10);
+//   return everyVal;
+// }
+
+// /**
+//  *
+//  * _inOrderTraversal
+//  *
+//  * This function traverses the binary tree by "in-order" traverse method
+//  * and generates the mathematic expression that will be evaluated later.
+//  *
+//  * TODOs
+//  * 1. try to merge the functionality of _inOrderTraversal and _flattenOpField
+//  * 2. Now it has redundant ) to the rightmost of the expression
+//  *
+//  *
+//  * @param {*} field
+//  * @param {*} isRight
+//  */
+// function _inOrderTraversal(field, isRight) {
+//   let expression = '';
+//   if (field.left) {
+//     if (field.left.operation) {
+//       expression += '(';
+//     }
+//     expression += _inOrderTraversal(field.left);
+//   }
+//   if (field.operation) {
+//     expression += field.operation;
+//   }
+//   if (field.alias && !field.isRoot) {
+//     expression += (!field.isConst)
+//       ? `-st-${field.alias}-ed-` // non-const field with prefix -st- and suffix -ed- for easy replacement later
+//       : field.alias;
+//   }
+
+//   if (field.right) {
+//     if (field.right.operation) {
+//       expression += '(';
+//     }
+//     expression += _inOrderTraversal(field.right, true);
+//   }
+
+//   if (isRight && !field.isRoot) {
+//     expression += ')';
+//   }
+//   return expression;
+// }
+
+// /**
+//  *
+//  * _flattenOpField
+//  *
+//  * This function traverses the nested tree of operation field
+//  * and extracts the list of actual aggregation fields that are being used
+//  * inside the arithmatic expression
+//  *
+//  * @param {*} field
+//  * @param {*} results
+//  */
+// function _flattenOpField(field, results = []) {
+//   if (field.operation) {
+//     if (field.left) {
+//       _flattenOpField(field.left, results);
+//     }
+//     if (field.right) {
+//       _flattenOpField(field.right, results);
+//     }
+//   } else if (!field.isConst) {
+//     if (!results.find(result => result.alias === field.alias)) {
+//       // prevent duplication
+//       results.push(field);
+//     }
+//   }
+//   return results;
+// }
+
+// /**
+//  *
+//  * _parseFieldNode
+//  *
+//  * This function parse the individual field
+//  * Field can be operational, functional, or literal.
+//  * Operational select sum(a)/count(a)
+//  * Functional select sum(a)
+//  * Literal select a
+//  * If field is operatinal field, it will have binary tree that expresses
+//  * the mathematic expression of the field
+//  *
+//  * @param {*} node
+//  * @param {*} isRoot
+//  */
+// function _parseFieldNode(node, isRoot = true) {
+//   const main = {};
+//   let field;
+//   let asName;
+//   if (!isRoot) {
+//     field = node;
+//   } else {
+//     ({ field, name: asName } = node);
+//   }
+//   if (field.operation) {
+//     if (isRoot) {
+//       if (asName) {
+//         main.alias = asName.values
+//           ? asName.values.join('.')
+//           : asName.value;
+//       } else {
+//         switch (field.operation) {
+//           case '+':
+//             main.alias = 'Aggregation';
+//             break;
+//           case '-':
+//             main.alias = 'Difference';
+//             break;
+//           case '*':
+//             main.alias = 'Multiplication';
+//             break;
+//           case '/':
+//             main.alias = 'Average';
+//             break;
+//           default:
+//             main.alias = 'Anonymous';
+//         }
+//         main.alias += new Date().getTime();
+//       }
+//     }
+//     main.isRoot = isRoot;
+//     main.operation = field.operation;
+//     if (field.left) {
+//       const leftNode = _parseFieldNode(field.left, false);
+//       main.left = leftNode;
+//     }
+//     if (field.right) {
+//       const rightNode = _parseFieldNode(field.right, false);
+//       main.right = rightNode;
+//     }
+//   } else {
+//     const nonOpField = {
+//       isRoot,
+//     };
+//     if (field.arguments) {
+//       const { arguments: _arguments } = field;
+//       nonOpField.name = _arguments.value && _arguments.value[0].values.join('.');
+//       nonOpField.function = field.name;
+//       if (nonOpField.function === 'round') {
+//         // Get the tick, start, end for round/bucket
+//         nonOpField.tick = _arguments.value[1] && _arguments.value[1].value;
+//         nonOpField.start = _arguments.value[2] && _arguments.value[2].value;
+//         nonOpField.end = _arguments.value[3] && _arguments.value[3].value;
+//       }
+//     } else if (field.values) {
+//       // normal field name
+//       nonOpField.name = field.values.join('.');
+//     } else {
+//       // numeric value (e.g 60)
+//       nonOpField.isConst = true;
+//       nonOpField.name = field.value;
+//     }
+//     const _funcAlias = nonOpField.function ? _getFunctionAlias(nonOpField.function) : null;
+//     if (asName) {
+//       nonOpField.alias = asName.values
+//         ? asName.values.join('.')
+//         : asName.value;
+//     } else {
+//       const _fieldAlias = nonOpField.isConst
+//         ? nonOpField.name
+//         : _getFieldAlias(nonOpField.name);
+//       nonOpField.alias = (_funcAlias ? `${_funcAlias} ` : '') + _fieldAlias;
+//     }
+//     return nonOpField;
+//   }
+//   return main;
+// }
+
+// /**
+// **
+// ** getMongoTokens accepts the raw sql string as an argument
+// ** It tries to parse the raw sql and generate an tokens
+// ** that are used for generating mongo query string in next step
+// **
+// ** example list of sql queries
+// ** select distinct(data.name), data.top_depth, data.bottom_depth from data.well-sections
+// ** select data.name, sum(data.top_depth) from data.well-sections
+// **
+// ** mongo tokens example
+// ** { mCollection, mMatch, mGroup, mFields}
+// **
+// * */
+// function getMongoTokens(rawString, filters) {
+//   // Parse [Every X] syntax and strip that syntax from raw sql string.
+//   const everyKeyword = _getEveryClause(rawString);
+//   let tokens;
+//   let parsed;
+
+//   if (everyKeyword) {
+//     rawString = rawString.replace(everyKeyword, '');
+//   }
+
+//   const { safeQuery, indexesOfDash } = _preProcessQueryString(rawString);
+//   rawString = safeQuery;
+
+//   _mMatch = '';
+
+//   try {
+//     tokens = lexer.tokenize(rawString);
+//     parsed = parser.parse(tokens);
+//   } catch (e) {
+//     throw new Error('sql parsing error');
+//   }
+
+//   const _fields = parsed.fields;
+//   const _source = parsed.source;
+//   const _where = parsed.where;
+//   const _group = parsed.group;
+//   const _limit = parsed.limit;
+//   const _order = parsed.order;
+//   const _joins = parsed.joins;
+
+//   const mCollection = {};
+//   const mFields = [];
+//   const mJoin = {};
+//   let mGroups;
+//   let mLimit;
+//   let mMatch;
+//   let mOrders;
+//   const mEvery = everyKeyword ? _parseEveryKeyword(everyKeyword) : null;
+
+//   // get the collection name
+//   if (!_source) {
+//     throw new Error('collection not specified');
+//   }
+//   mCollection.allias = _source.alias ? _source.alias.value : null;
+//   // NOTE: Return '-' to table name where is was replaced with '_'
+//   mCollection.name = substituteCharacters(_source.name.values.join('.'), indexesOfDash, '-');
+
+//   // joins - support joins with asset collection only
+//   if (_joins && _joins.length > 0) {
+//     mJoin.key = _joins[0].conditions.value;
+//     mJoin.collection = _joins[0].right.name.value;
+//   }
+
+//   // fields
+//   if (!_fields || _fields.length < 1) {
+//     throw new Error('fields not specified.');
+//   }
+
+//   let _subFields = [];
+//   for (let i = 0; i < _fields.length; i += 1) {
+//     const fieldNode = _fields[i];
+//     if (fieldNode.field) {
+//       const _rootField = _parseFieldNode(fieldNode);
+//       if (_rootField.operation) {
+//         const _flatten = _flattenOpField(_rootField);
+//         const _expression = _inOrderTraversal(_rootField).slice(0, -1); // remove last )
+//         _rootField.expression = _expression;
+//         _rootField.flatten = _flatten;
+//         _subFields = _subFields.concat(_flatten);
+//       }
+//       if (!mFields.find(f => f.alias === _rootField.alias)) {
+//         mFields.push(_rootField);
+//       }
+//     }
+//   }
+//   for (let i = 0; i < _subFields.length; i += 1) {
+//     if (!mFields.find(f => f.alias === _subFields[i].alias)) {
+//       mFields.push(_subFields[i]);
+//     }
+//   }
+
+//   if (_where && _where.conditions) {
+//     _getMongoQuery(_where.conditions, filters);
+//     mMatch = `{${_mMatch}}`;
+//   }
+
+//   // group
+//   if (_group) {
+//     mGroups = _group.fields.map((_field) => {
+//       if (_field.values) { // group by data.operation_name
+//         return {
+//           name: _field.values.join('.'),
+//           alias: null,
+//         };
+//       }
+//       // group by 1
+//       // TODO: group by [number] no longer accurate due to discrimination
+//       // between root fields and subfields
+//       return mFields[_field.value - 1];
+//     });
+
+//     let _mGroupValid = true;
+//     mGroups.map((mGroup) => {
+//       if (!mGroup) {
+//         _mGroupValid = false;
+//       }
+//       return mGroup;
+//     });
+//     if (!_mGroupValid) {
+//       throw new Error('Invalid grouping');
+//     }
+//   }
+
+//   // order by
+//   if (_order && _order.orderings.length >= 1) {
+//     mOrders = _order.orderings.map(ordering => ({
+//       direction: ordering.direction.toLowerCase() === 'asc' ? 1 : -1,
+//       field: ordering.value.values.join('.'),
+//     }));
+//   }
+
+//   // limit
+//   if (_limit) {
+//     mLimit = _limit.value.value;
+//   }
+
+//   return {
+//     mCollection,
+//     mFields,
+//     mMatch,
+//     mGroups,
+//     mOrders,
+//     mLimit,
+//     mEvery,
+//     mJoin,
+//   };
+// }
+
+// /**
+//  *
+//  * parseEverySyntaxTokens is a specific workflow to parse the [every x] syntax
+//  * Inside this function it composes the aggregation based on timestamp and $mod operator
+//  * It ignores groups if there.
+//  *
+// * */
+// function parseEverySyntaxTokens(mongoTokens, filters, assetIds, companyId) {
+//   const mongoQueryJson = {};
+//   const {
+//     mFields, mLimit, mMatch, mOrders, mEvery, mSchema,
+//   } = mongoTokens;
+//   let _matchJson = {};
+//   const _aggregateJson = [];
+//   const _sortJson = {};
+
+//   if (companyId) {
+//     _aggregateJson.push({ $match: { company_id: companyId } });
+//   }
+
+//   if (assetIds) {
+//     if (assetIds.length === 1) {
+//       _aggregateJson.push({ $match: { asset_id: parseInt(assetIds[0], 10) } });
+//     } else if (assetIds.length > 1) {
+//       const assetMatchJson = [];
+//       for (let i = 0; i < assetIds.length; i += 1) {
+//         assetMatchJson.push({ asset_id: parseInt(assetIds[i], 10) });
+//       }
+//       _aggregateJson.push({ $match: { $or: assetMatchJson } });
+//     }
+//   }
+
+//   if (mMatch) { // try to put $match at the first thing in the aggregatino pipeline
+//     _matchJson = JSON.parse(mMatch);
+//     _aggregateJson.push({ $match: _matchJson });
+//   }
+
+//   if (mOrders) {
+//     for (let i = 0; i < mOrders.length; i += 1) {
+//       const _mOrder = mOrders[i];
+//       _sortJson[_mOrder.field] = _mOrder.direction;
+//     }
+//     _aggregateJson.push({ $sort: _sortJson });
+//   }
+
+//   if (mLimit) {
+//     _aggregateJson.push({ $limit: mLimit });
+//   } else {
+//     _aggregateJson.push({ $limit: 500 });
+//   }
+
+//   const mGroup = {
+//     _id: {
+//       $subtract: [
+//         '$timestamp',
+//         { $mod: ['$timestamp', mEvery] },
+//       ],
+//     },
+//   };
+
+//   const groupFields = (mFields.length < 1)
+//     ? mSchema
+//     : mFields.filter(f => !f.operation); // only get non-operational fields;
+
+//   for (let i = 0; i < groupFields.length; i += 1) {
+//     const fieldName = groupFields[i].name;
+//     if (fieldName !== '_id') {
+//       const _shadowFieldName = fieldName.replace(/\./g, '___');
+//       mGroup[_shadowFieldName] = { $last: `$${fieldName}` };
+//     }
+//   }
+
+//   // select data.operation_time from t order by timestamp [every 1000]
+//   // we need to add 'timestamp' to $group clause
+//   // otherwise later sort will not work
+//   const _laterSortJson = {};
+//   if (mOrders) {
+//     for (let i = 0; i < mOrders.length; i += 1) {
+//       const _mOrder = mOrders[i];
+//       const _shadowFieldName = _mOrder.field.replace(/\./g, '___');
+//       mGroup[_shadowFieldName] = { $last: `$${_mOrder.field}` };
+//       _laterSortJson[_shadowFieldName] = _mOrder.direction;
+//     }
+//   }
+
+//   _aggregateJson.push({ $group: mGroup });
+
+//   // we need to apply $sort again because result was shuffled because of groupby timestamp
+//   if (mOrders) {
+//     _aggregateJson.push({ $sort: _laterSortJson });
+//   }
+
+//   mongoQueryJson.aggregate = JSON.stringify(_aggregateJson);
+//   return mongoQueryJson;
+// }
+
+// /**
+//  *
+//  * parseRoundTokens is a specific workflow to parse the round() function
+//  * Inside this function it composes the $bucket aggregtation to get the expected result
+//  * It ignores groups and orders if there.
+//  * It also rewrites the mFields because fields in select statement and api response are different.
+//  *
+// * */
+// function parseRoundTokens(mongoTokens, filters, assetIds, companyId) {
+//   const mongoQueryJson = {};
+//   const { mFields, mLimit, mMatch } = mongoTokens;
+//   let _matchJson = {};
+//   const _aggregateJson = [];
+//   const roundField = find(mFields, mField => mField.function === 'round');
+//   const limit = mLimit || 50; // 50 buckets by default;
+//   let { tick, start, end } = roundField;
+//   const boundaries = [];
+
+//   if (companyId) {
+//     _aggregateJson.push({ $match: { company_id: companyId } });
+//   }
+
+//   if (assetIds) {
+//     if (assetIds.length === 1) {
+//       _aggregateJson.push({ $match: { asset_id: parseInt(assetIds[0], 10) } });
+//     } else if (assetIds.length > 1) {
+//       const assetMatchJson = [];
+//       for (let i = 0; i < assetIds.length; i += 1) {
+//         assetMatchJson.push({ asset_id: parseInt(assetIds[i], 10) });
+//       }
+//       _aggregateJson.push({ $match: { $or: assetMatchJson } });
+//     }
+//   }
+
+//   if (mMatch) { // try to put $match at the first thing in the aggregatino pipeline
+//     _matchJson = JSON.parse(mMatch);
+//     _aggregateJson.push({ $match: _matchJson });
+//   }
+
+//   start = start || 0; // by default give 0 for start;
+//   tick = tick || 10; // by default give 10 for tick;
+//   end = end || 999999999; // by default give huge value for end;
+//   while (start < end && boundaries.length < limit) {
+//     boundaries.push(start);
+//     start += tick;
+//   }
+
+//   if (boundaries.length > 0) {
+//     _aggregateJson.push({
+//       $bucket: {
+//         groupBy: `$${roundField.name}`,
+//         boundaries,
+//         default: 'Other',
+//         output: {
+//           distribution: { $sum: 1 },
+//         },
+//       },
+//     });
+//   }
+
+//   // we know the schema/foramt of response json
+//   // change the mFields the way we expect from server response
+//   const newFields = [];
+//   newFields[0] = Object.assign({}, roundField, { name: '_id' });
+//   newFields[1] = {
+//     name: 'distribution',
+//     alias: 'Distribution',
+//     isRoot: true, // Distrubtion Field should be root field.
+//   };
+//   mongoTokens.mFields = newFields;
+//   mongoTokens.mGroups = null;
+
+//   mongoQueryJson.aggregate = JSON.stringify(_aggregateJson);
+//   return mongoQueryJson;
+// }
+
+// /**
+// **
+// ** parseMongoTokens is the function that is used in conjunction with getMongoTokens
+// ** It generates the actual mongo query string from generated tokens
+// **
+// ** example
+// ** { query: "", aggregate:"", limit:"" }
+// **
+// * */
+// function parseMongoTokens(mongoTokens, filters, assetIds, companyId) {
+//   if (!mongoTokens) {
+//     throw new Error('Empty mongo tokens...');
+//   }
+//   const mongoQueryJson = {};
+//   const {
+//     mGroups, mFields, mLimit, mMatch, mOrders, mEvery, ignoreEvery, mJoin,
+//   } = mongoTokens;
+//   let _matchJson = {};
+//   const _groupJson = {};
+//   const _sortJson = {};
+//   const _aggregateJson = [];
+//   const roundField = find(mFields, mField => mField.function === 'round');
+//   const aggrField = find(mFields, mField => (
+//     mField.function === 'sum' ||
+//     mField.function === 'avg' ||
+//     mField.function === 'count'
+//   ));
+
+//   // if there is a [Every] syntax, different parsing flow.
+//   if (mEvery && !ignoreEvery) {
+//     return parseEverySyntaxTokens(mongoTokens, filters, assetIds, companyId);
+//   }
+
+//   // if there is a field with round function, different workflow
+//   if (roundField) {
+//     return parseRoundTokens(mongoTokens, filters, assetIds, companyId);
+//   }
+
+//   if (companyId) {
+//     _aggregateJson.push({ $match: { company_id: companyId } });
+//   }
+
+//   // restrict to specific asset id
+//   if (assetIds) {
+//     if (assetIds.length === 1) {
+//       _aggregateJson.push({ $match: { asset_id: parseInt(assetIds[0], 10) } });
+//     } else if (assetIds.length > 1) {
+//       const assetMatchJson = [];
+//       for (let i = 0; i < assetIds.length; i += 1) {
+//         assetMatchJson.push({ asset_id: parseInt(assetIds[i], 10) });
+//       }
+//       _aggregateJson.push({ $match: { $or: assetMatchJson } });
+//     }
+//   }
+
+//   if (mMatch) { // try to put $match at the first thing in the aggregation pipeline
+//     _matchJson = JSON.parse(mMatch);
+//     _aggregateJson.push({ $match: _matchJson });
+//   }
+
+//   // do not join with assets collection when querying on assets collection regarding asset_id
+//   if (mJoin.collection === 'assets' && mJoin.key === 'asset_id') {
+//     _aggregateJson.push({
+//       $lookup: {
+//         from: 'corva#assets',
+//         localField: 'asset_id',
+//         foreignField: 'asset_id',
+//         as: 'asset',
+//       },
+//     });
+
+//     _aggregateJson.push({ $unwind: '$asset' });
+//   }
+
+//   if (mGroups || aggrField) {
+//     if (mGroups) {
+//       mGroups.map((mGroup) => {
+//         _groupJson._id = _groupJson._id || {};
+//         const _shadowFieldName = mGroup.name.replace(/\./g, '___'); // convert "." to "___"
+//         _groupJson._id[_shadowFieldName] = `$${mGroup.name}`;
+//         return null;
+//       });
+//     } else {
+//       // There is an aggregation field, but no group by clause.
+//       _groupJson._id = 'null';
+//     }
+
+//     for (let i = 0; i < mFields.length; i += 1) {
+//       const mField = mFields[i];
+//       if (mField.function && !mField.operation) { // silence skip for non aggregation fields????
+//         const _shadowFieldName = mField.name.replace(/\./g, '___'); // convert "." to "___"
+//         if (_groupJson[_shadowFieldName]) { // in case sum(duration), avg(duration), count(duration)
+//           const _shadowFieldNameNew = `__${i}__${_shadowFieldName}`;
+//           _groupJson[_shadowFieldNameNew] = {};
+//           if (mField.function.toLowerCase() !== 'count') {
+//             _groupJson[_shadowFieldNameNew][`$${mField.function}`] = `$${mField.name}`;
+//           } else {
+//             // for count aggregation
+//             _groupJson[_shadowFieldNameNew].$sum = 1;
+//           }
+//           mFields[i].name = `__${i}__${mField.name}`;
+//         } else {
+//           _groupJson[_shadowFieldName] = {};
+//           if (mField.function.toLowerCase() !== 'count') {
+//             _groupJson[_shadowFieldName][`$${mField.function}`] = `$${mField.name}`;
+//           } else {
+//             // for count aggregation
+//             _groupJson[_shadowFieldName].$sum = 1;
+//           }
+//         }
+//       }
+//     }
+//     _aggregateJson.push({ $group: _groupJson });
+
+//     if (aggrField && !mGroups) { // if this is an aggregation without group by
+//       mongoTokens.mGroups = [{ // redefine dummy mGroups for the latter pipeline.
+//         name: 'dumb',
+//         alias: 'dumb',
+//       }];
+//     }
+//   } else { // only join map collection when there is no aggregation
+//     /* _aggregateJson.push(
+//       { "$lookup": {
+//       from: "corva#data.map",
+//       localField: "asset_id",
+//       foreignField: "asset_id",
+//       as: "map"
+//     }},
+//     { "$unwind": '$map'}); */
+//   }
+
+//   if (mOrders) {
+//     for (let i = 0; i < mOrders.length; i += 1) {
+//       const _mOrder = mOrders[i];
+//       _sortJson[_mOrder.field] = _mOrder.direction;
+//     }
+//     _aggregateJson.push({ $sort: _sortJson });
+//   }
+
+//   if (ignoreEvery) { // we are trying to get a sample doc to get the schema
+//     _aggregateJson.push({ $limit: 1 });
+//   } else if (mLimit) {
+//     _aggregateJson.push({ $limit: mLimit });
+//   } else if (!mongoTokens.mGroups) {
+//     _aggregateJson.push({ $limit: 500 });
+//   }
+
+//   mongoQueryJson.aggregate = JSON.stringify(_aggregateJson);
+
+//   return mongoQueryJson;
+// }
+
+// /**
+// ** parseFields function is used when query field is *
+// ** It parse the pattern doc received and generate the mFields list
+// **
+// * */
+// function parseFields(patternDoc) {
+//   return _analyzeObject(patternDoc);
+// }
+
+// function _hashCode(str) { // java String#hashCode
+//   let hash = 0;
+//   for (let i = 0; i < str.length; i += 1) {
+//     hash = str.charCodeAt(i) + ((hash << 5) - hash); // eslint-disable-line no-bitwise
+//   }
+//   return hash;
+// }
+
+// function _intToRGB(i) {
+//   const c = (i & 0x00FFFFFF) // eslint-disable-line no-bitwise
+//     .toString(16)
+//     .toUpperCase();
+
+//   return `#${'00000'.substring(0, 6 - c.length) + c}`;
+// }
+
+// /**
+// **
+// ** _extractEssentialFields helper returns the "fundamental" fields
+// ** by removing "redundant" fields in case no fields were specified - "select * "
+// ** or by adding "prerequisite" fields like "map.data.top_hole"
+// **
+// * */
+// function _extractEssentialFields(schema, fields, isAsterik) {
+//   const essentialFields = [];
+//   const redundants = ['version', '_id', 'provider', 'collection'];
+//   const mapField = schema.find(f => f.name === 'map.data.top_hole');
+//   const assetRigNameField = schema.find(f => f.name === 'asset.rig.name');
+//   // remove redundant fields only when "select *";
+//   for (let i = 0; i < fields.length; i += 1) {
+//     const f = fields[i];
+//     let _bool = true;
+//     if (isAsterik) {
+//       if ((redundants.indexOf(f.name) > -1) ||
+//            (f.name.indexOf('asset.') > -1 && assetRigNameField && f.name !== assetRigNameField.name) ||
+//            (f.name.indexOf('map.') > -1 && mapField && f.name !== mapField.name)
+//       ) {
+//         _bool = false;
+//       }
+//     }
+//     if (_bool) {
+//       essentialFields.push(f);
+//     }
+//   }
+
+//   // add prerequisite field(map.data.top_hole)
+//   if (mapField && essentialFields.findIndex(f => f.name === mapField.name) === -1) {
+//     essentialFields.push(mapField);
+//   }
+//   return essentialFields;
+// }
+
+// /**
+// ** getFieldsWithVisualInfo function try to add more information
+// ** necessary for next step in the pipeline - visualization (pie, bar chart)
+// ** It tries to add dataType(number, string) and
+// ** random color of the field (used for serie color in pie, bar chart)
+// ** Other important steps:
+// ** add uuid to mField
+// ** override data type of field (with the name and timestamp) as string
+// ** TODO:
+// ** better way to detect timestamp field. Now it relies on name
+// **
+// * */
+// function getFieldsWithVisualInfo(schema, mFields, mGroups) {
+//   const fields = (mFields.length < 1)
+//     ? schema // select *, no specified fields
+//     : mFields.filter(f => f.isRoot); // get only root fields if fields were specified
+//   let essentialFields = fields;
+//   if (!(mGroups && mGroups.length > 0)) { // only in case no aggregational query
+//     essentialFields = _extractEssentialFields(schema, fields, (mFields.length < 1));
+//   }
+//   let defaultSerieSet = false;
+//   const newFields = essentialFields.map((field) => {
+//     const newField = Object.assign({}, field);
+//     if (!newField.dataType) {
+//       if (newField.operation) {
+//         newField.dataType = 'number';
+//       } else if (newField.function && newField.function !== 'round') {
+//         // don't take round field itself as number field
+//         newField.dataType = 'number';
+//       } else {
+//         const schemaField = schema.find(f => f.alias === newField.alias);
+//         newField.dataType = schemaField ? schemaField.dataType : 'unknown';
+//       }
+//     }
+//     if (newField.name && newField.name.match(/(timestamp|date)/ig)) { // if it's timestamp or date related format
+//       newField.dataType = 'timestamp';
+//     }
+//     if (newField.dataType === 'number' && (!defaultSerieSet || newField.function || newField.operation)) {
+//       // select only one of the fields as default series
+//       newField.isSerie = true;
+//       defaultSerieSet = true;
+//     }
+//     newField.color = _intToRGB(_hashCode(newField.alias));
+//     newField.id = uuidV1();
+//     return newField;
+//   });
+//   return newFields;
+// }
+
+// /**
+// ** normalizeDocuments normalize the documents from api
+// **
+// ** Aggregation result and normal query result are very different
+// ** This function process the documents in following steps
+// **
+// ** 1. Transform the document the way all nestings are removed
+// ** 2. Change the key of the document with alias of the field
+// ** In case of aggregation result, it takes one more pre-step to process "_id"
+// ** 3.(might deprecate) - try to detect timestamp and parse it to date string
+// **
+// * */
+// function normalizeDocuments(mongoTokens, documents) {
+//   const { mFields, mGroups, mEvery } = mongoTokens;
+//   let _isAggregated = false;
+//   if (mGroups && mGroups.length > 0) {
+//     _isAggregated = true;
+//   }
+//   if (mEvery) {
+//     // documents fetched by [Every] syntax has data___xxx attributes because it was aggregated
+//     // when normalizing documents it should be handled like aggregation result.
+//     _isAggregated = true;
+//   }
+
+//   let normalizedDocs = [];
+//   const docs = documents;
+//   // if documents are aggregation result, then
+//   // example aggregation result { data_length:21, _id:"{"asset_id"=>7, "version"=>1}" }
+//   if (_isAggregated) {
+//     const preNormzliedDocs = [];
+//     docs.map((doc) => { // doc[_id] is something like "{"asset_id"=>7, "version"=>1}"
+//       const newDoc = {};
+
+//       // process _id from aggregation result
+//       // e.g "{"data___name"=>"18.5\" Surface Section"}"
+//       // consideration for \"
+//       if (!mEvery) { // _id for [mEvery syntax] is normal timestamp like 1500002340
+//         const _idKeys = doc.get('_id')
+//           .replace(/\\"/g, '&quot;')
+//           .replace(/\{|\}|"/g, '')
+//           .replace(/&quot;/g, '"')
+//           .split(',');
+//         for (let i = 0; i < _idKeys.length; i += 1) {
+//           const _idKey = _idKeys[i].trim();
+//           const _keyValues = _idKey.split('=>');
+//           const _newDocKey = _keyValues[0].replace(/___/g, '.');
+//           const _newDocVal = _keyValues[1];
+//           newDoc[_newDocKey] = _newDocVal; // {asset_id: 7, version: 1}
+//         }
+//       }
+
+//       // process other keys from aggreation result
+//       doc.keySeq().forEach((key) => {
+//         if (key !== '_id') {
+//           const originalKey = key.replace(/___/g, '.'); // convert "___" back to "."
+//           const val = doc.get(key);
+//           newDoc[originalKey] = val;
+//         }
+//       });
+//       preNormzliedDocs.push(newDoc);
+//       return null;
+//     });
+
+//     normalizedDocs = preNormzliedDocs.map((doc) => {
+//       const newDoc = {};
+//       mFields.map((field) => {
+//         const newKey = field.alias || field.name.replace(/^__.*__/g, ''); // TODO: field.name.replace(/^__.*__/g,"")
+//         let val;
+//         if (field.operation) {
+//           let expr = field.expression;
+//           for (let j = 0; j < field.flatten.length; j += 1) {
+//             const { name, alias } = field.flatten[j];
+//             const needle = `-st-${alias}-ed-`;
+//             expr = expr.replace(new RegExp(needle, 'ig'), doc[name]);
+//           }
+//           val = eval(expr); // eslint-disable-line no-eval
+//           newDoc[newKey] = val;
+//         } else {
+//           val = doc[field.name];
+//           if (field.dataType === 'timestamp') { // convert unix timestamp to date string
+//             val = moment.unix(val).format('MM/DD/YY');
+//           } else if (field.dataType === 'boolean') { // convert boolean to string
+//             val = val.toString();
+//           }
+//           newDoc[newKey] = val;
+//         }
+//         return null;
+//       });
+//       return newDoc;
+//     });
+//   } else {
+//     docs.map((doc) => {
+//       const newDoc = {};
+//       mFields.map((field) => {
+//         const newKey = field.alias || field.name;
+//         let val;
+//         if (field.operation) {
+//           let expr = field.expression;
+//           for (let j = 0; j < field.flatten.length; j += 1) {
+//             const { name, alias } = field.flatten[j];
+//             const needle = `-st-${alias}-ed-`;
+//             expr = expr.replace(new RegExp(needle, 'ig'), doc.getIn(name.split('.')));
+//           }
+//           val = eval(expr); // eslint-disable-line no-eval
+//           newDoc[newKey] = val;
+//         } else {
+//           const fieldPath = field.name.split('.');
+//           val = doc.getIn(fieldPath);
+//           if (field.dataType === 'timestamp') { // convert unix timestamp to date string
+//             val = moment.unix(val).format('MM/DD/YY');
+//           } else if (field.dataType === 'boolean') { // convert boolean to string
+//             val = val.toString();
+//           }
+//           newDoc[newKey] = val;
+//         }
+//         return null;
+//       });
+//       normalizedDocs.push(newDoc);
+//       return null;
+//     });
+//   }
+
+//   return normalizedDocs;
+// }
+
+// /**
+// **
+// ** getFilterUsage parses the where section of raw query and get all the possible filter names.
+// **
+// ** {input} rawQuery
+// ** {output} array of filter names
+// **
+// * */
+// function _extractFilterName(obj, usedFilters) {
+//   const interpolation = obj.right.quoteType && _shouldInterpolate(obj.right.value);
+//   if (obj.operation === '=' && obj.right.quoteType && interpolation === 'filter') { // used filter
+//     const rightValue = obj.right.value.replace(/\[|\]/g, '');
+//     const tokens = rightValue.split('=');
+//     const filterName = tokens[0];
+//     usedFilters.push(filterName);
+//   }
+// }
+
+// function _getFiltersInWhere(obj, usedFilters) {
+//   if (!obj) { return; }
+//   if (obj.operation.toLowerCase() === 'and' || obj.operation.toLowerCase() === 'or') {
+//     // always follow left branch first
+//     if (obj.left) {
+//       _getFiltersInWhere(obj.left, usedFilters);
+//     }
+//     // then the right branch if it exists
+//     if (obj.right) {
+//       _getFiltersInWhere(obj.right, usedFilters);
+//     }
+//   } else {
+//     // do stuff for leaf nodes
+//     _extractFilterName(obj, usedFilters);
+//   }
+// }
+
+// function getFilterUsage(rawQuery) {
+//   // Parse [Every X] syntax and strip that syntax from raw sql string.
+//   const everyKeyword = _getEveryClause(rawQuery);
+//   let rawString = rawQuery;
+//   if (everyKeyword) {
+//     rawString = rawQuery.replace(everyKeyword, '');
+//   }
+
+//   const { safeQuery } = _preProcessQueryString(rawString);
+//   rawString = safeQuery;
+
+//   let tokens;
+//   let parsed;
+//   const usedFilters = [];
+//   try {
+//     tokens = lexer.tokenize(rawString);
+//     parsed = parser.parse(tokens);
+//   } catch (e) {
+//     throw new Error('sql parsing error');
+//   }
+
+//   const _where = parsed.where;
+
+//   if (_where && _where.conditions) {
+//     _getFiltersInWhere(_where.conditions, usedFilters);
+//   }
+
+//   return usedFilters;
+// }
+
+// export {
+//   getMongoTokens,
+//   parseMongoTokens,
+//   normalizeDocuments,
+//   parseFields,
+//   getFieldsWithVisualInfo,
+//   getFilterUsage,
+// };