@corva/ui 0.34.0-rc.3 → 0.34.0

package/utils/sqlParser.js

@@ -1,1283 +1 @@
-// /* 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,
-// };
-//# sourceMappingURL=sqlParser.js.map
+