elastic_dsl.js

/* 
 * IFQL to ES DSL
 * QXIP BV 2018 
*/

const nearley = require('nearley');
const grammar = require('./ifql-parse');
const timestring = require('timestring');

let count=0;
function walk(obj, fn) {
  if(!obj) return;
  const result = fn(obj);
  if(result == false) return;
  if(typeof obj == 'object') {
    for(i in obj) {
      walk(obj[i], fn);
    }
  }
}

// ES
var dsl = {
      "query": {}
    };
var bool = {
          "must": [],
          "must_not": [],
          "filter": [],
        }
var range = {};



function index(obj,is,value) {
    if (typeof is == 'string')
        return index(obj,is.split('.'), value);
    else if (is.length==1 && value!==undefined)
        return obj[is[0]] = value;
    else if (is.length==0)
        return obj;
    else
        return index(obj[is[0]],is.slice(1), value);
}

function leftRight(operator,data){
        if(data.left.value == 'time') return;
        if(operator == "AND" && data.left.right){
                leftRight(data.left.operator,data.left);
                leftRight(data.right.operator,data.right);
                return;
        }
        switch( operator ){
          case "=":
                bool.must.push( { match: { [data.left.value]: data.right.value }} );
                break;
          case "NOT":
                bool.must_not.push( { match: { [data.left.value]: data.right.value }} );
                break;
          case ">":
                range[data.left.value] = {};
                range[data.left.value].gte = data.right.value;
                break;
          case "<":
                range[data.left.value] = {};
                range[data.left.value].lte = data.right.value;
                break;
          case "BETWEEN":
                range[data.left.value] = {};
                range[data.left.value].gte = data.right.value[0];
                range[data.left.value].lte = data.right.value[1];
                break;
        }
  }

