1044 lines
21 KiB
Plaintext
1044 lines
21 KiB
Plaintext
|
// (C) 2011-2012 Alibaba Group Holding Limited.
|
||
|
|
// This program is free software; you can redistribute it and/or
|
||
|
|
// modify it under the terms of the GNU General Public License
|
||
|
|
// version 2 as published by the Free Software Foundation.
|
||
|
|
|
||
|
|
// Author :windyrobin <windyrobin@Gmail.com>
|
||
|
|
|
||
|
|
{
|
||
|
|
var util = require('util');
|
||
|
|
|
||
|
|
function debug(str){
|
||
|
|
console.log(str);
|
||
|
|
}
|
||
|
|
|
||
|
|
function inspect(obj){
|
||
|
|
console.log(util.inspect(obj, false, 10));
|
||
|
|
}
|
||
|
|
|
||
|
|
function createUnaryExpr(op, e) {
|
||
|
|
return {
|
||
|
|
type : 'unary_expr',
|
||
|
|
operator : op,
|
||
|
|
expr : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function createBinaryExpr(op, left, right) {
|
||
|
|
return {
|
||
|
|
type : 'binary_expr',
|
||
|
|
operator : op,
|
||
|
|
left : left,
|
||
|
|
right : right
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function createList(head, tail) {
|
||
|
|
var result = [head];
|
||
|
|
for (var i = 0; i < tail.length; i++) {
|
||
|
|
result.push(tail[i][3]);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function createExprList(head, tail, room) {
|
||
|
|
var epList = createList(head, tail);
|
||
|
|
var exprList = [];
|
||
|
|
var ep;
|
||
|
|
for (var i = 0; i < epList.length; i++) {
|
||
|
|
ep = epList[i];
|
||
|
|
//the ep has already added to the global params
|
||
|
|
if (ep.type == 'param') {
|
||
|
|
ep.room = room;
|
||
|
|
ep.pos = i;
|
||
|
|
} else {
|
||
|
|
exprList.push(ep);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return exprList;
|
||
|
|
}
|
||
|
|
|
||
|
|
function createBinaryExprChain(head, tail) {
|
||
|
|
var result = head;
|
||
|
|
for (var i = 0; i < tail.length; i++) {
|
||
|
|
result = createBinaryExpr(tail[i][1], result, tail[i][3]);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
var reservedMap = {
|
||
|
|
'SHOW' : true,
|
||
|
|
'DROP' : true,
|
||
|
|
'SELECT' : true,
|
||
|
|
'UPDATE' : true,
|
||
|
|
'CREATE' : true,
|
||
|
|
'DELETE' : true,
|
||
|
|
'INSERT' : true,
|
||
|
|
'REPLACE' : true,
|
||
|
|
'EXPLAIN' : true,
|
||
|
|
'ALL' : true,
|
||
|
|
'DISTINCT': true,
|
||
|
|
'AS' : true,
|
||
|
|
'TABLE' : true,
|
||
|
|
'INTO' : true,
|
||
|
|
'FROM' : true,
|
||
|
|
'SET' : true,
|
||
|
|
'LEFT' : true,
|
||
|
|
'ON' : true,
|
||
|
|
'INNER' : true,
|
||
|
|
'JOIN' : true,
|
||
|
|
'UNION' : true,
|
||
|
|
'VALUES' : true,
|
||
|
|
'EXISTS' : true,
|
||
|
|
'WHERE' : true,
|
||
|
|
'GROUP' : true,
|
||
|
|
'BY' : true,
|
||
|
|
'HAVING' : true,
|
||
|
|
'ORDER' : true,
|
||
|
|
'ASC' : true,
|
||
|
|
'DESC' : true,
|
||
|
|
'LIMIT' : true,
|
||
|
|
'BETWEEN' : true,
|
||
|
|
'IN' : true,
|
||
|
|
'IS' : true,
|
||
|
|
'LIKE' : true,
|
||
|
|
'CONTAINS': true,
|
||
|
|
'NOT' : true,
|
||
|
|
'AND' : true,
|
||
|
|
'OR' : true,
|
||
|
|
|
||
|
|
//literal
|
||
|
|
'TRUE' : true,
|
||
|
|
'FALSE' : true,
|
||
|
|
'NULL' : true
|
||
|
|
}
|
||
|
|
|
||
|
|
var cmpPrefixMap = {
|
||
|
|
'+' : true,
|
||
|
|
'-' : true,
|
||
|
|
'*' : true,
|
||
|
|
'/' : true,
|
||
|
|
'>' : true,
|
||
|
|
'<' : true,
|
||
|
|
'!' : true,
|
||
|
|
'=' : true,
|
||
|
|
|
||
|
|
//between
|
||
|
|
'B' : true,
|
||
|
|
'b' : true,
|
||
|
|
//for is or in
|
||
|
|
'I' : true,
|
||
|
|
'i' : true,
|
||
|
|
//for like
|
||
|
|
'L' : true,
|
||
|
|
'l' : true,
|
||
|
|
//for not
|
||
|
|
'N' : true,
|
||
|
|
'n' : true,
|
||
|
|
//for contains
|
||
|
|
'C' : true,
|
||
|
|
'c' : true,
|
||
|
|
}
|
||
|
|
|
||
|
|
//used for store refered parmas
|
||
|
|
var params = [];
|
||
|
|
|
||
|
|
//used for dependency analysis
|
||
|
|
var varList = [];
|
||
|
|
}
|
||
|
|
|
||
|
|
start
|
||
|
|
= &init __ ast:(union_stmt / update_stmt / replace_insert_stmt) {
|
||
|
|
return {
|
||
|
|
ast : ast,
|
||
|
|
param : params
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/ast:proc_stmts {
|
||
|
|
return {
|
||
|
|
ast : ast
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
init = { params = []; return true; }
|
||
|
|
|
||
|
|
union_stmt
|
||
|
|
= head:select_stmt tail:(__ KW_UNION __ select_stmt)* {
|
||
|
|
var cur = head;
|
||
|
|
for (var i = 0; i < tail.length; i++) {
|
||
|
|
cur._next = tail[i][3];
|
||
|
|
cur = cur._next
|
||
|
|
}
|
||
|
|
return head;
|
||
|
|
}
|
||
|
|
|
||
|
|
select_stmt
|
||
|
|
= select_stmt_nake
|
||
|
|
/ s:('(' __ select_stmt __ ')') {
|
||
|
|
return s[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
select_stmt_nake
|
||
|
|
= KW_SELECT __
|
||
|
|
d:KW_DISTINCT? __
|
||
|
|
c:column_clause __
|
||
|
|
f:from_clause? __
|
||
|
|
w:where_clause? __
|
||
|
|
g:group_by_clause? __
|
||
|
|
o:order_by_clause? __
|
||
|
|
l:limit_clause? {
|
||
|
|
return {
|
||
|
|
type : 'select',
|
||
|
|
distinct : d,
|
||
|
|
columns : c,
|
||
|
|
from : f,
|
||
|
|
where : w,
|
||
|
|
groupby : g,
|
||
|
|
orderby : o,
|
||
|
|
limit : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
column_clause
|
||
|
|
= (KW_ALL / (STAR !ident_start)) {
|
||
|
|
return '*';
|
||
|
|
}
|
||
|
|
/ head:column_list_item tail:(__ COMMA __ column_list_item)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* maybe you should use `expr` instead of `primary` or `additive_expr`
|
||
|
|
* to support complicated expression in column clause
|
||
|
|
*/
|
||
|
|
column_list_item
|
||
|
|
= e:additive_expr __ alias:alias_clause? {
|
||
|
|
return {
|
||
|
|
expr : e,
|
||
|
|
as : alias
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
alias_clause
|
||
|
|
= KW_AS? __ i:ident { return i; }
|
||
|
|
|
||
|
|
from_clause
|
||
|
|
= KW_FROM __ l:table_ref_list { return l; }
|
||
|
|
|
||
|
|
table_ref_list
|
||
|
|
= head:table_base
|
||
|
|
tail:table_ref* {
|
||
|
|
tail.unshift(head);
|
||
|
|
return tail;
|
||
|
|
}
|
||
|
|
|
||
|
|
table_ref
|
||
|
|
= __ COMMA __ t:table_base { return t; }
|
||
|
|
/ __ t:table_join { return t; }
|
||
|
|
|
||
|
|
|
||
|
|
table_join
|
||
|
|
= op:join_op __ t:table_base __ expr:on_clause? {
|
||
|
|
t.join = op;
|
||
|
|
t.on = expr;
|
||
|
|
return t;
|
||
|
|
/*
|
||
|
|
return {
|
||
|
|
db : t.db,
|
||
|
|
table : t.table,
|
||
|
|
as : t.as,
|
||
|
|
join : op,
|
||
|
|
on : expr
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
|
||
|
|
//NOTE that ,the table assigned to `var` shouldn't write in `table_join`
|
||
|
|
table_base
|
||
|
|
= t:table_name __ KW_AS? __ alias:ident? {
|
||
|
|
if (t.type == 'var') {
|
||
|
|
t.as = alias;
|
||
|
|
return t;
|
||
|
|
} else {
|
||
|
|
return {
|
||
|
|
db : t.db,
|
||
|
|
table : t.table,
|
||
|
|
as : alias
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
join_op
|
||
|
|
= KW_LEFT __ KW_JOIN { return 'LEFT JOIN'; }
|
||
|
|
/ (KW_INNER __)? KW_JOIN { return 'INNER JOIN'; }
|
||
|
|
|
||
|
|
table_name
|
||
|
|
= dt:ident tail:(__ DOT __ ident_name)? {
|
||
|
|
var obj = {
|
||
|
|
db : '',
|
||
|
|
table : dt
|
||
|
|
}
|
||
|
|
if (tail != '') {
|
||
|
|
obj.db = dt;
|
||
|
|
obj.table = tail[3];
|
||
|
|
}
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
/v:var_decl {
|
||
|
|
v.db = '';
|
||
|
|
v.table = v.name;
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
|
||
|
|
on_clause
|
||
|
|
= KW_ON __ e:expr { return e; }
|
||
|
|
|
||
|
|
where_clause
|
||
|
|
= KW_WHERE __ e:expr { return e; }
|
||
|
|
|
||
|
|
group_by_clause
|
||
|
|
= KW_GROUP __ KW_BY __ l:column_ref_list { return l; }
|
||
|
|
|
||
|
|
column_ref_list
|
||
|
|
= head:column_ref tail:(__ COMMA __ column_ref)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
having_clause
|
||
|
|
= KW_HAVING e:expr { return e; }
|
||
|
|
|
||
|
|
order_by_clause
|
||
|
|
= KW_ORDER __ KW_BY __ l:order_by_list { return l; }
|
||
|
|
|
||
|
|
order_by_list
|
||
|
|
= head:order_by_element tail:(__ COMMA __ order_by_element)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
order_by_element
|
||
|
|
= e:expr __ d:(KW_DESC / KW_ASC)? {
|
||
|
|
var obj = {
|
||
|
|
expr : e,
|
||
|
|
type : 'ASC'
|
||
|
|
}
|
||
|
|
if (d == 'DESC') {
|
||
|
|
obj.type = 'DESC';
|
||
|
|
}
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
|
||
|
|
number_or_param
|
||
|
|
= literal_numeric
|
||
|
|
/ param
|
||
|
|
|
||
|
|
limit_clause
|
||
|
|
= KW_LIMIT __ i1:(number_or_param) __ tail:(COMMA __ number_or_param)? {
|
||
|
|
var res = [i1];
|
||
|
|
if (tail == '') {
|
||
|
|
res.unshift({
|
||
|
|
type : 'number',
|
||
|
|
value : 0
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
res.push(tail[2]);
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
|
||
|
|
update_stmt
|
||
|
|
= KW_UPDATE __
|
||
|
|
t:table_name __
|
||
|
|
KW_SET __
|
||
|
|
l:set_list __
|
||
|
|
w:where_clause {
|
||
|
|
return {
|
||
|
|
type : 'update',
|
||
|
|
db : t.db,
|
||
|
|
table : t.table,
|
||
|
|
set : l,
|
||
|
|
where : w
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
set_list
|
||
|
|
= head:set_item tail:(__ COMMA __ set_item)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* here only use `additive_expr` to support 'col1 = col1+2'
|
||
|
|
* if you want to use lower operator, please use '()' like below
|
||
|
|
* 'col1 = (col2 > 3)'
|
||
|
|
*/
|
||
|
|
set_item
|
||
|
|
= c:column_name __ '=' __ v:additive_expr {
|
||
|
|
return {
|
||
|
|
column: c,
|
||
|
|
value : v
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
replace_insert_stmt
|
||
|
|
= ri:replace_insert __
|
||
|
|
KW_INTO __
|
||
|
|
t:table_name __ LPAREN __
|
||
|
|
c:column_list __ RPAREN __
|
||
|
|
v:value_clause {
|
||
|
|
return {
|
||
|
|
type : ri,
|
||
|
|
db : t.db,
|
||
|
|
table : t.table,
|
||
|
|
columns : c,
|
||
|
|
values : v
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
replace_insert
|
||
|
|
= KW_INSERT { return 'insert'; }
|
||
|
|
/ KW_REPLACE { return 'replace' }
|
||
|
|
|
||
|
|
value_clause
|
||
|
|
= KW_VALUES __ l:value_list { return l; }
|
||
|
|
|
||
|
|
value_list
|
||
|
|
= head:value_item tail:(__ COMMA __ value_item)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
value_item
|
||
|
|
= LPAREN __ l:expr_list __ RPAREN {
|
||
|
|
return l;
|
||
|
|
}
|
||
|
|
|
||
|
|
//for template auto fill
|
||
|
|
expr_list
|
||
|
|
= head:expr tail:(__ COMMA __ expr)*{
|
||
|
|
var el = {
|
||
|
|
type : 'expr_list'
|
||
|
|
}
|
||
|
|
var l = createExprList(head, tail, el);
|
||
|
|
|
||
|
|
el.value = l;
|
||
|
|
return el;
|
||
|
|
}
|
||
|
|
|
||
|
|
expr_list_or_empty
|
||
|
|
= l:expr_list
|
||
|
|
/ {
|
||
|
|
return {
|
||
|
|
type : 'expr_list',
|
||
|
|
value : []
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Borrowed from PL/SQL ,the priority of below list IS ORDER BY DESC
|
||
|
|
* ---------------------------------------------------------------------------------------------------
|
||
|
|
* | +, - | identity, negation |
|
||
|
|
* | *, / | multiplication, division |
|
||
|
|
* | +, - | addition, subtraction, concatenation |
|
||
|
|
* | =, <, >, <=, >=, <>, !=, IS, LIKE, BETWEEN, IN, CONTAINS | comparion |
|
||
|
|
* | !, NOT | logical negation |
|
||
|
|
* | AND | conjunction |
|
||
|
|
* | OR | inclusion |
|
||
|
|
* ---------------------------------------------------------------------------------------------------
|
||
|
|
*/
|
||
|
|
|
||
|
|
expr = or_expr
|
||
|
|
|
||
|
|
or_expr
|
||
|
|
= head:and_expr tail:(__ KW_OR __ and_expr)* {
|
||
|
|
return createBinaryExprChain(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
and_expr
|
||
|
|
= head:not_expr tail:(__ KW_AND __ not_expr)* {
|
||
|
|
return createBinaryExprChain(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
//here we should use `NOT` instead of `comparision_expr` to support chain-expr
|
||
|
|
not_expr
|
||
|
|
= (KW_NOT / "!" !"=") __ expr:not_expr {
|
||
|
|
return createUnaryExpr('NOT', expr);
|
||
|
|
}
|
||
|
|
/ comparison_expr
|
||
|
|
|
||
|
|
comparison_expr
|
||
|
|
= left:additive_expr __ rh:comparison_op_right? {
|
||
|
|
if (rh == '') {
|
||
|
|
return left;
|
||
|
|
} else {
|
||
|
|
var res = null;
|
||
|
|
if (rh.type == 'arithmetic') {
|
||
|
|
res = createBinaryExprChain(left, rh.tail);
|
||
|
|
} else {
|
||
|
|
res = createBinaryExpr(rh.op, left, rh.right);
|
||
|
|
}
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
//optimization for comparison judge, bug because we in use `additive` expr
|
||
|
|
//in column clause now , it have little effect
|
||
|
|
cmp_prefix_char
|
||
|
|
= c:char &{ debug(c); return cmpPrefixMap[c]; }
|
||
|
|
|
||
|
|
comparison_op_right
|
||
|
|
= &cmp_prefix_char body:(
|
||
|
|
arithmetic_op_right
|
||
|
|
/ in_op_right
|
||
|
|
/ between_op_right
|
||
|
|
/ is_op_right
|
||
|
|
/ like_op_right
|
||
|
|
/ contains_op_right
|
||
|
|
){
|
||
|
|
return body;
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
comparison_op_right
|
||
|
|
= arithmetic_op_right
|
||
|
|
/ in_op_right
|
||
|
|
/ between_op_right
|
||
|
|
/ is_op_right
|
||
|
|
/ like_op_right
|
||
|
|
/ contains_op_right
|
||
|
|
|
||
|
|
arithmetic_op_right
|
||
|
|
= l:(__ arithmetic_comparison_operator __ additive_expr)+ {
|
||
|
|
return {
|
||
|
|
type : 'arithmetic',
|
||
|
|
tail : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
arithmetic_comparison_operator
|
||
|
|
= ">=" / ">" / "<=" / "<>" / "<" / "=" / "!="
|
||
|
|
|
||
|
|
is_op_right
|
||
|
|
= op:KW_IS __ right:additive_expr {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : right
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
between_op_right
|
||
|
|
= op:KW_BETWEEN __ begin:additive_expr __ KW_AND __ end:additive_expr {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : {
|
||
|
|
type : 'expr_list',
|
||
|
|
value : [begin, end]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
like_op
|
||
|
|
= nk:(KW_NOT __ KW_LIKE) { return nk[0] + ' ' + nk[2]; }
|
||
|
|
/ KW_LIKE
|
||
|
|
|
||
|
|
in_op
|
||
|
|
= nk:(KW_NOT __ KW_IN) { return nk[0] + ' ' + nk[2]; }
|
||
|
|
/ KW_IN
|
||
|
|
|
||
|
|
contains_op
|
||
|
|
= nk:(KW_NOT __ KW_CONTAINS) { return nk[0] + ' ' + nk[2]; }
|
||
|
|
/ KW_CONTAINS
|
||
|
|
|
||
|
|
like_op_right
|
||
|
|
= op:like_op __ right:comparison_expr {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : right
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
in_op_right
|
||
|
|
= op:in_op __ LPAREN __ l:expr_list __ RPAREN {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/ op:in_op __ e:var_decl {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
contains_op_right
|
||
|
|
= op:contains_op __ LPAREN __ l:expr_list __ RPAREN {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/ op:contains_op __ e:var_decl {
|
||
|
|
return {
|
||
|
|
op : op,
|
||
|
|
right : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
additive_expr
|
||
|
|
= head:multiplicative_expr
|
||
|
|
tail:(__ additive_operator __ multiplicative_expr)* {
|
||
|
|
return createBinaryExprChain(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
additive_operator
|
||
|
|
= "+" / "-"
|
||
|
|
|
||
|
|
multiplicative_expr
|
||
|
|
= head:primary
|
||
|
|
tail:(__ multiplicative_operator __ primary)* {
|
||
|
|
return createBinaryExprChain(head, tail)
|
||
|
|
}
|
||
|
|
|
||
|
|
multiplicative_operator
|
||
|
|
= "*" / "/" / "%"
|
||
|
|
|
||
|
|
primary
|
||
|
|
= literal
|
||
|
|
/ aggr_func
|
||
|
|
/ func_call
|
||
|
|
/ column_ref
|
||
|
|
/ param
|
||
|
|
/ LPAREN __ e:expr __ RPAREN {
|
||
|
|
e.paren = true;
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
/ var_decl
|
||
|
|
|
||
|
|
column_ref
|
||
|
|
= tbl:ident __ DOT __ col:column {
|
||
|
|
return {
|
||
|
|
type : 'column_ref',
|
||
|
|
table : tbl,
|
||
|
|
column : col
|
||
|
|
};
|
||
|
|
}
|
||
|
|
/ col:column {
|
||
|
|
return {
|
||
|
|
type : 'column_ref',
|
||
|
|
table : '',
|
||
|
|
column: col
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
column_list
|
||
|
|
= head:column tail:(__ COMMA __ column)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
ident =
|
||
|
|
name:ident_name !{ return reservedMap[name.toUpperCase()] === true; } {
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
|
||
|
|
column =
|
||
|
|
name:column_name !{ return reservedMap[name.toUpperCase()] === true; } {
|
||
|
|
return name;
|
||
|
|
}
|
||
|
|
/'`' chars:[^`]+ '`' {
|
||
|
|
return chars.join('');
|
||
|
|
}
|
||
|
|
|
||
|
|
column_name
|
||
|
|
= start:ident_start parts:column_part* { return start + parts.join(''); }
|
||
|
|
|
||
|
|
ident_name
|
||
|
|
= start:ident_start parts:ident_part* { return start + parts.join(''); }
|
||
|
|
|
||
|
|
ident_start = [A-Za-z_]
|
||
|
|
|
||
|
|
ident_part = [A-Za-z0-9_]
|
||
|
|
|
||
|
|
//to support column name like `cf1:name` in hbase
|
||
|
|
column_part = [A-Za-z0-9_:]
|
||
|
|
|
||
|
|
|
||
|
|
param
|
||
|
|
= l:(':' ident_name) {
|
||
|
|
var p = {
|
||
|
|
type : 'param',
|
||
|
|
value: l[1]
|
||
|
|
}
|
||
|
|
//var key = 'L' + line + 'C' + column;
|
||
|
|
//debug(key);
|
||
|
|
//params[key] = p;
|
||
|
|
params.push(p);
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
aggr_func
|
||
|
|
= aggr_fun_count
|
||
|
|
/ aggr_fun_smma
|
||
|
|
|
||
|
|
aggr_fun_smma
|
||
|
|
= name:KW_SUM_MAX_MIN_AVG __ LPAREN __ e:additive_expr __ RPAREN {
|
||
|
|
return {
|
||
|
|
type : 'aggr_func',
|
||
|
|
name : name,
|
||
|
|
args : {
|
||
|
|
expr : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
KW_SUM_MAX_MIN_AVG
|
||
|
|
= KW_SUM / KW_MAX / KW_MIN / KW_AVG
|
||
|
|
|
||
|
|
aggr_fun_count
|
||
|
|
= name:KW_COUNT __ LPAREN __ arg:count_arg __ RPAREN {
|
||
|
|
return {
|
||
|
|
type : 'aggr_func',
|
||
|
|
name : name,
|
||
|
|
args : arg
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
count_arg
|
||
|
|
= e:star_expr {
|
||
|
|
return {
|
||
|
|
expr : e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/ d:KW_DISTINCT? __ c:column_ref {
|
||
|
|
return {
|
||
|
|
distinct : d,
|
||
|
|
expr : c
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
star_expr
|
||
|
|
= "*" {
|
||
|
|
return {
|
||
|
|
type : 'star',
|
||
|
|
value : '*'
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func_call
|
||
|
|
= name:ident __ LPAREN __ l:expr_list_or_empty __ RPAREN {
|
||
|
|
return {
|
||
|
|
type : 'function',
|
||
|
|
name : name,
|
||
|
|
args : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
literal
|
||
|
|
= literal_string / literal_numeric / literal_bool /literal_null
|
||
|
|
|
||
|
|
literal_list
|
||
|
|
= head:literal tail:(__ COMMA __ literal)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
literal_null
|
||
|
|
= KW_NULL {
|
||
|
|
return {
|
||
|
|
type : 'null',
|
||
|
|
value : null
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
literal_bool
|
||
|
|
= KW_TRUE {
|
||
|
|
return {
|
||
|
|
type : 'bool',
|
||
|
|
value : true
|
||
|
|
};
|
||
|
|
}
|
||
|
|
/ KW_FALSE {
|
||
|
|
return {
|
||
|
|
type : 'bool',
|
||
|
|
value : false
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
literal_string
|
||
|
|
= ca:( ('"' double_char* '"')
|
||
|
|
/("'" single_char* "'")) {
|
||
|
|
return {
|
||
|
|
type : 'string',
|
||
|
|
value : ca[1].join('')
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
single_char
|
||
|
|
= [^'\\\0-\x1F\x7f]
|
||
|
|
/ escape_char
|
||
|
|
|
||
|
|
double_char
|
||
|
|
= [^"\\\0-\x1F\x7f]
|
||
|
|
/ escape_char
|
||
|
|
|
||
|
|
escape_char
|
||
|
|
= "\\'" { return "'"; }
|
||
|
|
/ '\\"' { return '"'; }
|
||
|
|
/ "\\\\" { return "\\"; }
|
||
|
|
/ "\\/" { return "/"; }
|
||
|
|
/ "\\b" { return "\b"; }
|
||
|
|
/ "\\f" { return "\f"; }
|
||
|
|
/ "\\n" { return "\n"; }
|
||
|
|
/ "\\r" { return "\r"; }
|
||
|
|
/ "\\t" { return "\t"; }
|
||
|
|
/ "\\u" h1:hexDigit h2:hexDigit h3:hexDigit h4:hexDigit {
|
||
|
|
return String.fromCharCode(parseInt("0x" + h1 + h2 + h3 + h4));
|
||
|
|
}
|
||
|
|
|
||
|
|
line_terminator
|
||
|
|
= [\n\r]
|
||
|
|
|
||
|
|
literal_numeric
|
||
|
|
= n:number {
|
||
|
|
return {
|
||
|
|
type : 'number',
|
||
|
|
value : n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
number
|
||
|
|
= int_:int frac:frac exp:exp __ { return parseFloat(int_ + frac + exp); }
|
||
|
|
/ int_:int frac:frac __ { return parseFloat(int_ + frac); }
|
||
|
|
/ int_:int exp:exp __ { return parseFloat(int_ + exp); }
|
||
|
|
/ int_:int __ { return parseFloat(int_); }
|
||
|
|
|
||
|
|
int
|
||
|
|
= digit19:digit19 digits:digits { return digit19 + digits; }
|
||
|
|
/ digit:digit
|
||
|
|
/ op:("-" / "+" ) digit19:digit19 digits:digits { return "-" + digit19 + digits; }
|
||
|
|
/ op:("-" / "+" ) digit:digit { return "-" + digit; }
|
||
|
|
|
||
|
|
frac
|
||
|
|
= "." digits:digits { return "." + digits; }
|
||
|
|
|
||
|
|
exp
|
||
|
|
= e:e digits:digits { return e + digits; }
|
||
|
|
|
||
|
|
digits
|
||
|
|
= digits:digit+ { return digits.join(""); }
|
||
|
|
|
||
|
|
digit = [0-9]
|
||
|
|
digit19 = [1-9]
|
||
|
|
|
||
|
|
hexDigit
|
||
|
|
= [0-9a-fA-F]
|
||
|
|
|
||
|
|
e
|
||
|
|
= e:[eE] sign:[+-]? { return e + sign; }
|
||
|
|
|
||
|
|
|
||
|
|
KW_NULL = "NULL"i !ident_start
|
||
|
|
KW_TRUE = "TRUE"i !ident_start
|
||
|
|
KW_FALSE = "FALSE"i !ident_start
|
||
|
|
|
||
|
|
KW_SHOW = "SHOW"i !ident_start
|
||
|
|
KW_DROP = "DROP"i !ident_start
|
||
|
|
KW_SELECT = "SELECT"i !ident_start
|
||
|
|
KW_UPDATE = "UPDATE"i !ident_start
|
||
|
|
KW_CREATE = "CREATE"i !ident_start
|
||
|
|
KW_DELETE = "DELETE"i !ident_start
|
||
|
|
KW_INSERT = "INSERT"i !ident_start
|
||
|
|
KW_REPLACE = "REPLACE"i !ident_start
|
||
|
|
KW_EXPLAIN = "EXPLAIN"i !ident_start
|
||
|
|
|
||
|
|
KW_INTO = "INTO"i !ident_start
|
||
|
|
KW_FROM = "FROM"i !ident_start
|
||
|
|
KW_SET = "SET"i !ident_start
|
||
|
|
|
||
|
|
KW_AS = "AS"i !ident_start
|
||
|
|
KW_TABLE = "TABLE"i !ident_start
|
||
|
|
|
||
|
|
KW_ON = "ON"i !ident_start
|
||
|
|
KW_LEFT = "LEFT"i !ident_start
|
||
|
|
KW_INNER = "INNER"i !ident_start
|
||
|
|
KW_JOIN = "JOIN"i !ident_start
|
||
|
|
KW_UNION = "UNION"i !ident_start
|
||
|
|
KW_VALUES = "VALUES"i !ident_start
|
||
|
|
|
||
|
|
KW_EXISTS = "EXISTS"i !ident_start
|
||
|
|
|
||
|
|
KW_WHERE = "WHERE"i !ident_start
|
||
|
|
|
||
|
|
KW_GROUP = "GROUP"i !ident_start
|
||
|
|
KW_BY = "BY"i !ident_start
|
||
|
|
KW_ORDER = "ORDER"i !ident_start
|
||
|
|
KW_HAVING = "HAVING"i !ident_start
|
||
|
|
|
||
|
|
KW_LIMIT = "LIMIT"i !ident_start
|
||
|
|
|
||
|
|
KW_ASC = "ASC"i !ident_start { return 'ASC'; }
|
||
|
|
KW_DESC = "DESC"i !ident_start { return 'DESC'; }
|
||
|
|
|
||
|
|
KW_ALL = "ALL"i !ident_start { return 'ALL'; }
|
||
|
|
KW_DISTINCT = "DISTINCT"i !ident_start { return 'DISTINCT';}
|
||
|
|
|
||
|
|
KW_BETWEEN = "BETWEEN"i !ident_start { return 'BETWEEN'; }
|
||
|
|
KW_IN = "IN"i !ident_start { return 'IN'; }
|
||
|
|
KW_IS = "IS"i !ident_start { return 'IS'; }
|
||
|
|
KW_LIKE = "LIKE"i !ident_start { return 'LIKE'; }
|
||
|
|
KW_CONTAINS = "CONTAINS"i !ident_start { return 'CONTAINS';}
|
||
|
|
|
||
|
|
KW_NOT = "NOT"i !ident_start { return 'NOT'; }
|
||
|
|
KW_AND = "AND"i !ident_start { return 'AND'; }
|
||
|
|
KW_OR = "OR"i !ident_start { return 'OR'; }
|
||
|
|
|
||
|
|
KW_COUNT = "COUNT"i !ident_start { return 'COUNT'; }
|
||
|
|
KW_MAX = "MAX"i !ident_start { return 'MAX'; }
|
||
|
|
KW_MIN = "MIN"i !ident_start { return 'MIN'; }
|
||
|
|
KW_SUM = "SUM"i !ident_start { return 'SUM'; }
|
||
|
|
KW_AVG = "AVG"i !ident_start { return 'AVG'; }
|
||
|
|
|
||
|
|
//specail character
|
||
|
|
DOT = '.'
|
||
|
|
COMMA = ','
|
||
|
|
STAR = '*'
|
||
|
|
LPAREN = '('
|
||
|
|
RPAREN = ')'
|
||
|
|
|
||
|
|
LBRAKE = '['
|
||
|
|
RBRAKE = ']'
|
||
|
|
|
||
|
|
__ =
|
||
|
|
whitespace*
|
||
|
|
|
||
|
|
char = .
|
||
|
|
|
||
|
|
whitespace =
|
||
|
|
[ \t\n\r]
|
||
|
|
|
||
|
|
EOL
|
||
|
|
= EOF
|
||
|
|
/ [\n\r]+
|
||
|
|
|
||
|
|
EOF = !.
|
||
|
|
|
||
|
|
//begin procedure extension
|
||
|
|
proc_stmts
|
||
|
|
= proc_stmt*
|
||
|
|
|
||
|
|
proc_stmt
|
||
|
|
= &proc_init __ s:(assign_stmt / return_stmt) {
|
||
|
|
return {
|
||
|
|
stmt : s,
|
||
|
|
vars: varList
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_init = { varList = []; return true; }
|
||
|
|
|
||
|
|
assign_stmt
|
||
|
|
= va:var_decl __ KW_ASSIGN __ e:proc_expr {
|
||
|
|
return {
|
||
|
|
type : 'assign',
|
||
|
|
left : va,
|
||
|
|
right: e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return_stmt
|
||
|
|
= KW_RETURN __ e:proc_expr {
|
||
|
|
return {
|
||
|
|
type : 'return',
|
||
|
|
expr: e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_expr
|
||
|
|
= select_stmt
|
||
|
|
/ proc_join
|
||
|
|
/ proc_additive_expr
|
||
|
|
/ proc_array
|
||
|
|
|
||
|
|
proc_additive_expr
|
||
|
|
= head:proc_multiplicative_expr
|
||
|
|
tail:(__ additive_operator __ proc_multiplicative_expr)* {
|
||
|
|
return createBinaryExprChain(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_multiplicative_expr
|
||
|
|
= head:proc_primary
|
||
|
|
tail:(__ multiplicative_operator __ proc_primary)* {
|
||
|
|
return createBinaryExprChain(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_join
|
||
|
|
= lt:var_decl __ op:join_op __ rt:var_decl __ expr:on_clause {
|
||
|
|
return {
|
||
|
|
type : 'join',
|
||
|
|
ltable : lt,
|
||
|
|
rtable : rt,
|
||
|
|
op : op,
|
||
|
|
on : expr
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_primary
|
||
|
|
= literal
|
||
|
|
/ var_decl
|
||
|
|
/ proc_func_call
|
||
|
|
/ param
|
||
|
|
/ LPAREN __ e:proc_additive_expr __ RPAREN {
|
||
|
|
e.paren = true;
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_func_call
|
||
|
|
= name:ident __ LPAREN __ l:proc_primary_list __ RPAREN {
|
||
|
|
//compatible with original func_call
|
||
|
|
return {
|
||
|
|
type : 'function',
|
||
|
|
name : name,
|
||
|
|
args : {
|
||
|
|
type : 'expr_list',
|
||
|
|
value : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_primary_list
|
||
|
|
= head:proc_primary tail:(__ COMMA __ proc_primary)* {
|
||
|
|
return createList(head, tail);
|
||
|
|
}
|
||
|
|
|
||
|
|
proc_array =
|
||
|
|
LBRAKE __ l:proc_primary_list __ RBRAKE {
|
||
|
|
return {
|
||
|
|
type : 'array',
|
||
|
|
value : l
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
var_decl
|
||
|
|
= KW_VAR_PRE name:ident_name m:mem_chain {
|
||
|
|
//push for analysis
|
||
|
|
varList.push(name);
|
||
|
|
return {
|
||
|
|
type : 'var',
|
||
|
|
name : name,
|
||
|
|
members : m
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
mem_chain
|
||
|
|
= l:('.' ident_name)* {
|
||
|
|
var s = [];
|
||
|
|
for (var i = 0; i < l.length; i++) {
|
||
|
|
s.push(l[i][1]);
|
||
|
|
}
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
|
||
|
|
KW_VAR_PRE = '$'
|
||
|
|
|
||
|
|
KW_RETURN = 'return'i
|
||
|
|
|
||
|
|
KW_ASSIGN = ':='
|