gcl/com/coooders/db/nosql.js

码农村nodejs类库，完成解决回调陷阱，配置框架，IOC框架，统一多DB访问框架，可扩展日志框架和io/db/net/thread/pool 克隆表达式，加解密算法等等一系列基础类库和算法的实现

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.LCOperate = exports.AndOperate = exports.NotOperate = exports.O2Operate = exports.EqualOperate = exports.O1Operate = exports.ALogicOperate = exports.OperationSession = exports.NoSQLParser = exports.LinqParser = exports.QueryEntity = undefined;

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require("babel-runtime/helpers/get");

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require("babel-runtime/helpers/inherits");

var _inherits3 = _interopRequireDefault(_inherits2);

var _typeof2 = require("babel-runtime/helpers/typeof");

var _typeof3 = _interopRequireDefault(_typeof2);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _tool = require("../common/tool");

var _tool2 = _interopRequireDefault(_tool);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var QueryEntity = exports.QueryEntity = function () {
  function QueryEntity(sign) {
    (0, _classCallCheck3.default)(this, QueryEntity);

    var that = this;

    var _pri = pri(this),
        _ = _pri._,
        __ = _pri.__;

    _.IDs = {};
    _.MethodParam = {};
    _.WhereParam = {};
    _.OrderParam = {};
    _.SkipParam = {};
    _.LimitParam = {};
    _.DateTimeParam = {};
    _.Method = null;
    _.Params = {};
    _.Table = "";
    _.sign = sign;
  }

  (0, _createClass3.default)(QueryEntity, [{
    key: "addParams",
    value: function addParams(p, ret) {
      var _pri2 = pri(this),
          _ = _pri2._,
          __ = _pri2.__;

      p = p.trim();
      if (_.Params[p]) {
        var hasData = false;
        _.Params[p].forEach(function (v) {
          if (v == ret) hasData = true;
        });
        if (!hasData) _.Params[p].push(ret);
      } else {
        _.Params[p] = [ret];
      }
    }
  }, {
    key: "clone",
    value: function clone() {
      var _pri3 = pri(this),
          _ = _pri3._,
          __ = _pri3.__;

      var ret = new QueryEntity();
      _tool2.default.merge(ret.IDs, _.IDs, true);
      _tool2.default.merge(ret.MethodParam, _.MethodParam, true);
      _tool2.default.merge(ret.WhereParam, _.WhereParam, true);
      _tool2.default.merge(ret.OrderParam, _.OrderParam, true);
      _tool2.default.merge(ret.SkipParam, _.SkipParam, true);
      _tool2.default.merge(ret.DateTimeParam, _.DateTimeParam, true);
      _tool2.default.merge(ret.LimitParam, _.LimitParam, true);
      for (var k in ret.IDs) {
        var v = ret.IDs[k];
        if (v && v.startsWith && v.startWith(_.sign)) ret.addParams(v.trim(_.sign), ret.IDs);
        if (v && v.startsWith && v.startWith("{")) ret.addParams(v.trim("{").trim("}"), ret.IDs);
      }
      for (var _k in ret.MethodParam) {
        var _v = ret.MethodParam[_k];
        if (_v && _v.startsWith && _v.startWith(_.sign)) ret.addParams(_v.trim(_.sign), ret.MethodParam);
        if (_v && _v.startsWith && _v.startWith("{")) ret.addParams(_v.trim("{").trim("}"), ret.MethodParam);
      }
      for (var _k2 in ret.OrderParam) {
        var _v2 = ret.OrderParam[_k2];
        if (_v2 && _v2.startsWith && _v2.startWith(_.sign)) ret.addParams(_v2.trim(_.sign), ret.OrderParam);
        if (_v2 && _v2.startsWith && _v2.startWith("{")) ret.addParams(_v2.trim("{").trim("}"), ret.OrderParam);
      }
      for (var _k3 in ret.SkipParam) {
        var _v3 = ret.SkipParam[_k3];
        if (_v3 && _v3.startsWith && _v3.startWith(_.sign)) ret.addParams(_v3.trim(_.sign), ret.SkipParam);
        if (_v3 && _v3.startsWith && _v3.startWith("{")) ret.addParams(_v3.trim("{").trim("}"), ret.SkipParam);
      }
      for (var _k4 in ret.DateTimeParam) {
        var _v4 = ret.DateTimeParam[_k4];
        if (_v4 && _v4.startsWith && _v4.startWith(_.sign)) ret.addParams(_v4.trim(_.sign), ret.DateTimeParam);
        if (_v4 && _v4.startsWith && _v4.startWith("{")) ret.addParams(_v4.trim("{").trim("}"), ret.DateTimeParam);
      }
      for (var _k5 in ret.LimitParam) {
        var _v5 = ret.LimitParam[_k5];
        if (_v5 && _v5.startsWith && _v5.startWith(_.sign)) ret.addParams(_v5.trim(_.sign), ret.LimitParam);
        if (_v5 && _v5.startsWith && _v5.startWith("{")) ret.addParams(_v5.trim("{").trim("}"), ret.LimitParam);
      }
      ___.func(ret.WhereParam, ret, _.sign);
      ret.Method = _.Method;
      ret.Table = _.Table;
      ret.sign = _.sign;
      return ret;
    }
  }]);
  return QueryEntity;
}();
var LinqParser = exports.LinqParser = function () {
  function LinqParser() {
    var sign = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "?";
    (0, _classCallCheck3.default)(this, LinqParser);

    var _pri4 = pri(this, {
      dicQuery: {}
    }),
        _ = _pri4._,
        __ = _pri4.__;

    _.sign = sign;
  }

  (0, _createClass3.default)(LinqParser, [{
    key: "parse",
    value: function parse(sql) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      var _pri5 = pri(this),
          _ = _pri5._,
          __ = _pri5.__;

      var key = "K" + _tool2.default.hash(sql);
      if (__.dicQuery[key]) {} else {
        var rets = sql.split(";").filter(function (v) {
          return _tool2.default.isValid(v);
        });
        rets.forEach(function (v, i) {
          return rets[i] = v ? _.singleparse(v) : null;
        });
        __.dicQuery[key] = rets;
      }
      var ret = [];
      __.dicQuery[key].forEach(function (v) {
        if (v) {
          var entity = v.clone();

          var _loop = function _loop(k) {
            var v = entity.Params[k];
            entity.IDs[k] && !params[k] && (params[k] = { value: "" }); //为hgets hkeys 添加默认值
            var val = params[k] && params[k].value !== undefined ? params[k].value : params[k];
            var key = _.sign + k;
            if (val !== undefined && val !== null) {} else throw new Error("没有找到需要的参数值" + key);
            v.forEach(function (v2) {
              for (var k3 in v2) {
                if (v2[k3] == key) v2[k3] = val;
              }
            });
          };

          for (var k in entity.Params) {
            _loop(k);
          }

          if (entity.Table && entity.Table.indexOf("{") >= 0) entity.Table = entity.Table.replace(/\{[a-zA-Z0-9_]+\}/g, function (k) {
            var k2 = k.substr(1, k.length - 2);
            var ret = params[k2] ? params[k2].value || (params[k2].type ? "" : params[k2]) : k;
            if (ret && ret.startWith(_.sign) && params[ret.trim(_.sign)]) {
              k2 = ret.trim(_.sign);
              ret = params[k2] ? params[k2].value || (params[k2].type ? "" : params[k2]) : k;
            }
            return ret;
          });

          ret.push(entity);
        }
      });
      return ret;
    }
  }, {
    key: "singleparse",
    value: function singleparse(sql) {
      var _pri6 = pri(this),
          _ = _pri6._,
          __ = _pri6.__;

      if (sql) {
        var entity = new QueryEntity(_.sign);
        var sqls = sql.split(".");
        var v = sqls.shift();
        while (!_tool2.default.isValid(v)) {
          v = sqls.shift();
        }v && "transaction".eq(v.trim()) && (entity.Method = "transaction", v = sqls.shift());
        if (v) {
          //设置表名
          v = v.trim();
          if (v.indexOf("<") >= 0) {
            var tabs = v.split("<");
            entity.Table = tabs[0].trim();
            tabs[1].trim(">").split(",").forEach(function (f) {
              f = f.trim(_.sign);
              entity.IDs[f] = _.sign + f;
              entity.addParams(f, entity.IDs);
            });
          } else {
            entity.Table = v.trim();
          }
          v = sqls.shift();
        }
        if (v && !_tool2.default.isValid(entity.Method)) {
          v = v.trim();
          var method = v.toLowerCase().split("(")[0];
          switch (method) {
            case "select":
            case "hselect":
            case "hmselect":
            case "hkeys":
            case "hgets":
            case "zlen":
            case "zcount":
            case "zselect":
            case "zpop":
            case "zrank":
            case "lselect":
            case "lpop":
            case "lcount":
            case "lrange":
            case "lgets":
            case "llen":
            case "dbs":
            case "hkeys":
            case "hlen":
            case "hcount":
            case "expire":
            case "delete":
            case "hdelete":
            case "zdelete":
            case "ldelete":
              handleMethodstartWith(v, method, entity);
              break;
            case "insert":
            case "hinsert":
            case "zinsert":
            case "linsert":
            case "hupdate":
            case "zupdate":
            case "lupdate":
            case "hngcrease":
            case "ngcrease":
            case "lock":
            case "hlock":
              handleMethodstartWith(v, method, entity, _.sign);
              break;
            case "update":
              handleMethodstartWith(v, "insert", entity, _.sign);
              break;
            case "increase":
            case "hincrease":
            case "zincrease":
              {
                entity.Method = method.startWith("i") ? "increase" : method.startWith("z") ? "zincrease" : "hincrease";
                v = v.substr(entity.length).trim("(").trim(")").trim();
                if (!(!_tool2.default.isValid(v) || "*" == v)) {
                  v.split(",").forEach(function (f) {
                    if (!_tool2.default.isValid(f)) return;
                    f = f.trim();
                    var p3 = f.split("=");
                    if (p3.length < 2) throw new Error('SQL在"' + v.substr(v.indexOf(f)) + '"处解析错误!\r\n:' + f + "没有找到=号");
                    entity.MethodParam[p3[0].trim()] = p3[1].trim();
                    if (p3[1].trim().startWith(_.sign)) {
                      entity.addParams(p3[1].trim(_.sign), entity.MethodParam);
                    }
                  });
                } else throw new Error('SQL在"' + v.substr(v.indexOf(".")) + '"处解析错误!\r\n:\r\n:没有找到可插入的列及其值');
              }
              break;
            default:
              //错误
              throw new Error('SQL在"' + v.substr(v.indexOf(".")) + '"处解析错误!\r\n:没有找到可解析的操作指令');
          }
          //设置操作
          v = sqls.shift();
        }

        if (v && v.toLowerCase().startWith("where")) {
          //这里需要判断 where skip limit
          v = v.trim();
          //region where(a1 = 1 and b=2 or c=3 and d=4 and ())
          //= > >= < <= <> 第一优先级 然后是 () 然后是 and 然后是 or 再添加对not的处理
          var ht = {};
          var w = 0;
          //取消)号 由(号识别其结束符
          "=,>,<,>=,<=,<>,not,and,or,(,;,in".split(",").forEach(function (f) {
            return ht[f] = w++;
          });
          ht[","] = w++;
          //todo in和,号

          /*
           * 解释器+责任链式处理思路
           * 缓存分为 非逻辑字符 与 已完成逻辑操作两个变量 和 未完成逻辑操作栈 保留未完成的操作
           * LogicOperate 其每次 lIncome 非逻辑字符，已完成逻辑操作 rIncome 非逻辑字符，已完成逻辑操作与未处理字符，
           * 如果发现此逻辑字符不为自己所能处理 将自己压栈等待下一个逻辑操作完成，当下一个操作完成时自动弹出下个操作调用将自己作为其另一种右进操作，直到语句结束
           * 发现字符未处理完成或者栈内仍然有未处理的操作 报错，如果缓存字符，已完成逻辑操作超过1个报错
           **/
          var session = new OperationSession();
          var _p = v.trim();
          _p = _p.substr(6, _p.length - 7);
          _p = _p.replace(/=/g, " = ");
          _p = _p.replace(/>/g, " > ");
          _p = _p.replace(/</g, " < ");
          _p = _p.replace(/\(/g, " ( ");
          _p = _p.replace(/\)/g, " ) ");
          _p = _p.replace(/<\s*>/g, " <> ");
          _p = _p.replace(/>\s*=/g, " >= ");
          _p = _p.replace(/<\s*=/g, " <= ");
          _p = _p.replace(/\s+/g, " ");
          _p.split(" ").forEach(function (f) {
            try {
              if (!_tool2.default.isValid(f)) return;
              if (ht[f.toLowerCase()] >= 0) {
                var index = ht[f.toLowerCase()];
                var ope = null;
                if (index < 1) {
                  //表达式
                  ope = new EqualOperate();
                } else if (index < 6) {
                  ope = new O1Operate(f);
                } else if (index < 7) {
                  ope = new NotOperate();
                } else if (index < 8) {
                  ope = new AndOperate();
                } else if (index < 9) {
                  //处理or
                  ope = new O2Operate(f);
                } else if (index < 10) {
                  //处理括号
                  ope = new LCOperate();
                }
                if (ope == null) throw new Error("发现暂时无法处理的操作符号" + f);
                ope.lIncome(session);
              } else {
                //临时存放字符否则弹出操作栈进行右入处理
                if (session.OperateStack.length == 0) session.Word = f;else session.OperateStack.pop().rIncome(session, f);
              }
            } catch (ex) {
              throw new Error('SQL在"' + _p.substr(_p.indexOf(" " + f + " ")) + '"处解析错误!\r\n:' + ex.message);
            }
          });
          if (session.isComplete) {
            var ope = session.CompleteOperate;
            entity.WhereParam = ope.toDictionary(entity, _.sign);
            var func = function func(data) {
              for (var k in data) {
                var _v6 = data[k];
                if (_v6.startsWith) {
                  if (_v6.startWith(_.sign)) {
                    entity.addParams(_v6.trim(_.sign), data);
                  }
                } else if ((typeof _v6 === "undefined" ? "undefined" : (0, _typeof3.default)(_v6)) == "object") {
                  func(_v6);
                }
              }
            };
            func(entity.WhereParam);
          } else throw new Error('SQL在"' + _p.substr(_p.indexOf(" " + session.Word + " ")) + '"处解析错误!\r\n:语句未完成');

          v = sqls.shift();
        }

        if (v && v.startWith("order")) {
          v = v.trim();
          //#region order(a1 asc,b1 desc)
          var p4 = v.trim(")").split("(");
          if (p4.length < 2) {
            throw new Error('SQL在"' + p3.substr(p3.indexOf(".order")) + '"处解析错误!\r\n:skip没有找到可用的参数');
          }
          p4[1].split(",").forEach(function (f) {
            var f2 = f.split(" ");
            entity.OrderParam[f2[0].trim()] = f2.length < 2 ? "asc" : f2[1].trim();
          });
          v = sqls.shift();
          //#endregion
        }

        if (v && v.startWith("skip")) {
          v = v.trim();
          //#region skip(@page) skip(11)
          //todo 支持表达式
          var _p2 = v.trim(")").split("(");
          if (_p2.length < 2) {
            throw new Error('SQL在"' + p3.substr(p3.indexOf(".skip")) + '"处解析错误!\r\n:skip没有找到可用的参数');
          }
          entity.SkipParam[_p2[1].trim(_.sign)] = _p2[1];
          if (_p2[1].startWith(_.sign)) entity.addParams(_p2[1].trim(_.sign), entity.SkipParam);

          v = sqls.shift();
          //#endregion
        }

        if (v && v.startWith("limit")) {
          v = v.trim();
          //#region limit(@page) limit(11)
          //todo 支持表达式
          var _p3 = v.trim(")").split("(");
          if (_p3.length < 2) {
            throw new Error('SQL在"' + p3.substr(p3.indexOf(".limit")) + '"处解析错误!\r\n:skip没有找到可用的参数');
          }
          _p3[1].split(",").forEach(function (v2, i) {
            entity.LimitParam[v2.trim(_.sign)] = v2;
            entity.LimitParam["_" + i] = v2.trim(_.sign);
            if (v2.startWith(_.sign)) entity.addParams(v2.trim(_.sign), entity.LimitParam);
          });

          v = sqls.shift();
          //#endregion
        }

        if (v && (v.startWith("datetime") || v.startWith("timeout"))) {
          v = v.trim();
          //#region datetime(@time) datetime(200) timeout(@time) timeout(2000)
          //todo 支持表达式
          var _p4 = v.trim(")").split("(");
          if (_p4.length < 2) {
            throw new Error('SQL在"' + p3.substr(p3.indexOf("datetime")) + '"处解析错误!\r\n:skip没有找到可用的参数');
          }
          entity.DateTimeParam[_p4[1].trim(_.sign)] = _p4[1];
          if (_p4[1].startWith(_.sign)) entity.addParams(_p4[1].trim(_.sign), entity.DateTimeParam);

          v = sqls.shift();
          //#endregion
        }

        if (v) throw new Error('SQL在"' + p3.substr(p3.indexOf("." + v)) + '"处解析错误!\r\n:没有找到可解析的操作指令');
        return entity;
      } else throw new Error("sql必须有值!");
    }
  }]);
  return LinqParser;
}();

