eme-flow/lib/sql/SQL.js

eme flow组件

/**
 * Created by cc on 2016/9/23 0023.
 * 查询语句
 * 必须先配置好Pooler
 */
'use strict';

exports.__esModule = true;

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

var _typeof3 = _interopRequireDefault(_typeof2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _mysql = require('mysql');

var _mysql2 = _interopRequireDefault(_mysql);

var _toolkit = require('../util/toolkit');

var _toolkit2 = _interopRequireDefault(_toolkit);

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

var regex = /:(\D\w+)\b/g;

var SQL = function () {
    function SQL() {
        var name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
        (0, _classCallCheck3.default)(this, SQL);

        this._sql = [];
        this._where = [];
        this._order = [];
        this._group = [];
        this._params = {};
        this._keyword = {};
        this._begin = -1;
        this._length = -1;
        this._name = name;
        this._and = true;
    }

    SQL.prototype.push = function push(sql) {
        this._sql.push(sql);
        return this;
    };

    SQL.prototype.and = function and(sql) {
        if (sql !== undefined) {
            this._where.push(' AND ' + sql);
        }
        this._and = true;
        return this;
    };

    SQL.prototype.or = function or(sql) {
        if (sql !== undefined) {
            this._where.push(' OR ' + sql);
        }
        this._and = false;
        return this;
    };

    SQL.prototype.where = function where(sql) {
        this._where.push(sql);
        return this;
    };

    SQL.prototype.order = function order(sql) {
        this._order.push(sql);
        return this;
    };

    SQL.prototype.group = function group(sql) {
        this._group.push(sql);
        return this;
    };

    /**
     *
     * @param key like {key1 : value1,key2 : value2} or key
     * @param value like {key1 : keyword,key2 : keyword} or value
     * @param keyword like true | false
     * @returns {SQL}
     */


    SQL.prototype.set = function set(key, value) {
        var keyword = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];

        if ((typeof key === 'undefined' ? 'undefined' : (0, _typeof3.default)(key)) === 'object') {
            _toolkit2.default.mix(this._params, key);
            if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object') {
                _toolkit2.default.mix(this._keyword, value);
            }
        } else {
            this._params[key] = value;
            this._keyword[key] = keyword;
        }

        return this;
    };

    SQL.prototype.begin = function begin(c) {
        this._begin = c;
        return this;
    };

    SQL.prototype.length = function length(c) {
        this._length = c;
        return this;
    };

    SQL.prototype.jqGrid = function jqGrid(req) {
        var _this = this;

        //是否是jqgrid请求判断
        if (!req || req.param('nd') === undefined) return this;
        var filters = req.param('filters'),
            search = req.param('search'),
            param_req = req.param('params'),
            __tableName__ = req.param('__tableName__'),
            __search__ = req.param('__search__');
        try {
            filters = JSON.parse(req.param('filters'));
        } catch (e) {}
        var rules = filters && filters.rules || [],
            groupOp = filters && filters.groupOp || 'AND';

        search && (rules = rules.concat(search));

        __search__ && __search__.forEach(function (s) {
            return rules.push({
                field: s[0],
                op: s[1],
                data: s[2]
            });
        });

        if (groupOp !== 'AND') this.or();
        var param_cache = {};
        var paramName = function paramName(field) {
            field = field.replace(/\w+\./, '');
            if (param_cache[field] === undefined) param_cache[field] = 0;
            return '_param_' + field + '_' + ++param_cache[field];
        };
        var dataCheck = function dataCheck(value) {
            if (value === '') return false;
            if (value === undefined) return false;
            if (isNaN(value)) return value;
            if (!isNaN(value)) return +value;
        };
        rules.forEach(function (rule) {
            rule.data = dataCheck(rule.data);
            if (__tableName__ !== undefined) {
                var ta = __tableName__.find(function (t) {
                    return t[0] === rule.field;
                });
                if (ta !== undefined) rule.field = ta[1] + '.' + rule.field;
            }
            switch (rule.op) {
                case 'nu':
                    _this.where(groupOp + ' ' + rule.field + ' IS NULL');
                    break;
                case 'nn':
                    _this.where(groupOp + ' ' + rule.field + ' IS NOT NULL');
                    break;
                case 'gt':
                    if (rule.data !== false) {
                        var p = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' > :' + p);
                        _this.set(p, rule.data);
                    }
                    break;
                case 'ge':
                    if (rule.data !== false) {
                        var _p = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' >= :' + _p);
                        _this.set(_p, rule.data);
                    }
                    break;
                case 'le':
                    if (rule.data !== false) {
                        var _p2 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' <= :' + _p2);
                        _this.set(_p2, rule.data);
                    }
                    break;
                case 'lt':
                    if (rule.data !== false) {
                        var _p3 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' < :' + _p3);
                        _this.set(_p3, rule.data);
                    }
                    break;
                case 'eq':
                    if (rule.data !== false) {
                        var _p4 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' = :' + _p4);
                        _this.set(_p4, rule.data);
                    }
                    break;
                case 'ne':
                    if (rule.data !== false) {
                        var _p5 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' <> :' + _p5);
                        _this.set(_p5, rule.data);
                    }
                    break;
                case 'cn':
                    if (rule.data !== false) {
                        var _p6 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' LIKE CONCAT(\'%\',:' + _p6 + ',\'%\')');
                        _this.set(_p6, rule.data);
                    }
                    break;
                case 'nc':
                    if (rule.data !== false) {
                        var _p7 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' NOT LIKE CONCAT(\'%\',:' + _p7 + ',\'%\')');
                        _this.set(_p7, rule.data);
                    }
                    break;
                case 'bw':
                    if (rule.data !== false) {
                        var _p8 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' LIKE CONCAT(:' + _p8 + ',\'%\')');
                        _this.set(_p8, rule.data);
                    }
                    break;
                case 'bn':
                    if (rule.data !== false) {
                        var _p9 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' NOT LIKE CONCAT(:' + _p9 + ',\'%\')');
                        _this.set(_p9, rule.data);
                    }
                    break;
                case 'ew':
                    if (rule.data !== false) {
                        var _p10 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' LIKE CONCAT(\'%\',:' + _p10 + ')');
                        _this.set(_p10, rule.data);
                    }
                    break;
                case 'en':
                    if (rule.data !== false) {
                        var _p11 = paramName(rule.field);
                        _this.where(groupOp + ' ' + rule.field + ' NOT LIKE CONCAT(\'%\',:' + _p11 + ')');
                        _this.set(_p11, rule.data);
                    }
                    break;
            }
        });
        param_req !== undefined && this.set(param_req);

        var order = req.param('sidx') && [req.param('sidx'), req.param('sord')].join(' ').replace('asc,  asc', '').replace('desc,  desc', '');
        if (order) {
            if (__tableName__ !== undefined) {
                order = order.replace(/[^,\s]*?/gi, function (m, i) {
                    var n = m.toLowerCase();
                    if (n === 'asc' || n === 'desc') {
                        return m;
                    }
                    var ta = __tableName__.find(function (t) {
                        return t[0] === m;
                    });
                    if (ta !== undefined) return ta[1] + '.' + m;
                    return m;
                });
            }
            this.order(order);
        }

        var group = req.param('groupBy');
        if (group) {
            if (__tableName__ !== undefined) {
                group = group.replace(/[^,\s]*?/gi, function (m, i) {
                    var n = m.toLowerCase();
                    if (n === 'asc' || n === 'desc') {
                        return m;
                    }
                    var ta = __tableName__.find(function (t) {
                        return t[0] === m;
                    });
                    if (ta !== undefined) return ta[1] + '.' + m;
                    return m;
                });
            }
            this.group(group);
        }

        this.begin((+req.param('page') - 1) * +req.param('rows'));
        this.length(+req.param('rows'));
        return this;
    };

    SQL.prototype.compile = function compile() {
        var _this2 = this;

        var params = [];
        var sql = [];
        this._sql.forEach(function (e) {
            var es = [];
            es.push(e);
            if (_this2._where.length > 0) {
                es.push(' WHERE ');
                if (_this2._and === true) es.push(' 1 = 1 ');else es.push(' 1 <> 1 ');
                es.push(_this2._where.join(' '));
            }
            if (_this2._group.length > 0) {
                es.push(' GROUP BY ');
                es.push(_this2._group.join(' '));
            }
            if (_this2._order.length > 0) {
                es.push(' ORDER BY ');
                es.push(_this2._order.join(' '));
            }
            sql.push(es.join(''));
        });
        sql = sql.join(';');
        sql = sql.replace(regex, function (a1, a2) {
            if (_this2._params.hasOwnProperty(a2) === false) {
                throw {
                    message: '参数' + a2 + '没有传递',
                    error: '参数' + a2 + '没有传递',
                    state: 111001
                };
            }
            params.push(_this2._params[a2]);
            return _this2._keyword[a2] === true ? '??' : '?';
        });
        sails.log.debug(sql + ' > ' + params);
        return {
            sql: sql,
            values: params
        };
    };

    SQL.prototype.clear = function clear() {
        this._sql.length = 0;
        this._where.length = 0;
        this._order.length = 0;
        this._group.length = 0;
        this._params = {};
        this._keyword = {};
        this._begin = -1;
        this._length = -1;
        this._and = true;
        return this;
    };

    return SQL;
}();

exports.default = SQL;

module.exports = exports.default;
//# sourceMappingURL=SQL.js.map