function parserDefinition(options) {
options = options || {};
options.stringEscape=options.stringEscape || (x=>'"'+x+'"');
options.identifierEscape=options.identifierEscape || (x=>'`'+x+'`');
return {
  toSql(parsed) {
    if(!parsed) return '';
    if(!parsed.type) return '';
    const spacing=options.spacing || '';

    options = options || {};
    switch(parsed.type) {
    case 'create_view': {
      const table=this.toSql(parsed.table, options);
      const definition=this.toSql(parsed.definition, options);
      let sql='create ';
      if(parsed.replace) sql+='or replace ';
      sql+=('view ' + table + ' as '+definition);
      return sql;
    }
    case 'select': {
      let sql='(select ';
      if(parsed.top) sql+='top '+parsed.top+' ';
      if(parsed.all_distinct) sql+=this.toSql(parsed.all)+' ';
      let selection;
      if(parsed.selection.columns) selection=parsed.selection.columns.map(x=>this.toSql(x)).join(', ');
      else selection=this.toSql(parsed.selection);
      sql+=selection;
      if(parsed.table_exp) sql+=' '+this.toSql(parsed.table_exp);
      return sql+')';
    }
    case 'union': {
      const left=this.toSql(parsed.left);
      const right=this.toSql(parsed.right);
      return '(('+left+') union ('+right+'))';
    }
    case 'from': {
      let sql='from (';
      if(parsed.table_refs) sql+=parsed.table_refs.map(x=>this.toSql(x)).join(', ');
      else if(parsed.subquery) sql+=this.toSql(parsed.subquery);
      return sql+')';
    }
    case 'from_table': {
      let sql=this.toSql(parsed.from);
      if(parsed.where) sql+=' '+this.toSql(parsed.where);
      if(parsed.groupby) sql+=' '+this.toSql(parsed.groupby);
      if(parsed.having) sql+=' '+this.toSql(parsed.having);
      if(parsed.order) sql+=' '+this.toSql(parsed.order);
      return sql;
    }
    case 'all': return 'all';
    case 'distinct': return 'distinct';
    case 'group_by': {
      return 'group by ('+this.toSql(parsed.columns)+')';
    }
    case 'select_all': return '*';
    case 'column': {
      let sql='';
      if(parsed.expression) {
        sql+=this.toSql(parsed.expression);
      }
      else if(parsed.name) {
        if(parsed.table) sql+=options.identifierEscape(parsed.table)+'.';
        sql+=options.identifierEscape(parsed.name);
      }
      if(parsed.alias) sql+=' as '+this.toSql(parsed.alias);
      return sql;
    }
    case 'expr_comma_list': {
      return parsed.exprs.map(x=>this.toSql(x)).join(', ');
    }
    case 'table_ref': {
      let sql='('+this.toSql(parsed.left);
      if(parsed.side) sql+=' '+parsed.side+' ';
      sql+='join '+this.toSql(parsed.right);
      if(parsed.on) sql+=' on '+this.toSql(parsed.on);
      return sql+')';
    }
    case 'table': {
      let sql=options.identifierEscape(parsed.table);
      if(parsed.alias)sql+='as '+options.identifierEscape(parsed.alias);
      return sql;
    }
    case 'where': {
      let sql='where (';
      const condition=this.toSql(parsed.condition);
      sql+=condition+')';
      return sql;
    }
    case 'having': {
      let sql='having (';
      const condition=this.toSql(parsed.condition);
      sql+=condition+')';
      return sql;
    }
    case 'selection_columns': {
      return parsed.columns.map(x=>this.toSql(x)).join(', ');
    }
    case 'order': {
      let sql='order by (';
      sql+=parsed.order.map(x => this.toSql(x)).join(', ')+')';
      return sql;
    }
    case 'order_statement': {
      const value=this.toSql(parsed.value);
      sql=value;
      if(parsed.direction) sql+=' '+parsed.direction;
      return sql;
    }
    case 'operator': {
      let sql='(';
      if(parsed.operator=='not') {
        const operand=this.toSql(parsed.operand);
        sql+='not '+operand;
      } else {
        const left=this.toSql(parsed.left);
        const right=this.toSql(parsed.right);
        sql+=left+' '+parsed.operator+' '+right;
      }
      return sql+')';
    }
    case 'is_null': {
      const value=this.toSql(parsed.value);
      let sql='('+value+' is ';
      if(parsed.not) sql+='not ';
      sql+='null)';
      return sql;
    }
    case 'in': {
      const value=this.toSql(parsed.value);
      let sql='('+value+' ';
      if(parsed.not) sql+='not';
      sql+='in ';
      if(parsed.subquery) sql+='('+this.toSql(parsed.subquery)+')';
      else if(parsed.expressions) sql+='('+parsed.expressions.map(x=>this.toSql(x)).join(', ')+')';
      return sql+')';
    }
    case 'between': {
      const value=this.toSql(parsed.value);
      const lower=this.toSql(parsed.lower);
      const upper=this.toSql(parsed.upper);
      let sql='('+value+' ';
      if(parsed.not) sql+='not ';
      sql+='between '+lower+' and '+upper+')';
      return sql;
    }
    case 'like': {
      const value=this.toSql(parsed.value);
      const comparison=this.toSql(parsed.comparison);
      let sql='('+value+' ';
      if(parsed.not) sql+='not ';
      sql+='like '+comparison+')';
      return sql;
    }
    case 'exists': {
      const query=this.toSql(parsed.query);
      return '(exists '+query+')';
    }
    case 'null': return 'null';
    case 'true': return 'true';
    case 'false': return 'false';
    case 'if': {
      const condition=this.toSql(parsed.condition);
      const then=this.toSql(parsed.then);
      const elseExpr=this.toSql(parsed['else']);
      return 'if('+condition+', '+then+', '+elseExpr+')';
    }
    case 'case': {
      let sql='(case ';
      if(parsed.match) sql+= this.toSql(parsed.match)+' ';
      sql+=parsed.when_statements.map(when => this.toSql(when)).join(' ');
      if(parsed['else']) {
        sql+=' else '+this.toSql(parsed['else']);
      }
      sql+=' end)';
      return sql;
    }
    case 'when': {
      const condition=this.toSql(parsed.condition);
      const then=this.toSql(parsed.then);
      return 'when '+condition+' then '+then;
    }
    case 'convert': {
      const value=this.toSql(parsed.value);
      const using=this.toSql(parsed.using);
      return 'conver('+value+' using '+using+")";
    }
    case 'interval': {
      const value=this.toSql(parsed.value);
      const unit=this.toSql(parsed.unit);
      return 'interval '+value+ ' '+unit;
    }
    case 'cast': {
      const value=this.toSql(parsed.value);
      const type=this.toSql(parsed.data_type);
      return 'cast('+value+' as '+type+')';
    }
    case 'data_type': {
      let sql=parsed.data_type;
      if(parsed.size) sql+='('+parsed.size+')';
      else if(parsed.size1) sql+='('+parsed.size1+', '+parsed.size2+')';
      return sql;
    }
    case 'date_unit': {
      return parsed.date_unit;
    }
    case 'function_call': {
      let sql=parsed.name.value + '(';
      if(parsed.select_all) return sql+'*)';
      if(!parsed.parameters.length) return sql+')';
      if(parsed.distinct) sql += 'distinct ';
      if(parsed.all) sql += 'all ';
      sql += parsed.parameters.map(p => this.toSql(p)).join(', ');
      return sql+')';
    }
    case 'string': {
      return options.stringEscape(parsed.string);
    }
    case 'identifier': {
      return options.identifierEscape(parsed.value);
    }
    case 'decimal':{
      return parsed.value;
    }}
    return '-- Invalid sql.type: ' + parsed.type + '\n';
  },
  parse(sql) {
    const parser = new nearley.Parser(grammar.ParserRules, grammar.ParserStart);
    // Sanitize IFQL
    var sql = sql.replace(/"/g,'');
    var sql = sql.replace(/:/g,'');
    const parsed = parser.feed(sql);

    const parsedResult = parsed.results;
    if(!parsedResult.length) throw 'Invalid sql: ' + sql;
    if(parsedResult.length > 1) {
      // console.error(JSON.stringify(parsedResult, null, 2));
      //throw 'SQL ambiguous: Report to developers ' + sql;
    }

    const result = parsedResult[0];

    const referencedTables = {};
    const joins = [];

    walk(result, node => {
      if(node.type == 'operator') {

           leftRight(node.operator,node);

           if(node.left && node.right){
                // Resolve Time function
                if(node.left.value == "time"){
                   if(!range['@timestamp']) range['@timestamp'] = {};

                   if(node.right.left && node.right.right) {
                           if(node.right.left.name && node.right.left.name.value == "now"){
                                range['@timestamp'].lte =  new Date().getTime();
                           }
                           if(node.right.right.range && node.right.operator){
                                var timeeq = node.right.right.value + node.right.right.range.data_type;
                                if (node.right.operator == '-') range['@timestamp'].gte = new Date().getTime() - timestring(timeeq)
                                else if (node.right.operator == '+') range['@timestamp'].gte = new Date().getTime() + timestring(timeeq)
                                range['@timestamp'].lte = new Date().getTime();
                           }
                   }
                   else if(node.right.name && node.right.name.value == "now"){
                        range['@timestamp'].lte = new Date().getTime();
                   }
                }
           }
      }
      if(node.type == 'table') {
                var select = node.table ? node.table.split('.') : [];
                if(select && select.length > 2){
                        node.db = select[0];
                        node.ret = select[1];
                        node.table = select[2];
                } else if(select.length > 1){
                        node.db = select[0];
                        node.table = select[1];
                }
                referencedTables[node.table] = node;
      }
      if(node.type == 'table_ref' && node.on) {
        const columns = [];
        walk(node.on, n => {
          if(n.type == 'table_ref') return false;
          if(n.type == 'column') {
            columns.push(n);
            return false;
          }
        });
        joins.push({
          right: node.right,
          columns: columns
        });
      }
    });

    const operation = result.type;

    let createdTables, sourceTables;
    if(operation=='create_view') {
      createdTables=[result.table.table];
      sourceTables=Object.keys(referencedTables).filter(x => x != result.table.table);
    } else {
      sourceTables=Object.keys(referencedTables);
    }

    const returnColumns=[];
    if(operation=='select') {
      if(result.selection && result.selection.columns) {
        result.selection.columns.forEach(column => {
          const sourceColumns=[];
          walk(column.expression, n => {
            if(n.type=='column') {
              sourceColumns.push(n);
              return false;
            }
            if(n.type=='identifier') {
              sourceColumns.push(n);
              return false;
            }
          });
          let name;
          if(column.alias) name=column.alias.value;
          else name=column.expression;
          returnColumns.push({
            name: name,
            sourceColumns: sourceColumns
          });
        });
      }
    }


    if (Array.isArray(returnColumns)){
        var aggs = {};
        var parent = [];
        returnColumns.forEach(function(key,i){
          parent.push(key.name);
          var jid = parent.join('.')
          index(aggs,jid,{ "terms" : { "field" : key.sourceColumns[0].value || key.value } });
          if(i<returnColumns.length-1){
            index(aggs,jid+".aggregations",{});
            parent.push('aggregations');
          }
        })

        dsl.aggregations = aggs;
    }

    bool.filter.push({ range: range });
    dsl.query.bool = bool;

    return dsl;

  }
};};

const basicParser=parserDefinition({});
parserDefinition.parse=function(sql){return basicParser.parse(sql);}
parserDefinition.toSql=function(parsed){return basicParser.toSql(parsed);}

module.exports=parserDefinition;