/**
 * 处理Method时，统一处理
 * v: 传进来的方法名，如：select开头，hselect开头，insert开头等
 * method:  nosql对应的操作方法
 * entity:转换后的实体
 * sign:
 */
function handleMethodstartWith(v, method, entity, sign) {
  entity.Method = method;
  v = v.substr(method.length).trim("(").trim(")").trim();
  switch (method) {
    case "select":
    case "hselect":
    case "hmselect":
    case "zlen":
    case "zcount":
    case "zselect":
    case "zpop":
    case "zrank":
    case "hkeys":
    case "hgets":
    case "lpop":
    case "lselect":
    case "llen":
    case "lcount":
    case "lrange":
    case "lgets":
    case "hlen":
    case "hcount":
    case "dbs":
      if (!(!_tool2.default.isValid(v) || "*" == v)) {
        v.split(",").forEach(function (f) {
          if (!_tool2.default.isValid(f)) return;
          entity.MethodParam[f] = 1;
        });
      }
      break;
    case "insert":
    case "hinsert":
    case "zinsert":
    case "linsert":
    case "hngcrease":
    case "ngcrease":
    case "update":
    case "hupdate":
    case "zupdate":
    case "lupdate":
    case "expire":
    case "lock":
    case "hlock":
      if (!(!_tool2.default.isValid(v) || "*" == v)) {
        v.split(",").forEach(function (f) {
          if (!_tool2.default.isValid(f)) return;
          f = f.trim();
          var p3 = f.split("=");
          if (p3.length < 2) throw new Error('SQL在"' + v.substr(v.indexOf(f)) + '"处解析错误!\r\n:' + f + "没有找到=号");
          entity.MethodParam[p3[0].trim()] = p3[1].trim();
          if (p3[1].trim().startWith(sign)) {
            entity.addParams(p3[1].trim(sign), entity.MethodParam);
          }
        });
      } else throw new Error('SQL在"' + v.substr(v.indexOf(".")) + '"处解析错误!\r\n:\r\n:没有找到可插入的列及其值');
      break;
    case "delete":
    case "hdelete":
    case "zdelete":
    case "ldelete":
      if (!(!_tool2.default.isValid(v) || "*" == v)) {
        throw new Error('SQL在"' + v.substr(v.indexOf(".")) + '"处解析错误!\r\n:\r\n:不需要设置可删除的列及其值');
      }
      break;
  }
}
var NoSQLParser = exports.NoSQLParser = function (_LinqParser) {
  (0, _inherits3.default)(NoSQLParser, _LinqParser);

  function NoSQLParser(sign) {
    (0, _classCallCheck3.default)(this, NoSQLParser);

    var _this = (0, _possibleConstructorReturn3.default)(this, (NoSQLParser.__proto__ || (0, _getPrototypeOf2.default)(NoSQLParser)).call(this, sign));

    var _pri7 = pri(_this),
        _ = _pri7._,
        __ = _pri7.__;

    return _this;
  }

  (0, _createClass3.default)(NoSQLParser, [{
    key: "singleparse",
    value: function singleparse(sql) {
      var _pri8 = pri(this),
          _ = _pri8._,
          __ = _pri8.__;

      var sss = sql.replace(/\(/g, " ( ").replace(/\)/g, " ) ");
      //将多个空格,换行换成一个空格
      var item1 = sss.replace(/\s+/g, " ");
      //取关键点索引位置
      var temp = item1.toLowerCase();
      var from1 = temp.indexOf(" from ");
      var where1 = temp.indexOf(" where ");
      var skip1 = temp.indexOf(" skip ");
      var limit1 = temp.indexOf(" limit ");
      var order1 = temp.indexOf(" order ");
      var by1 = temp.indexOf(" by ");
      var set1 = temp.indexOf(" set ");
      var into1 = temp.indexOf(" into ");
      var values1 = temp.indexOf(" values ");
      var dateTime1 = temp.indexOf(" datetime ");
      var begintrans = temp.indexOf("begin transaction");
      var whereMember = "";
      var method = "";
      var methodMember = "";
      var tableStr = "";
      var orderby = "";
      var sk = null;
      var lm = null;
      var date = null;

      //语句中包含from
      if (from1 != -1) {
        var s = item1.substr(0, from1).trim().split(" ");
        if (s.length >= 2) {
          method = s[0].trim().toLowerCase();
          methodMember = s[1].trim();
        } else method = s[0].trim().toLowerCase();
      }
      //语句中不包含from但包含set,update语句处理
      if (set1 != -1 && from1 == -1) {
        var _s = item1.substr(0, set1).trim().split(" ");
        method = _s[0].trim().toLowerCase();
        tableStr = _s[1].trim();
        if (where1 != -1) {
          methodMember = item1.substr(set1 + 4, where1 - set1 - 4).trim();
        } else {
          methodMember = item1.substr(set1 + 4).trim();
        }
      }
      //插入语句处理
      if (from1 == -1 && into1 != -1 && set1 == -1) {
        method = item1.substr(0, into1).trim().toLowerCase();
        if (values1 != -1) {
          var _s2 = item1.substr(into1 + 5, values1 - into1 - 5).trim().split(" ");
          tableStr = _s2[0].trim();
          for (var i = 1; i < _s2.length; i++) {
            methodMember += _s2[i].trim();
          }

          var tp = void 0;
          if (dateTime1 != -1) {
            tp = item1.substr(values1 + 7, dateTime1 - values1 - 7).replace(/\(/g, "").replace(/\)/g, "").trim().split(",");
            date = item1.substr(dateTime1 + 9).replace(/\(/g, "").replace(/\)/g, "").trim(";").trim();
          } else tp = item1.substr(values1 + 7).replace(/\(/g, "").replace(/\)/g, "").trim().split(",");
          var tt = new _tool2.default.sb();
          var mem = methodMember.replace(/\(/g, "").replace(/\)/g, "").split(",");
          for (var _i = 0; _i < mem.length; _i++) {
            tt.append(mem[_i] + "=" + tp[_i] + ",");
          }
          methodMember = tt.clear().trim(",");
        }
      }

      var sb = new _tool2.default.sb();
      //取表名
      if (where1 != -1 && from1 != -1) tableStr = item1.substr(from1 + 5, where1 - from1 - 5).trim();
      if (where1 == -1 && set1 == -1 && from1 != -1) tableStr = item1.substr(from1 + 5).trim().split(" ")[0];
      if (begintrans != -1) {
        method = "transaction";
      }
      //只支持增删改查
      switch (method) {
        case "select":
        case "increase":
        case "delete":
        case "update":
        case "insert":
        case "lock":
        case "touch":
        case "transaction":
        case "hselect":
        case "hmselect":
        case "hincrease":
        case "zlen":
        case "zcount":
        case "zselect":
        case "zpop":
        case "zrank":
        case "zincrease":
        case "lselect":
        case "llen":
        case "lcount":
        case "hkeys":
        case "hlen":
        case "hcount":
        case "hgets":
        case "hlock":
        case "dbs":
        case "lpop":
        case "lrange":
        case "lgets":
        case "zinsert":
        case "linsert":
        case "hinsert":
        case "zupdate":
        case "lupdate":
        case "hupdate":
        case "hdelete":
        case "ldelete":
        case "zdelete":
        case "hngcrease":
        case "ngcrease":
        case "expire":
          break;
        default:
          throw new Error("只支持select,insert,lock,update,delete,touch,transaction,hselect,hmselect,zlen,zcount,zselect,zpop,zrank,zincrease,lselect,lpop,lrange,lgets,llen,lcount,hkeys,hgets,hlen,hcount,zinsert,linsert,hlock,hinsert,hdelete,ldelete,zdelete,hngcrease,dbs,ngcrease,expire.请检查查询语句" + method);
      }
      sb.append(tableStr + "." + method);
      if (!(methodMember.indexOf("*") >= 0 || !_tool2.default.isValid(methodMember))) sb.append("(" + methodMember + ")");
      if (dateTime1 != -1 && date != null) sb.append(".datetime(" + date + ")");
      //排序处理
      if (order1 != -1) {
        if (where1 != -1) {
          whereMember = item1.substr(where1 + 6, order1 - where1 - 6).trim();
          sb.append(".where(" + whereMember + ")");
        }
        if (skip1 != -1) {
          orderby = item1.substr(by1 + 3, skip1 - by1 - 3).trim();
          if (orderby.indexOf(_.sign) >= 0) throw new Error("排序中不允许参数化");
        }
        if (skip1 == -1 && limit1 != -1) {
          orderby = item1.substr(by1 + 3, limit1 - by1 - 3).trim();
        }
        if (skip1 == -1 && limit1 == -1 && dateTime1 == -1) {
          orderby = item1.substr(by1 + 3).trim();
        }
        if (orderby.indexOf(_.sign) >= 0) throw new Error("排序中不允许参数化");
        sb.append(".order(" + orderby + ")");
      } else if (where1 != -1) {
        if (skip1 == -1 && limit1 == -1 && into1 == -1 && dateTime1 == -1) {
          whereMember = item1.substr(where1 + 6).trim();
          sb.append(".where(" + whereMember + ")");
        } else if (skip1 != -1) {
          whereMember = item1.substr(where1 + 6, skip1 - where1 - 6).trim();
          sb.append(".where(" + whereMember + ")");
        } else if (skip1 == -1 && limit1 != -1) {
          whereMember = item1.substr(where1 + 6, limit1 - where1 - 6).trim();
          sb.append(".where(" + whereMember + ")");
        }
      }
      //跳转处理
      if (skip1 != -1) {
        if (limit1 != -1) {
          sk = item1.substr(skip1 + 5, limit1 - 5 - skip1).trim();
          sb.append(".skip(" + sk + ")");
        } else if (dateTime1 == -1 && limit1 == -1) {
          sk = item1.substr(skip1 + 5).trim();
          sb.append(".skip(" + sk + ")");
        }
      }
      //限制条数处理
      if (limit1 != -1 && dateTime1 == -1) {
        lm = item1.substr(limit1 + 6).trim();
        sb.append(".limit(" + lm + ")");
      }
      var p = sb.clear();
      sb = null;
      return (0, _get3.default)(NoSQLParser.prototype.__proto__ || (0, _getPrototypeOf2.default)(NoSQLParser.prototype), "singleparse", this).call(this, p);
    }
  }]);
  return NoSQLParser;
}(LinqParser);
/*
    export const addParams = (ret, value, entity, sign) => {
        //仅仅补充Level为1时的状态                    
        if (typeof(value) == 'object' && V.toJsonString(value).startWith('{')) {
            for(let k in value){
                let v = value[k];
                if ((v + '').startWith(sign)) {
                    entity.addParams(v + '', value);
                }
            });
        } else if (V.isArray(value)) {
            //对这种2级操作符之间的嵌套不做处理
        } else {
            if ((value + '').startWith(sign)) {
                entity.addParams(value + '', ret);
            }
        }
    };*/
var OperationSession = exports.OperationSession = function () {
  function OperationSession() {
    (0, _classCallCheck3.default)(this, OperationSession);

    var _pri9 = pri(this, {
      word: null,
      regWord: new RegExp("^[a-zA-Z_\\$]+[a-zA-Z0-9_\\$]*$"),
      completeOperate: null
    }),
        _ = _pri9._,
        __ = _pri9.__;

    _.OperateStack = [];
  }

  (0, _createClass3.default)(OperationSession, [{
    key: "Word",
    set: function set(val) {
      var _pri10 = pri(this),
          _ = _pri10._,
          __ = _pri10.__;

      if (!_tool2.default.isValid(val.match(__.regWord))) throw new Error("不能放入含非法字符的列名" + val);
      if (__.word) throw new Error("不能连续放入未处理字符");else __.word = val;
    },
    get: function get() {
      var _pri11 = pri(this),
          _ = _pri11._,
          __ = _pri11.__;

      var ret = __.word;
      __.word = null;
      return ret;
    }
  }, {
    key: "CompleteOperate",
    set: function set(val) {
      var _pri12 = pri(this),
          _ = _pri12._,
          __ = _pri12.__;

      if (!_tool2.default.isValid(__.completeOperate)) __.completeOperate = val;else throw new Error("不能连续放入已处理的Operator");
    },
    get: function get() {
      var _pri13 = pri(this),
          _ = _pri13._,
          __ = _pri13.__;

      var ret = __.completeOperate;
      __.completeOperate = null;
      return ret;
    }
  }, {
    key: "isComplete",
    get: function get() {
      var _pri14 = pri(this),
          _ = _pri14._,
          __ = _pri14.__;

      return !_tool2.default.isValid(__.word) && _.OperateStack.length == 0 && __.completeOperate != null;
    }
  }]);
  return OperationSession;
}();
var ALogicOperate = exports.ALogicOperate = function () {
  function ALogicOperate(ope) {
    (0, _classCallCheck3.default)(this, ALogicOperate);

    var _pri15 = pri(this, {}),
        _ = _pri15._,
        __ = _pri15.__;

    _.Ope = ope;
    _.level = 0;
  }

  (0, _createClass3.default)(ALogicOperate, [{
    key: "lIncome",
    value: function lIncome(session) {}
  }, {
    key: "rIncome",
    value: function rIncome(session, word) {}
  }, {
    key: "rIncome2",
    value: function rIncome2(session, ope) {}
  }, {
    key: "toDictionary",
    value: function toDictionary(entity, sign) {}
  }]);
  return ALogicOperate;
}();
var O1Operate = exports.O1Operate = function (_ALogicOperate) {
  (0, _inherits3.default)(O1Operate, _ALogicOperate);

  function O1Operate(ope) {
    (0, _classCallCheck3.default)(this, O1Operate);

    var _this2 = (0, _possibleConstructorReturn3.default)(this, (O1Operate.__proto__ || (0, _getPrototypeOf2.default)(O1Operate)).call(this, ope));

    var _pri16 = pri(_this2),
        _ = _pri16._,
        __ = _pri16.__;

    _.level = 1;
    _.Key = null;
    _.Value = null;
    return _this2;
  }

  (0, _createClass3.default)(O1Operate, [{
    key: "lIncome",
    value: function lIncome(session) {
      var _pri17 = pri(this),
          _ = _pri17._,
          __ = _pri17.__;

      _.Key = session.Word;
      if (!_tool2.default.isValid(_.Key)) throw new Error(_.Ope + "不能没有对应的列");
      session.OperateStack.push(_);
      return true;
    }
  }, {
    key: "rIncome",
    value: function rIncome(session, word) {
      var _pri18 = pri(this),
          _ = _pri18._,
          __ = _pri18.__;

      _.Value = word;
      if (!_tool2.default.isValid(word)) throw new Error(_.Ope + "不能没有对应的值");
      if (session.OperateStack.length > 0) {
        //向上查找未完成操作的递归操作
        var ope = session.OperateStack.pop();
        if (ope.rIncome2(session, _)) return true;else {
          throw new Error(ope.Ope + "处理错误失败:" + word);
        }
      } else session.CompleteOperate = _;
      return true;
    }
  }, {
    key: "rIncome2",
    value: function rIncome2(session, ope) {
      throw new Error("1级操作符不能处理逻辑表达式之间的关系");
    }
  }, {
    key: "toDictionary",
    value: function toDictionary() {
      var _pri19 = pri(this),
          _ = _pri19._,
          __ = _pri19.__;

      var ret = {};
      ret[_.Ope] = {};
      ret[_.Ope][_.Key] = _.Value;
      return ret;
    }
  }]);
  return O1Operate;
}(ALogicOperate);
var EqualOperate = exports.EqualOperate = function (_O1Operate) {
  (0, _inherits3.default)(EqualOperate, _O1Operate);

  function EqualOperate() {
    (0, _classCallCheck3.default)(this, EqualOperate);

    var _this3 = (0, _possibleConstructorReturn3.default)(this, (EqualOperate.__proto__ || (0, _getPrototypeOf2.default)(EqualOperate)).call(this, "="));

    pri(_this3);
    return _this3;
  }

  (0, _createClass3.default)(EqualOperate, [{
    key: "toDictionary",
    value: function toDictionary() {
      var _pri20 = pri(this),
          _ = _pri20._,
          __ = _pri20.__;

      var ret = {};
      ret[_.Key] = _.Value;
      return ret;
    }
  }]);
  return EqualOperate;
}(O1Operate);

/**
 * 剩余的2级操作 and or not ( )
 */
var O2Operate = exports.O2Operate = function (_ALogicOperate2) {
  (0, _inherits3.default)(O2Operate, _ALogicOperate2);

  function O2Operate(ope) {
    (0, _classCallCheck3.default)(this, O2Operate);

    var _this4 = (0, _possibleConstructorReturn3.default)(this, (O2Operate.__proto__ || (0, _getPrototypeOf2.default)(O2Operate)).call(this, ope));

    var _pri21 = pri(_this4),
        _ = _pri21._;

    _.level = 2;
    _.left = null;
    _.right = null;
    return _this4;
  }

  (0, _createClass3.default)(O2Operate, [{
    key: "lIncome",
    value: function lIncome(session) {
      var _pri22 = pri(this),
          _ = _pri22._,
          __ = _pri22.__;

      _.left = session.CompleteOperate;
      if (_.left == null) throw new Error(_.Ope + " 不能直接处理非逻辑表达式");
      session.OperateStack.push(_);
      return true;
    }
  }, {
    key: "rIncome",
    value: function rIncome(session, word) {
      session.Word = word;
      session.OperateStack.push(this);
      return true;
    }
  }, {
    key: "rIncome2",
    value: function rIncome2(session, ope) {
      var _pri23 = pri(this),
          _ = _pri23._,
          __ = _pri23.__;

      _.right = ope;
      if (_.right == null) throw new Error(_.Ope + " 不能直接处理非逻辑表达式");
      if (session.OperateStack.length > 0) {
        //向上查找未完成操作的递归操作
        var ope2 = session.OperateStack.pop();
        if (ope2.rIncome2(session, _)) return true;else {
          throw new Error(ope2.Ope + "处理错误失败");
        }
      } else session.CompleteOperate = this;
      return true;
    }
    /**
     * 目前只能处理1,2级混杂 不能处理连续2级
     */

  }, {
    key: "toDictionary",
    value: function toDictionary(entity, sign) {
      var _pri24 = pri(this),
          _ = _pri24._,
          __ = _pri24.__;

      var ret = {};
      var dicLeft = _.left.toDictionary(entity, sign);
      var dicRight = _.right.toDictionary(entity, sign);
      //当操作符一致时去壳可以并列于一个字典中
      if (_.left.Ope == _.Ope) {
        dicLeft = dicLeft[_.Ope];
      }
      if (_.right.Ope == _.Ope) {
        dicRight = dicRight[_.Ope];
      }

      //左侧原始值赋值并判断是否为真实
      _tool2.default.merge(ret, dicLeft, true);
      _tool2.default.merge(ret, dicRight, true);
      //保证一定不会有键值重复的可能
      var ret2 = {};
      ret2[_.Ope] = ret;
      return ret2;
    }
  }]);
  return O2Operate;
}(ALogicOperate);
var NotOperate = exports.NotOperate = function (_O2Operate) {
  (0, _inherits3.default)(NotOperate, _O2Operate);

  function NotOperate() {
    (0, _classCallCheck3.default)(this, NotOperate);

    var _this5 = (0, _possibleConstructorReturn3.default)(this, (NotOperate.__proto__ || (0, _getPrototypeOf2.default)(NotOperate)).call(this, "not"));

    var _pri25 = pri(_this5),
        _ = _pri25._;

    return _this5;
  }

  (0, _createClass3.default)(NotOperate, [{
    key: "lIncome",
    value: function lIncome(session) {
      var _pri26 = pri(this),
          _ = _pri26._,
          __ = _pri26.__;

      if (_tool2.default.isValid(session.Word) || session.CompleteOperate != null) throw new Error("not 处理错误,不允许存在前置的非2级表达式");
      session.OperateStack.push(_);
      return true;
    }
  }, {
    key: "toDictionary",
    value: function toDictionary(entity, sign) {
      var _pri27 = pri(this),
          _ = _pri27._,
          __ = _pri27.__;

      var ret = {};
      var dicRight = _.right.toDictionary(entity, sign);
      //左侧原始值赋值并判断是否为真实
      ret[_.Ope] = dicRight;
      return ret;
    }
  }]);
  return NotOperate;
}(O2Operate);
/**
 * 特别处理and 当前面是已结束的or 时可能把自己放进去其右边
 */
var AndOperate = exports.AndOperate = function (_O2Operate2) {
  (0, _inherits3.default)(AndOperate, _O2Operate2);

  function AndOperate() {
    (0, _classCallCheck3.default)(this, AndOperate);

    var _this6 = (0, _possibleConstructorReturn3.default)(this, (AndOperate.__proto__ || (0, _getPrototypeOf2.default)(AndOperate)).call(this, "and"));

    pri(_this6);
    return _this6;
  }

  (0, _createClass3.default)(AndOperate, [{
    key: "lIncome",
    value: function lIncome(session) {
      var _pri28 = pri(this),
          _ = _pri28._,
          __ = _pri28.__;

      _.left = session.CompleteOperate;
      if (_.left == null) throw new Error(_.Ope + " 不能直接处理非逻辑表达式");
      if ("or" == _.left.Ope && _.left.right && _.left.right.level == 1) {
        var orOpe = _.left;
        _.left = orOpe.right;
        orOpe.right = this;
        session.OperateStack.push(orOpe);
        session.OperateStack.push(_);
      } else session.OperateStack.push(_);
      return true;
    }
  }]);
  return AndOperate;
}(O2Operate);
var LCOperate = exports.LCOperate = function (_O2Operate3) {
  (0, _inherits3.default)(LCOperate, _O2Operate3);

  function LCOperate() {
    (0, _classCallCheck3.default)(this, LCOperate);

    var _this7 = (0, _possibleConstructorReturn3.default)(this, (LCOperate.__proto__ || (0, _getPrototypeOf2.default)(LCOperate)).call(this, "("));

    var _pri29 = pri(_this7),
        _ = _pri29._;

    _.RealLogicOperate = null;
    return _this7;
  }

  (0, _createClass3.default)(LCOperate, [{
    key: "lIncome",
    value: function lIncome(session) {
      var _pri30 = pri(this),
          _ = _pri30._,
          __ = _pri30.__;

      if (_tool2.default.isValid(session.Word) || session.completeOperate != null) throw new Error('"("处理错误,不允许存在前置的非2级表达式');
      session.OperateStack.push(_);
      return true;
    }
  }, {
    key: "rIncome",
    value: function rIncome(session, word) {
      var _pri31 = pri(this),
          _ = _pri31._,
          __ = _pri31.__;

      if (")" == word) {
        _.RealLogicOperate = session.CompleteOperate;
        if (session.OperateStack.length > 0) {
          var ope = session.OperateStack.pop();
          ope.rIncome2(session, _);
        } else session.CompleteOperate = _;
      } else return (0, _get3.default)(LCOperate.prototype.__proto__ || (0, _getPrototypeOf2.default)(LCOperate.prototype), "rIncome", this).call(this, session, word);
      return true;
    }
  }, {
    key: "rIncome2",
    value: function rIncome2(session, ope) {
      session.CompleteOperate = ope;
      session.OperateStack.push(this);
      return true;
    }
  }, {
    key: "toDictionary",
    value: function toDictionary(entity, sign) {
      //todo 应该把$加在ope前面
      //return new Dictionary<string, object> { { _.Ope, RealLogicOperate.toDictionary(entity, sign) } };
      return this.RealLogicOperate.toDictionary(entity, sign);
    }
  }]);
  return LCOperate;
}(O2Operate);
exports.default = {
  QueryEntity: QueryEntity,
  LinqParser: LinqParser,
  NoSQLParser: NoSQLParser,
  OperationSession: OperationSession,
  ALogicOperate: ALogicOperate,
  O1Operate: O1Operate,
  EqualOperate: EqualOperate,
  O2Operate: O2Operate,
  NotOperate: NotOperate,
  AndOperate: AndOperate,
  LCOperate: LCOperate
};

var pri = _tool2.default.pris();
var ___ = {
  func: function func(data, ret, sign) {
    //参数化
    for (var k in data) {
      var v = data[k];
      if (v.startsWith) {
        if (v.startWith(sign)) {
          ret.addParams(v.trim(sign), data);
        }
      } else if ((typeof v === "undefined" ? "undefined" : (0, _typeof3.default)(v)) == "object") {
        ___.func(v, ret, sign);
      }
    }
  }
};
//# sourceMappingURL=nosql.js.map