diff --git a/docs-md/coverage.html b/docs-md/coverage.html index f4295537..fd8d971d 100644 --- a/docs-md/coverage.html +++ b/docs-md/coverage.html @@ -256,10 +256,10 @@
- Coverage88.47 - SLOC22140 - LOC5315 - Missed613 + Coverage88.48 + SLOC22197 + LOC5311 + Missed612
@@ -6921,11 +6921,11 @@
  • * @property {Boolean} hasSelectSource true if this dataset already has a select sources.
  • */
  • constructor:function (db, opts) {
    • -
  • 25725 this._super(arguments);
    • -
  • 25725 this.db = db;
    • -
  • 25725 this.__opts = {};
    • -
  • 25725 this.__rowCb = null;
    • -
  • 25725 if (db) {
    • +
  • 25745 this._super(arguments);
    • +
  • 25745 this.db = db;
    • +
  • 25745 this.__opts = {};
    • +
  • 25745 this.__rowCb = null;
    • +
  • 25745 if (db) {
  • 13274 this.__quoteIdentifiers = db.quoteIdentifiers;
  • 13274 this.__identifierInputMethod = db.identifierInputMethod;
  • 13274 this.__identifierOutputMethod = db.identifierOutputMethod;
    • @@ -6943,22 +6943,22 @@
  • * @return [patio.Dataset] a cloned dataset with the merged options
  • **/
  • mergeOptions:function (opts) {
    • -
  • 13414 opts = isUndefined(opts) ? {} : opts;
    • -
  • 13414 var ds = new this._static(this.db, {});
    • -
  • 13414 ds.rowCb = this.rowCb;
    • -
  • 13414 this._static.FEATURES.forEach(function (f) {
    • -
  • 187796 ds[f] = this[f];
    • +
  • 13418 opts = isUndefined(opts) ? {} : opts;
    • +
  • 13418 var ds = new this._static(this.db, {});
    • +
  • 13418 ds.rowCb = this.rowCb;
    • +
  • 13418 this._static.FEATURES.forEach(function (f) {
    • +
  • 187852 ds[f] = this[f];
  • }, this);
    • -
  • 13414 var dsOpts = ds.__opts = merge({}, this.__opts, opts);
    • -
  • 13414 ds.identifierInputMethod = this.identifierInputMethod;
    • -
  • 13414 ds.identifierOutputMethod = this.identifierOutputMethod;
    • -
  • 13414 var columnChangeOpts = this._static.COLUMN_CHANGE_OPTS;
    • -
  • 13414 if (Object.keys(opts).some(function (o) {
    • -
  • 12145 return columnChangeOpts.indexOf(o) !== -1;
    • +
  • 13418 var dsOpts = ds.__opts = merge({}, this.__opts, opts);
    • +
  • 13418 ds.identifierInputMethod = this.identifierInputMethod;
    • +
  • 13418 ds.identifierOutputMethod = this.identifierOutputMethod;
    • +
  • 13418 var columnChangeOpts = this._static.COLUMN_CHANGE_OPTS;
    • +
  • 13418 if (Object.keys(opts).some(function (o) {
    • +
  • 12149 return columnChangeOpts.indexOf(o) !== -1;
  • })) {
  • 2289 dsOpts.columns = null;
  • }
    • -
  • 13414 return ds;
    • +
  • 13418 return ds;
  • },
    • @@ -6985,17 +6985,17 @@
  • * @return {patio.sql.Identifier|patio.sql.QualifiedIdentifier|patio.sql.AliasedExpression} an identifier generated based on the name string.
  • */
  • stringToIdentifier:function (name) {
    • -
  • 12879 if (isString(name)) {
    • -
  • 8755 var parts = this._splitString(name);
    • -
  • 8755 var schema = parts[0], table = parts[1], alias = parts[2];
    • -
  • 8755 return (schema && table && alias
    • +
  • 12895 if (isString(name)) {
    • +
  • 8763 var parts = this._splitString(name);
    • +
  • 8763 var schema = parts[0], table = parts[1], alias = parts[2];
    • +
  • 8763 return (schema && table && alias
  • ? new AliasedExpression(new QualifiedIdentifier(schema, table), alias)
  • : (schema && table
  • ? new QualifiedIdentifier(schema, table)
  • : (table && alias
  • ? new AliasedExpression(new Identifier(table), alias) : new Identifier(table))));
  • } else {
    • -
  • 4124 return name;
    • +
  • 4132 return name;
  • }
  • },
    • @@ -7023,20 +7023,20 @@
  • * </ul>
  • */
  • _splitString:function (s) {
    • -
  • 16920 var ret, m;
    • -
  • 16920 if ((m = s.match(this._static.COLUMN_REF_RE1)) !== null) {
    • +
  • 16928 var ret, m;
    • +
  • 16928 if ((m = s.match(this._static.COLUMN_REF_RE1)) !== null) {
  • 137 ret = m.slice(1);
  • }
    • -
  • 16783 else if ((m = s.match(this._static.COLUMN_REF_RE2)) !== null) {
    • +
  • 16791 else if ((m = s.match(this._static.COLUMN_REF_RE2)) !== null) {
  • 24 ret = [null, m[1], m[2]];
  • }
    • -
  • 16759 else if ((m = s.match(this._static.COLUMN_REF_RE3)) !== null) {
    • +
  • 16767 else if ((m = s.match(this._static.COLUMN_REF_RE3)) !== null) {
  • 1547 ret = [m[1], m[2], null];
  • }
  • else {
    • -
  • 15212 ret = [null, s, null];
    • +
  • 15220 ret = [null, s, null];
  • }
    • -
  • 16920 return ret;
    • +
  • 16928 return ret;
  • },
  • /**
    • @@ -7045,15 +7045,15 @@
  • getters:{
  • rowCb:function () {
    • -
  • 19292 return this.__rowCb;
    • +
  • 19296 return this.__rowCb;
  • },
  • identifierInputMethod:function () {
    • -
  • 13414 return this.__identifierInputMethod;
    • +
  • 13418 return this.__identifierInputMethod;
  • },
  • identifierOutputMethod:function () {
    • -
  • 13414 return this.__identifierOutputMethod;
    • +
  • 13418 return this.__identifierOutputMethod;
  • },
  • firstSourceAlias:function () {
    • @@ -7112,16 +7112,16 @@
  • /**@lends patio.Dataset.prototype*/
  • identifierInputMethod:function (meth) {
    • -
  • 13484 this.__identifierInputMethod = meth;
    • +
  • 13488 this.__identifierInputMethod = meth;
  • },
  • identifierOutputMethod:function (meth) {
    • -
  • 13484 this.__identifierOutputMethod = meth;
    • +
  • 13488 this.__identifierOutputMethod = meth;
  • },
  • rowCb:function (cb) {
    • -
  • 16639 if (isFunction(cb) || isNull(cb)) {
    • -
  • 16634 this.__rowCb = cb;
    • +
  • 16643 if (isFunction(cb) || isNull(cb)) {
    • +
  • 16638 this.__rowCb = cb;
  • } else {
  • 5 throw new DatasetError("rowCb mus be a function");
  • }
    • @@ -7347,14 +7347,14 @@
  • * @borrows patio.Dataset#leftJoin as leftJoin
  • * */
  • constructor:function (options, fromDb) {
    • -
  • 2717 if (this.synced) {
    • -
  • 2717 this.__emitter = new EventEmitter();
    • -
  • 2717 this._super(arguments);
    • -
  • 2717 this.patio = patio || require("./index");
    • -
  • 2717 fromDb = isBoolean(fromDb) ? fromDb : false;
    • -
  • 2717 this.__changed = {};
    • -
  • 2717 this.__values = {};
    • -
  • 2717 if (fromDb) {
    • +
  • 2715 if (this.synced) {
    • +
  • 2715 this.__emitter = new EventEmitter();
    • +
  • 2715 this._super(arguments);
    • +
  • 2715 this.patio = patio || require("./index");
    • +
  • 2715 fromDb = isBoolean(fromDb) ? fromDb : false;
    • +
  • 2715 this.__changed = {};
    • +
  • 2715 this.__values = {};
    • +
  • 2715 if (fromDb) {
  • 1519 this._hook("pre", "load");
  • 1519 this.__isNew = false;
  • 1519 this.__setFromDb(options, true);
    • @@ -7363,8 +7363,8 @@
  • 1519 this._static.emit("load", this);
  • }
  • } else {
    • -
  • 1198 this.__isNew = true;
    • -
  • 1198 this.__set(options);
    • +
  • 1196 this.__isNew = true;
    • +
  • 1196 this.__set(options);
  • }
  • } else {
  • 0 throw new ModelError("Model " + this.tableName + " has not been synced");
    • @@ -7372,15 +7372,15 @@
  • },
  • __set:function (values, ignore) {
    • -
  • 1322 values = values || {};
    • -
  • 1322 this.__ignore = ignore === true;
    • -
  • 1322 Object.keys(values).forEach(function (attribute) {
    • +
  • 1320 values = values || {};
    • +
  • 1320 this.__ignore = ignore === true;
    • +
  • 1320 Object.keys(values).forEach(function (attribute) {
  • 5863 var value = values[attribute];
  • //check if the column is a constrained value and is allowed to be set
  • 5863 !ignore && this._checkIfColumnIsConstrained(attribute);
  • 5863 this[attribute] = value;
  • }, this);
    • -
  • 1322 this.__ignore = false;
    • +
  • 1320 this.__ignore = false;
  • },
  • __setFromDb:function (values, ignore) {
    • @@ -7635,7 +7635,7 @@
  • },
  • synced:function () {
    • -
  • 11255 return this._static.synced;
    • +
  • 11253 return this._static.synced;
  • }
  • }
    • @@ -9564,7 +9564,7 @@
  • * @param {String} message the message to show.
  • */
  • 1patio.QueryError = function(message) {
    • -
  • 122 return new Error("QueryError : " + message);
    • +
  • 118 return new Error("QueryError : " + message);
  • };
  • /**
    • @@ -9662,21 +9662,21 @@
  • 1var virtualRow = function (name) {
    • -
  • 882 var WILDCARD = new LiteralString('*');
    • -
  • 882 var QUESTION_MARK = new LiteralString('?');
    • -
  • 882 var COMMA_SEPARATOR = new LiteralString(', ');
    • -
  • 882 var DOUBLE_UNDERSCORE = '__';
    • -
    • -
  • 882 var parts = name.split(DOUBLE_UNDERSCORE);
    • -
  • 882 var table = parts[0], column = parts[1];
    • -
  • 882 var ident = column ? QualifiedIdentifier.fromArgs([table, column]) : Identifier.fromArgs([name]);
    • -
  • 882 var prox = methodMissing(ident, function (m) {
    • +
  • 876 var WILDCARD = new LiteralString('*');
    • +
  • 876 var QUESTION_MARK = new LiteralString('?');
    • +
  • 876 var COMMA_SEPARATOR = new LiteralString(', ');
    • +
  • 876 var DOUBLE_UNDERSCORE = '__';
    • +
    • +
  • 876 var parts = name.split(DOUBLE_UNDERSCORE);
    • +
  • 876 var table = parts[0], column = parts[1];
    • +
  • 876 var ident = column ? QualifiedIdentifier.fromArgs([table, column]) : Identifier.fromArgs([name]);
    • +
  • 876 var prox = methodMissing(ident, function (m) {
  • 3 return function () {
  • 3 var args = argsToArray(arguments);
  • 3 return SQLFunction.fromArgs([m, name].concat(args));
  • }
  • }, column ? QualifiedIdentifier : Identifier);
    • -
  • 882 var ret = createFunctionWrapper(prox, function (m) {
    • +
  • 876 var ret = createFunctionWrapper(prox, function (m) {
  • 484 var args = argsToArray(arguments);
  • 484 if (args.length) {
  • 478 return SQLFunction.fromArgs([name].concat(args));
    • @@ -9686,8 +9686,8 @@
  • }, function () {
  • 0 return SQLFunction.fromArgs(arguments);
  • });
    • -
  • 882 ret.__proto__ = ident;
    • -
  • 882 return ret;
    • +
  • 876 ret.__proto__ = ident;
    • +
  • 876 return ret;
  • };
  • 1var DATE_METHODS = ["getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds",
    • @@ -10042,8 +10042,8 @@
  • * @see patio.sql.identifier
  • */
  • stringToIdentifier:function (name) {
    • -
  • 10491 !Dataset && (Dataset = require("./dataset"));
    • -
  • 10491 return new Dataset().stringToIdentifier(name);
    • +
  • 10507 !Dataset && (Dataset = require("./dataset"));
    • +
  • 10507 return new Dataset().stringToIdentifier(name);
  • },
  • /**
    • @@ -10139,7 +10139,7 @@
  • });
  • 1exports.sql = methodMissing(sql, function (name) {
    • -
  • 882 return virtualRow(name);
    • +
  • 876 return virtualRow(name);
  • });
  • 1var OPERTATOR_INVERSIONS = {
    • @@ -10949,13 +10949,13 @@
  • * @return {patio.sql.Expression} an expression.
  • */
  • fromArgs:function (args) {
    • -
  • 1960 var ret;
    • -
  • 1960 try {
    • -
  • 1960 ret = new this();
    • +
  • 1958 var ret;
    • +
  • 1958 try {
    • +
  • 1958 ret = new this();
  • } catch (ignore) {
  • }
    • -
  • 1960 this.apply(ret, args);
    • -
  • 1960 return ret;
    • +
  • 1958 this.apply(ret, args);
    • +
  • 1958 return ret;
  • },
  • /**
    • @@ -10972,8 +10972,8 @@
  • * @return {Boolean} true if the object is a Hash or is an array of two element arrays.
  • */
  • isConditionSpecifier:function (obj) {
    • -
  • 19142 return isHash(obj) || (isArray(obj) && obj.length && obj.every(function (i) {
    • -
  • 7932 return isArray(i) && i.length === 2;
    • +
  • 19178 return isHash(obj) || (isArray(obj) && obj.length && obj.every(function (i) {
    • +
  • 7944 return isArray(i) && i.length === 2;
  • }));
  • }
  • }
    • @@ -11197,35 +11197,35 @@
  • * </p>
  • */
  • constructor:function (op) {
    • -
  • 6642 if (op) {
    • -
  • 6054 var args = argsToArray(arguments,1 );
    • +
  • 6658 if (op) {
    • +
  • 6066 var args = argsToArray(arguments,1 );
  • //make a copy of the args
    • -
  • 6054 var origArgs = args.slice(0);
    • -
  • 6054 args.forEach(function (a, i) {
    • -
  • 12280 if (Expression.isConditionSpecifier(a)) {
    • +
  • 6066 var origArgs = args.slice(0);
    • +
  • 6066 args.forEach(function (a, i) {
    • +
  • 12304 if (Expression.isConditionSpecifier(a)) {
  • 6 args[i] = BooleanExpression.fromValuePairs(a);
  • }
  • });
    • -
  • 6054 op = op.toUpperCase();
    • +
  • 6066 op = op.toUpperCase();
    • -
  • 6054 if (N_ARITY_OPERATORS.hasOwnProperty(op)) {
    • -
  • 953 if (args.length < 1) {
    • +
  • 6066 if (N_ARITY_OPERATORS.hasOwnProperty(op)) {
    • +
  • 957 if (args.length < 1) {
  • 0 throw new ExpressionError("The " + op + " operator requires at least 1 argument")
  • }
    • -
  • 953 var oldArgs = args.slice(0);
    • -
  • 953 args = [];
    • -
  • 953 oldArgs.forEach(function (a) {
    • -
  • 2141 a instanceof ComplexExpression && a.op == op ? args = args.concat(a.args) : args.push(a);
    • +
  • 957 var oldArgs = args.slice(0);
    • +
  • 957 args = [];
    • +
  • 957 oldArgs.forEach(function (a) {
    • +
  • 2149 a instanceof ComplexExpression && a.op == op ? args = args.concat(a.args) : args.push(a);
  • });
    • -
  • 5101 } else if (TWO_ARITY_OPERATORS.hasOwnProperty(op)) {
    • -
  • 5038 if (args.length != 2) {
    • +
  • 5109 } else if (TWO_ARITY_OPERATORS.hasOwnProperty(op)) {
    • +
  • 5046 if (args.length != 2) {
  • 0 throw new ExpressionError("The " + op + " operator requires precisely 2 arguments");
  • }
  • //With IN/NOT IN, even if the second argument is an array of two element arrays,
  • //don't convert it into a boolean expression, since it's definitely being used
  • //as a value list.
    • -
  • 5038 if (IN_OPERATORS[op]) {
    • +
  • 5046 if (IN_OPERATORS[op]) {
  • 23 args[1] = origArgs[1]
  • }
  • 63 } else if (ONE_ARITY_OPERATORS.hasOwnProperty(op)) {
    • @@ -11235,8 +11235,8 @@
  • } else {
  • 0 throw new ExpressionError("Invalid operator " + op);
  • }
    • -
  • 6054 this.op = op;
    • -
  • 6054 this.args = args;
    • +
  • 6066 this.op = op;
    • +
  • 6066 this.args = args;
  • }
  • },
    • @@ -11249,9 +11249,9 @@
  • * @return String the SQL version of the {@link patio.sql.ComplexExpression}.
  • */
  • toString:function (ds) {
    • -
  • 5673 !Dataset && (Dataset = require("./dataset"));
    • -
  • 5673 ds = ds || new Dataset();
    • -
  • 5673 return ds.complexExpressionSql(this.op, this.args);
    • +
  • 5685 !Dataset && (Dataset = require("./dataset"));
    • +
  • 5685 ds = ds || new Dataset();
    • +
  • 5685 return ds.complexExpressionSql(this.op, this.args);
  • }
  • },
    • @@ -11468,40 +11468,40 @@
  • * @return {patio.sql.BooleanExpression} expression composed of sub expressions built from the hash.
  • */
  • fromValuePairs:function (a, op, negate) {
    • -
  • 6758 !Dataset && (Dataset = require("./dataset"));
    • -
  • 6758 op = op || "AND", negate = negate || false;
    • -
  • 6758 var pairArr = [];
    • -
  • 6758 var isArr = isArray(a) && Expression.isConditionSpecifier(a);
    • -
  • 6758 if (isHash(a)) {
    • -
  • 3063 pairArr.push(this.__filterObject(a));
    • +
  • 6774 !Dataset && (Dataset = require("./dataset"));
    • +
  • 6774 op = op || "AND", negate = negate || false;
    • +
  • 6774 var pairArr = [];
    • +
  • 6774 var isArr = isArray(a) && Expression.isConditionSpecifier(a);
    • +
  • 6774 if (isHash(a)) {
    • +
  • 3071 pairArr.push(this.__filterObject(a));
  • } else {
    • -
  • 3695 for (var k in a) {
    • -
  • 4320 var v = isArr ? a[k][1] : a[k], ret;
    • -
  • 4320 k = isArr ? a[k][0] : k;
    • -
  • 4320 if (isArray(v) || isInstanceOf(v, Dataset)) {
    • +
  • 3703 for (var k in a) {
    • +
  • 4328 var v = isArr ? a[k][1] : a[k], ret;
    • +
  • 4328 k = isArr ? a[k][0] : k;
    • +
  • 4328 if (isArray(v) || isInstanceOf(v, Dataset)) {
  • 17 k = isArray(k) ? k.map(function (i) {
  • 12 return isString(i) ? sql.stringToIdentifier(i) : i
  • }) : isString(k) ? sql.stringToIdentifier(k) : k;
  • 17 ret = new BooleanExpression("IN", k, v);
    • -
  • 4303 } else if (isInstanceOf(v, NegativeBooleanConstant)) {
    • +
  • 4311 } else if (isInstanceOf(v, NegativeBooleanConstant)) {
  • 0 ret = new BooleanExpression("ISNOT", k, v.constant);
    • -
  • 4303 } else if (isInstanceOf(v, BooleanConstant)) {
    • +
  • 4311 } else if (isInstanceOf(v, BooleanConstant)) {
  • 0 ret = new BooleanExpression("IS", k, v.constant);
    • -
  • 4303 } else if (isNull(v) || isBoolean(v)) {
    • +
  • 4311 } else if (isNull(v) || isBoolean(v)) {
  • 180 ret = new BooleanExpression("IS", k, v);
    • -
  • 4123 } else if (isHash(v)) {
    • +
  • 4131 } else if (isHash(v)) {
  • 0 ret = BooleanExpression.__filterObject(v, k);
    • -
  • 4123 } else if (isRegExp(v)) {
    • +
  • 4131 } else if (isRegExp(v)) {
  • 61 ret = StringExpression.like(sql.stringToIdentifier(k), v);
  • } else {
    • -
  • 4062 ret = new BooleanExpression("EQ", sql.stringToIdentifier(k), v);
    • +
  • 4070 ret = new BooleanExpression("EQ", sql.stringToIdentifier(k), v);
  • }
    • -
  • 4320 negate && (ret = BooleanExpression.invert(ret));
    • -
  • 4320 pairArr.push(ret);
    • +
  • 4328 negate && (ret = BooleanExpression.invert(ret));
    • +
  • 4328 pairArr.push(ret);
  • }
  • }
  • //if We just have one then return the first otherwise create a new Boolean expression
    • -
  • 6758 return pairArr.length == 1 ? pairArr[0] : BooleanExpression.fromArgs([op].concat(pairArr));
    • +
  • 6774 return pairArr.length == 1 ? pairArr[0] : BooleanExpression.fromArgs([op].concat(pairArr));
  • },
  • /**
    • @@ -11526,13 +11526,13 @@
  • * @return {patio.sql.Expression} an expression to use in the filter
  • */
  • __filterObject:function (expr, key) {
    • -
  • 3172 var pairs = [], opts, newKey;
    • -
  • 3172 var twoArityOperators = this.TWO_ARITY_OPERATORS;
    • -
  • 3172 for (var k in expr) {
    • -
  • 3196 var v = expr[k];
    • -
  • 3196 if (isHash(v)) { //its a hash too filter it too!
    • +
  • 3180 var pairs = [], opts, newKey;
    • +
  • 3180 var twoArityOperators = this.TWO_ARITY_OPERATORS;
    • +
  • 3180 for (var k in expr) {
    • +
  • 3204 var v = expr[k];
    • +
  • 3204 if (isHash(v)) { //its a hash too filter it too!
  • 107 pairs.push(this.__filterObject(v, k));
    • -
  • 3089 } else if (key && (twoArityOperators[k.toUpperCase()] || k.match(/between/i))) {
    • +
  • 3097 } else if (key && (twoArityOperators[k.toUpperCase()] || k.match(/between/i))) {
  • //its a two arrity operator (e.g. '=', '>')
  • 110 newKey = isString(key) ? key.split(",") : [key];
  • 110 if (newKey.length > 1) {
    • @@ -11566,19 +11566,19 @@
  • } else {
  • //we're not a twoarity operator
  • //so we create a boolean expression out of it
    • -
  • 2979 newKey = k.split(",");
    • -
  • 2979 if (newKey.length == 1) {
    • -
  • 2973 newKey = sql.stringToIdentifier(newKey[0]);
    • +
  • 2987 newKey = k.split(",");
    • +
  • 2987 if (newKey.length == 1) {
    • +
  • 2981 newKey = sql.stringToIdentifier(newKey[0]);
  • }
    • -
  • 2979 opts = [
    • +
  • 2987 opts = [
  • [newKey, v]
  • ];
    • -
  • 2979 pairs.push(BooleanExpression.fromValuePairs(opts));
    • +
  • 2987 pairs.push(BooleanExpression.fromValuePairs(opts));
  • }
  • }
  • //if the total of pairs is one then we just return the first element
  • //otherwise we join them all with an AND
    • -
  • 3172 return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
    • +
  • 3180 return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
  • }
  • }
  • }).as(sql, "BooleanExpression");
    • @@ -11758,7 +11758,7 @@
  • * @property {String} value <b>READ ONLY</b> the column or table this identifier represents.
  • */
  • constructor:function (value) {
    • -
  • 14766 this.__value = value;
    • +
  • 14762 this.__value = value;
  • },
  • /**
    • @@ -11770,15 +11770,15 @@
  • * @return String the SQL version of the {@link patio.sql.Identifier}.
  • */
  • toString:function (ds) {
    • -
  • 19196 !Dataset && (Dataset = require("./dataset"));
    • -
  • 19196 ds = ds || new Dataset();
    • -
  • 19196 return ds.quoteIdentifier(this);
    • +
  • 19208 !Dataset && (Dataset = require("./dataset"));
    • +
  • 19208 ds = ds || new Dataset();
    • +
  • 19208 return ds.quoteIdentifier(this);
  • },
  • /**@ignore*/
  • getters:{
  • value:function () {
    • -
  • 22095 return this.__value;
    • +
  • 22107 return this.__value;
  • }
  • }
  • }
    • @@ -12335,7 +12335,7 @@
  • 1var addStringMethod = function (op) {
  • 24 return function () {
    • -
  • 3622 return this.__str[op].apply(this.__str, arguments);
    • +
  • 3626 return this.__str[op].apply(this.__str, arguments);
  • }
  • };
    • @@ -12358,7 +12358,7 @@
  • * @param {String} str the literal string.
  • */
  • constructor:function (str) {
    • -
  • 3075 this.__str = str;
    • +
  • 3057 this.__str = str;
  • }
  • }
  • }).as(sql, "LiteralString");
    • @@ -14086,9 +14086,9 @@
  • constructor:function () {
  • //We initialize these here because otherwise
  • //the will be blank because of recursive dependencies.
    • -
  • 25725 !patio && (patio = require("../index"));
    • -
  • 25725 !Dataset && (Dataset = patio.Dataset);
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 !patio && (patio = require("../index"));
    • +
  • 25745 !Dataset && (Dataset = patio.Dataset);
    • +
  • 25745 this._super(arguments);
  • },
  • /**
    • @@ -14373,15 +14373,15 @@
  • * @return {String} a literal representation of the value.
  • */
  • literal:function (v) {
    • -
  • 38459 if (isInstanceOf(v, LiteralString)) {
    • +
  • 38491 if (isInstanceOf(v, LiteralString)) {
  • 194 return "" + v;
    • -
  • 38265 } else if (isString(v)) {
    • +
  • 38297 } else if (isString(v)) {
  • 5397 return this._literalString(v);
    • -
  • 32868 } else if (isNumber(v)) {
    • -
  • 6152 return this._literalNumber(v);
    • +
  • 32900 } else if (isNumber(v)) {
    • +
  • 6160 return this._literalNumber(v);
  • }
    • -
  • 26716 else if (isInstanceOf(v, Expression)) {
    • -
  • 24443 return this._literalExpression(v);
    • +
  • 26740 else if (isInstanceOf(v, Expression)) {
    • +
  • 24467 return this._literalExpression(v);
  • }
  • 2273 else if (isInstanceOf(v, Dataset)) {
  • 104 return this._literalDataset(v);
    • @@ -14572,22 +14572,22 @@
  • //Prepares an SQL statement by calling all clause methods for the given statement type.
  • _clauseSql:function (type) {
    • -
  • 5793 var sql = [("" + type).toUpperCase()];
    • -
  • 5793 try {
    • -
  • 5793 this._static[sql + "_CLAUSE_METHODS"].forEach(function (m) {
    • -
  • 58246 if (m.match("With")) {
    • -
  • 5516 this[m](sql);
    • +
  • 5797 var sql = [("" + type).toUpperCase()];
    • +
  • 5797 try {
    • +
  • 5797 this._static[sql + "_CLAUSE_METHODS"].forEach(function (m) {
    • +
  • 58298 if (m.match("With")) {
    • +
  • 5520 this[m](sql);
  • } else {
    • -
  • 52730 var sqlRet = this[m]();
    • -
  • 52728 if (sqlRet) {
    • -
  • 18662 sql.push(sqlRet);
    • +
  • 52778 var sqlRet = this[m]();
    • +
  • 52776 if (sqlRet) {
    • +
  • 18674 sql.push(sqlRet);
  • }
  • }
  • }, this);
  • } catch (e) {
  • 2 throw e;
  • }
    • -
  • 5791 return sql.join("");
    • +
  • 5795 return sql.join("");
  • },
    • @@ -14701,9 +14701,9 @@
  • * SQL fragment for complex expressions
  • **/
  • complexExpressionSql:function (op, args) {
    • -
  • 5658 var newOp;
    • -
  • 5658 var isOperators = this._static.IS_OPERATORS, isLiterals = this._static.IS_LITERALS;
    • -
  • 5658 if ((newOp = isOperators[op]) != null) {
    • +
  • 5670 var newOp;
    • +
  • 5670 var isOperators = this._static.IS_OPERATORS, isLiterals = this._static.IS_LITERALS;
    • +
  • 5670 if ((newOp = isOperators[op]) != null) {
  • 232 var r = args[1], v = isNull(r) ? isLiterals.NULL : isLiterals[r];
  • 232 if (r == null || this.supportsIsTrue) {
  • 232 if (isUndefined(v)) {
    • @@ -14719,7 +14719,7 @@
  • null)]);
  • }
    • -
  • 5426 } else if (["IN", "NOTIN"].indexOf(op) != -1) {
    • +
  • 5438 } else if (["IN", "NOTIN"].indexOf(op) != -1) {
  • 17 var cols = args[0], vals = args[1], colArray = isArray(cols), valArray = false, emptyValArray = false;
  • 17 if (isArray(vals)) {
    • @@ -14765,12 +14765,12 @@
  • ComplexExpression.IN_OPERATORS[op], this.literal(vals));
  • }
  • }
    • -
  • 5409 } else if ((newOp = this._static.TWO_ARITY_OPERATORS[op]) != null) {
    • -
  • 4596 var l = args[0];
    • -
  • 4596 return format("(%s %s %s)", isString(l) ? l : this.literal(l), newOp,
    • +
  • 5421 } else if ((newOp = this._static.TWO_ARITY_OPERATORS[op]) != null) {
    • +
  • 4604 var l = args[0];
    • +
  • 4604 return format("(%s %s %s)", isString(l) ? l : this.literal(l), newOp,
  • this.literal(args[1]));
    • -
  • 813 } else if ((newOp = this._static.N_ARITY_OPERATORS[op]) != null) {
    • -
  • 779 return string.format("(%s)", args.map(this.literal, this).join(" " + newOp + " "));
    • +
  • 817 } else if ((newOp = this._static.N_ARITY_OPERATORS[op]) != null) {
    • +
  • 783 return string.format("(%s)", args.map(this.literal, this).join(" " + newOp + " "));
  • 34 } else if (op == "NOT") {
  • 5 return string.format("NOT %s", this.literal(args[0]));
  • 29 } else if (op == "NOOP") {
    • @@ -14899,18 +14899,18 @@
  • * quote the name with {@link patio.dataset._Sql#_quotedIdentifier}.
  • */
  • quoteIdentifier:function (name) {
    • -
  • 29064 if (isInstanceOf(name, LiteralString)) {
    • +
  • 29076 if (isInstanceOf(name, LiteralString)) {
  • 228 return name;
  • } else {
    • -
  • 28836 if (isInstanceOf(name, Identifier)) {
    • -
  • 19530 name = name.value;
    • +
  • 28848 if (isInstanceOf(name, Identifier)) {
    • +
  • 19542 name = name.value;
  • }
    • -
  • 28836 name = this.inputIdentifier(name);
    • -
  • 28836 if (this.quoteIdentifiers) {
    • +
  • 28848 name = this.inputIdentifier(name);
    • +
  • 28848 if (this.quoteIdentifiers) {
  • 21729 name = this._quotedIdentifier(name)
  • }
  • }
    • -
  • 28836 return name;
    • +
  • 28848 return name;
  • },
  • /**
    • @@ -14920,9 +14920,9 @@
  • * identifierOutputMethod.
  • */
  • inputIdentifier:function (v) {
    • -
  • 28970 var i = this.__identifierInputMethod;
    • -
  • 28970 v = v.toString(this);
    • -
  • 28970 return !isUndefinedOrNull(i) ?
    • +
  • 28982 var i = this.__identifierInputMethod;
    • +
  • 28982 v = v.toString(this);
    • +
  • 28982 return !isUndefinedOrNull(i) ?
  • isFunction(v[i]) ?
  • v[i]() :
  • isFunction(comb[i]) ?
    • @@ -15010,7 +15010,7 @@
  • * column names. If the array is empty, a wildcard (*) is returned.
  • */
  • __columnList:function (columns) {
    • -
  • 4776 return (!columns || columns.length == 0) ? this._static.WILDCARD : this.__expressionList(columns);
    • +
  • 4780 return (!columns || columns.length == 0) ? this._static.WILDCARD : this.__expressionList(columns);
  • },
  • /**
    • @@ -15094,11 +15094,11 @@
  • * @return SQL fragment for a number.
  • */
  • _literalNumber:function (num) {
    • -
  • 6152 var ret = "" + num;
    • -
  • 6152 if (isNaN(num) || num == Infinity) {
    • +
  • 6160 var ret = "" + num;
    • +
  • 6160 if (isNaN(num) || num == Infinity) {
  • 0 ret = string.format("'%s'", ret);
  • }
    • -
  • 6152 return ret;
    • +
  • 6160 return ret;
  • },
  • /**
    • @@ -15147,7 +15147,7 @@
  • * @return SQL fragment for SQL::Expression, result depends on the specific type of expression.
  • * */
  • _literalExpression:function (v) {
    • -
  • 24453 return v.toString(this);
    • +
  • 24477 return v.toString(this);
  • },
  • /**
    • @@ -15180,9 +15180,9 @@
  • /*SQL STATEMENT CREATION METHODS*/
  • _selectQualifySql:function () {
    • -
  • 4323 var o = this.__opts;
    • -
  • 4323 var table = this.__opts.alwaysQualify;
    • -
  • 4323 if (table && !o.sql) {
    • +
  • 4327 var o = this.__opts;
    • +
  • 4327 var table = this.__opts.alwaysQualify;
    • +
  • 4327 if (table && !o.sql) {
  • 2 array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
  • 2 o[k] = this._qualifiedExpression(o[k], table);
  • }, this);
    • @@ -15200,19 +15200,19 @@
  • * @return the columns selected
  • * */
  • _selectColumnsSql:function () {
    • -
  • 3588 return " " + this.__columnList(this.__opts.select);
    • +
  • 3592 return " " + this.__columnList(this.__opts.select);
  • },
  • /**@return the DISTINCT clause.*/
  • _selectDistinctSql:function () {
    • -
  • 3588 var distinct = this.__opts.distinct, ret = [];
    • -
  • 3588 if (distinct) {
    • +
  • 3592 var distinct = this.__opts.distinct, ret = [];
    • +
  • 3592 if (distinct) {
  • 10 ret.push(" DISTINCT");
  • 10 if (distinct.length) {
  • 4 ret.push(format(" ON (%s)", this.__expressionList(distinct)));
  • }
  • }
    • -
  • 3588 return ret.join("");
    • +
  • 3592 return ret.join("");
  • },
  • /**
    • @@ -15221,30 +15221,30 @@
  • * work on all databases.
  • **/
  • _selectCompoundsSql:function () {
    • -
  • 3588 var opts = this.__opts, compounds = opts.compounds, ret = [];
    • -
  • 3588 if (compounds) {
    • +
  • 3592 var opts = this.__opts, compounds = opts.compounds, ret = [];
    • +
  • 3592 if (compounds) {
  • 49 compounds.forEach(function (c) {
  • 49 var type = c[0], dataset = c[1], all = c[2];
  • 49 ret.push(string.format(" %s%s %s", type.toUpperCase(), all ? " ALL" : "", this._subselectSql(dataset)));
  • }, this);
  • }
    • -
  • 3588 return ret.join("");
    • +
  • 3592 return ret.join("");
  • },
  • /**
  • * @return the sql to add the list of tables to select FROM
  • **/
  • _selectFromSql:function () {
    • -
  • 3606 var from = this.__opts.from;
    • -
  • 3606 return from ? string.format(" %s%s", this._static.FROM, this._sourceList(from)) : "";
    • +
  • 3610 var from = this.__opts.from;
    • +
  • 3610 return from ? string.format(" %s%s", this._static.FROM, this._sourceList(from)) : "";
  • },
  • /**
  • * @return the GROUP BY clause
  • **/
  • _selectGroupSql:function () {
    • -
  • 3588 var group = this.__opts.group;
    • -
  • 3588 return group ? string.format(" GROUP BY %s", this.__expressionList(group)) : "";
    • +
  • 3592 var group = this.__opts.group;
    • +
  • 3592 return group ? string.format(" GROUP BY %s", this.__expressionList(group)) : "";
  • },
    • @@ -15252,62 +15252,62 @@
  • *@return the sql to add the filter criteria in the HAVING clause
  • **/
  • _selectHavingSql:function () {
    • -
  • 3588 var having = this.__opts.having;
    • -
  • 3588 return having ? string.format(" HAVING %s", this.literal(having)) : "";
    • +
  • 3592 var having = this.__opts.having;
    • +
  • 3592 return having ? string.format(" HAVING %s", this.literal(having)) : "";
  • },
  • /**
  • * @return the JOIN clause.
  • **/
  • _selectJoinSql:function () {
    • -
  • 3591 var join = this.__opts.join, ret = [];
    • -
  • 3591 if (join) {
    • +
  • 3595 var join = this.__opts.join, ret = [];
    • +
  • 3595 if (join) {
  • 467 join.forEach(function (j) {
  • 771 ret.push(this.literal(j));
  • }, this);
  • }
    • -
  • 3591 return ret.join("");
    • +
  • 3595 return ret.join("");
  • },
  • /**
  • * @return the LIMIT and OFFSET clauses.
  • * */
  • _selectLimitSql:function () {
    • -
  • 3588 var ret = [], limit = this.__opts.limit, offset = this.__opts.offset;
    • -
  • 3588 !isUndefined(limit) && !isNull(limit) && (ret.push(format(" LIMIT %s", this.literal(limit))));
    • -
  • 3588 !isUndefined(offset) && !isNull(offset) && (ret.push(format(" OFFSET %s", this.literal(offset))));
    • -
  • 3588 return ret.join("");
    • +
  • 3592 var ret = [], limit = this.__opts.limit, offset = this.__opts.offset;
    • +
  • 3592 !isUndefined(limit) && !isNull(limit) && (ret.push(format(" LIMIT %s", this.literal(limit))));
    • +
  • 3592 !isUndefined(offset) && !isNull(offset) && (ret.push(format(" OFFSET %s", this.literal(offset))));
    • +
  • 3592 return ret.join("");
  • },
  • /**
  • * @return SQL for different locking modes.
  • **/
  • _selectLockSql:function () {
    • -
  • 3587 var lock = this.__opts.lock, ret = [];
    • -
  • 3587 if (lock) {
    • +
  • 3591 var lock = this.__opts.lock, ret = [];
    • +
  • 3591 if (lock) {
  • 3 if (lock == "update") {
  • 2 ret.push(this._static.FOR_UPDATE);
  • } else {
  • 1 ret.push(" ", lock);
  • }
  • }
    • -
  • 3587 return ret.join("");
    • +
  • 3591 return ret.join("");
  • },
  • /**
  • * @return the SQL ORDER BY clause fragment.
  • */
  • _selectOrderSql:function () {
    • -
  • 3600 var order = this.__opts.order;
    • -
  • 3600 return order ? string.format(" ORDER BY %s", this.__expressionList(order)) : "";
    • +
  • 3604 var order = this.__opts.order;
    • +
  • 3604 return order ? string.format(" ORDER BY %s", this.__expressionList(order)) : "";
  • },
  • /**
  • * @return the SQL WHERE clause fragment.
  • */
  • _selectWhereSql:function () {
    • -
  • 4554 var where = this.__opts.where;
    • -
  • 4554 return where ? string.format(" WHERE %s", this.literal(where)) : "";
    • +
  • 4558 var where = this.__opts.where;
    • +
  • 4558 return where ? string.format(" WHERE %s", this.literal(where)) : "";
  • },
  • /**
    • @@ -15315,8 +15315,8 @@
  • * @param sql
  • */
  • _selectWithSql:function (sql) {
    • -
  • 5516 var wit = this.__opts["with"];
    • -
  • 5516 if (wit && wit.length) {
    • +
  • 5520 var wit = this.__opts["with"];
    • +
  • 5520 if (wit && wit.length) {
  • //sql.length = 0;
  • 8 var base = sql.join("");
  • 8 sql.length = 0;
    • @@ -15459,15 +15459,15 @@
  • * Converts an array of source names into into a comma separated list.
  • **/
  • _sourceList:function (source) {
    • -
  • 5814 if (!Array.isArray(source)) {
    • +
  • 5818 if (!Array.isArray(source)) {
  • 718 source = [source];
  • }
    • -
  • 5814 if (!source || !source.length) {
    • +
  • 5818 if (!source || !source.length) {
  • 0 throw new QueryError("No source specified for the query");
  • }
    • -
  • 5814 return " " + source.map(
    • +
  • 5818 return " " + source.map(
  • function (s) {
    • -
  • 5996 return this.__tableRef(s);
    • +
  • 6000 return this.__tableRef(s);
  • }, this).join(this._static.COMMA_SEPARATOR);
  • },
    • @@ -15492,7 +15492,7 @@
  • * @returns SQL fragment specifying a table name.
  • **/
  • __tableRef:function (t) {
    • -
  • 6767 return isString(t) ? this._quotedIdentifier(t) : this.literal(t);
    • +
  • 6771 return isString(t) ? this._quotedIdentifier(t) : this.literal(t);
  • },
    • @@ -15522,12 +15522,12 @@
  • getters:{
  • //Same as selectS, not aliased directly to make subclassing simpler.
  • sql:function () {
    • -
  • 648 return this.selectSql;
    • +
  • 652 return this.selectSql;
  • },
  • selectSql:function () {
    • -
  • 3690 if (this.__opts.sql) return this._staticSql(this.__opts.sql);
    • -
  • 3588 else return this._clauseSql("select");
    • +
  • 3694 if (this.__opts.sql) return this._staticSql(this.__opts.sql);
    • +
  • 3592 else return this._clauseSql("select");
  • },
  • deleteSql:function () {
    • @@ -15982,10 +15982,10 @@
  • /**@ignore*/
  • constructor:function () {
    • -
  • 25725 if (!Dataset) {
    • +
  • 25745 if (!Dataset) {
  • 1 Dataset = require("../index").Dataset;
  • }
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 this._super(arguments);
  • },
    • @@ -17202,10 +17202,10 @@
  • *
  • */
  • constructor:function () {
    • -
  • 2717 if (comb.isUndefinedOrNull(this.__associations)) {
    • -
  • 2629 this.__associations = {};
    • +
  • 2715 if (comb.isUndefinedOrNull(this.__associations)) {
    • +
  • 2628 this.__associations = {};
  • }
    • -
  • 2717 this._super(arguments);
    • +
  • 2715 this._super(arguments);
  • },
  • reload:function () {
    • @@ -17597,2865 +17597,2922 @@
  • }});
    • -
    +
    -
    dataset/query.js
    +
    plugins/validation.js
    - Coverage97.62 - SLOC2290 - LOC462 - Missed11 + Coverage97.66 + SLOC535 + LOC128 + Missed3
    - 
    1. 1var comb = require("comb"),
      2. 
+    
      1. 1var comb = require("comb"),
        2. 
 
      2.      array = comb.array,
        3. 
-
      3.      flatten = array.flatten,
        4. 
 
      4.      compact = array.compact,
        5. 
-
      5.      define = comb.define,
        6. 
-
      6.      argsToArray = comb.argsToArray,
        7. 
-
      7.      isString = comb.isString,
        8. 
-
      8.      isEmpty = comb.isEmpty,
        9. 
-
      9.      isNull = comb.isNull,
        10. 
-
      10.      isBoolean = comb.isBoolean,
        11. 
-
      11.      isNumber = comb.isNumber,
        12. 
-
      12.      merge = comb.merge,
        13. 
+
      13.      flatten = array.flatten,
        14. 
+
      14.      toArray = array.toArray,
        15. 
+
      15.      net = require("net"),
        16. 
+
      16.      isIP = net.isIP,
        17. 
+
      17.      isIPv4 = net.isIPv4,
        18. 
+
      18.      isIPv6 = net.isIPv6,
        19. 
+
      19.      validator = require("validator"),
        20. 
+
      20.      validatorCheck = validator.check,
        21. 
+
      21.      dateCmp = comb.date.compare,
        22. 
 
      22.      isArray = comb.isArray,
        23. 
-
      23.      isObject = comb.isObject,
        24. 
+
      24.      combDeepEqual = comb.deepEqual,
        25. 
+
      25.      combIsBoolean = comb.isBoolean,
        26. 
+
      26.      isString = comb.isString,
        27. 
+
      27.      combIsDefined = comb.isDefined,
        28. 
+
      28.      combIsNull = comb.isNull,
        29. 
+
      29.      ModelError = require("../errors.js").ModelError,
        30. 
 
      30.      isFunction = comb.isFunction,
        31. 
-
      31.      isUndefined = comb.isUndefined,
        32. 
-
      32.      isHash = comb.isHash,
        33. 
-
      33.      isInstanceOf = comb.isInstanceOf,
        34. 
-
      34.      sql = require("../sql").sql,
        35. 
-
      35.      LiteralString = sql.LiteralString,
        36. 
-
      36.      Expression = sql.Expression,
        37. 
-
      37.      ComplexExpression = sql.ComplexExpression,
        38. 
-
      38.      BooleanExpression = sql.BooleanExpression,
        39. 
-
      39.      PlaceHolderLiteralString = sql.PlaceHolderLiteralString,
        40. 
-
      40.      Identifier = sql.Identifier,
        41. 
-
      41.      QualifiedIdentifier = sql.QualifiedIdentifier,
        42. 
-
      42.      AliasedExpression = sql.AliasedExpression,
        43. 
-
      43.      StringExpression = sql.StringExpression,
        44. 
-
      44.      NumericExpression = sql.NumericExpression,
        45. 
-
      45.      OrderedExpression = sql.OrderedExpression,
        46. 
-
      46.      JoinClause = sql.JoinClause,
        47. 
-
      47.      JoinOnClause = sql.JoinOnClause,
        48. 
-
      48.      JoinUsingClause = sql.JoinUsingClause,
        49. 
-
      49.      ColumnAll = sql.ColumnAll,
        50. 
-
      50.      QueryError = require("../errors").QueryError;
        51. 
+
      51.      format = comb.string.format,
        52. 
+
      52.      Promise = comb.Promise,
        53. 
+
      53.      serial = comb.serial,
        54. 
+
      54.      when = comb.when,
        55. 
+
      55.      merge = comb.merge,
        56. 
+
      56.      define = comb.define;
        57. 
 
      57.  
        58. 
+
      58. 1var Validator = define(null, {
        59. 
+
      59.      instance:{
        60. 
 
      60.  
        61. 
-
      61. 1var Dataset;
        62. 
+
      62.          constructor:function validator(col) {
        63. 
+
      63. 44            this.col = col;
        64. 
+
      64. 44            this.__actions = [];
        65. 
+
      65.          },
        66. 
 
      66.  
        67. 
-
      67. 1function conditionedJoin(type) {
        68. 
-
      68. 539    var args = argsToArray(arguments, 1);
        69. 
-
      69. 539    return this.joinTable.apply(this, [type].concat(args));
        70. 
-
      70.  }
        71. 
+
      71.          __addAction:function __addAction(action, opts) {
        72. 
+
      72. 46            this.__actions.push({
        73. 
+
      73.                  action:action,
        74. 
+
      74.                  opts:merge({onlyDefined:true, onlyNotNull:false}, opts)
        75. 
+
      75.              });
        76. 
+
      76. 46            return this;
        77. 
+
      77.          },
        78. 
 
      78.  
        79. 
-
      79. 1function unConditionJoin(type, table) {
        80. 
-
      80. 6    var args = argsToArray(arguments, 1);
        81. 
-
      81. 6    return this.joinTable.apply(this, [type, table]);
        82. 
-
      82.  }
        83. 
+
      83.          isAfter:function (date, opts) {
        84. 
+
      84. 1            opts = opts || {};
        85. 
+
      85. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
        86. 
+
      86. 1            return this.__addAction(function (col) {
        87. 
+
      87. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") > 0;
        88. 
+
      88.              }, merge({message:"{col} must be after " + date + " got {val}."}, opts));
        89. 
+
      89.          },
        90. 
 
      90.  
        91. 
+
      91.          isBefore:function (date, opts) {
        92. 
+
      92. 1            opts = opts || {};
        93. 
+
      93. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
        94. 
+
      94. 1            return this.__addAction(function (col) {
        95. 
+
      95. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") === -1;
        96. 
+
      96.              }, merge({message:"{col} must be before " + date + " got {val}."}, opts));
        97. 
+
      97.          },
        98. 
 
      98.  
        99. 
-
      99. 1define(null, {
        100. 
-
      100.      /**@ignore*/
        101. 
-
      101.      instance: {
        102. 
+
      102.          isDefined:function isDefined(opts) {
        103. 
+
      103. 1            return this.__addAction(function (col) {
        104. 
+
      104. 3                return combIsDefined(col);
        105. 
+
      105.              }, merge({message:"{col} must be defined.", onlyDefined:false, onlyNotNull:false}, opts));
        106. 
+
      106.          },
        107. 
 
      107.  
        108. 
-
      108.          /**@lends patio.Dataset.prototype*/
        109. 
+
      109.          isNotDefined:function isNotDefined(opts) {
        110. 
+
      110. 1            return this.__addAction(function (col) {
        111. 
+
      111. 3                return !combIsDefined(col);
        112. 
+
      112.              }, merge({message:"{col} cannot be defined.", onlyDefined:false, onlyNotNull:false}, opts));
        113. 
+
      113.          },
        114. 
 
      114.  
        115. 
-
      115.          /**
        116. 
-
      116.           * @ignore
        117. 
-
      117.           */
        118. 
-
      118.          constructor: function () {
        119. 
-
      119. 25725            !Dataset && (Dataset = require("../index").Dataset);
        120. 
-
      120. 25725            this._super(arguments);
        121. 
-
      121. 25725            this._static.CONDITIONED_JOIN_TYPES.forEach(function (type) {
        122. 
-
      122. 180075                if (!this[type + "Join"]) {
        123. 
-
      123. 180075                    this[type + "Join"] = conditionedJoin.bind(this, type);
        124. 
-
      124.                  }
        125. 
+
      125.          isNotNull:function isNotNull(opts) {
        126. 
+
      126. 3            return this.__addAction(function (col) {
        127. 
+
      127. 21                return combIsDefined(col) && !combIsNull(col);
        128. 
+
      128.              }, merge({message:"{col} cannot be null.", onlyDefined:false, onlyNotNull:false}, opts));
        129. 
+
      129.          },
        130. 
 
      130.  
        131. 
-
      131.              }, this);
        132. 
-
      132. 25725            this._static.UNCONDITIONED_JOIN_TYPES.forEach(function (type) {
        133. 
-
      133. 128625                if (!this[type + "Join"]) {
        134. 
-
      134. 128625                    this[type + "Join"] = unConditionJoin.bind(this, type);
        135. 
-
      135.                  }
        136. 
+
      136.          isNull:function isNull(opts) {
        137. 
+
      137. 1            return this.__addAction(function (col) {
        138. 
+
      138. 3                return !combIsDefined(col) || combIsNull(col);
        139. 
+
      139.              }, merge({message:"{col} must be null got {val}.", onlyDefined:false, onlyNotNull:false}, opts));
        140. 
+
      140.          },
        141. 
 
      141.  
        142. 
-
      142.              }, this);
        143. 
+
      143.          isEq:function eq(val, opts) {
        144. 
+
      144. 4            return this.__addAction(function (col) {
        145. 
+
      145. 15                return combDeepEqual(col, val);
        146. 
+
      146.              }, merge({message:"{col} must === " + val + " got {val}."}, opts));
        147. 
 
      147.          },
        148. 
 
      148.  
        149. 
-
      149.          /**
        150. 
-
      150.           * Adds a RETURNING clause, which is not supported by all databases. If returning is
        151. 
-
      151.           * used instead of returning the autogenerated primary key or update/delete returning the number of rows modified.
        152. 
-
      152.           *
        153. 
-
      153.           * @example
        154. 
-
      154.           *
        155. 
-
      155.           * ds.from("items").returning() //"RETURNING *"
        156. 
-
      156.           * ds.from("items").returning(null) //"RETURNING NULL"
        157. 
-
      157.           * ds.from("items").returning("id", "name") //"RETURNING id, name"
        158. 
-
      158.           * ds.from("items").returning(["id", "name"]) //"RETURNING id, name"
        159. 
-
      159.           *
        160. 
-
      160.           * @param values columns to return. If values is an array then the array is assumed to contain the columns to
        161. 
-
      161.           * return. Otherwise the arguments will be used.
        162. 
-
      162.           * @return {patio.Dataset} a new dataset with the retuning option added.
        163. 
-
      163.           */
        164. 
-
      164.          returning: function (values) {
        165. 
-
      165. 1087            var args;
        166. 
-
      166. 1087            if (Array.isArray(values)) {
        167. 
-
      167. 0                args = values;
        168. 
-
      168.              } else {
        169. 
-
      169. 1087                args = argsToArray(arguments);
        170. 
-
      170.              }
        171. 
-
      171. 1087            return this.mergeOptions({returning: args.map(function (v) {
        172. 
-
      172. 1005                return isString(v) ? sql.stringToIdentifier(v) : v;
        173. 
-
      173.              })});
        174. 
+
      174.          isNeq:function neq(val, opts) {
        175. 
+
      175. 2            return this.__addAction(function (col) {
        176. 
+
      176. 8                return !combDeepEqual(col, val);
        177. 
+
      177.              }, merge({message:"{col} must !== " + val + "."}, opts));
        178. 
 
      178.          },
        179. 
 
      179.  
        180. 
+
      180.          isLike:function like(val, opts) {
        181. 
+
      181. 3            return this.__addAction(function (col) {
        182. 
+
      182. 14                return !!col.match(val);
        183. 
+
      183.              }, merge({message:"{col} must be like " + val + " got {val}."}, opts));
        184. 
+
      184.          },
        185. 
 
      185.  
        186. 
-
      186.          /**
        187. 
-
      187.           * Adds a futher filter to an existing filter using AND. This method is identical to {@link patio.Dataset#filter}
        188. 
-
      188.           * except it expects an existing filter.
        189. 
-
      189.           *
        190. 
-
      190.           * <p>
        191. 
-
      191.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        192. 
-
      192.           * </p>
        193. 
-
      193.           *
        194. 
-
      194.           * @example
        195. 
-
      195.           * DB.from("table").filter("a").and("b").sql;
        196. 
-
      196.           *      //=>SELECT * FROM table WHERE a AND b
        197. 
-
      197.           *
        198. 
-
      198.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        199. 
-
      199.           *
        200. 
-
      200.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
        201. 
-
      201.           */
        202. 
-
      202.          and: function () {
        203. 
-
      203. 7            var tOpts = this.__opts, clauseObj = tOpts[tOpts.having ? "having" : "where"];
        204. 
-
      204. 7            if (clauseObj) {
        205. 
-
      205. 6                return this.filter.apply(this, arguments);
        206. 
-
      206.              } else {
        207. 
-
      207. 1                throw new QueryError("No existing filter found");
        208. 
-
      208.              }
        209. 
+
      209.          isNotLike:function notLike(val, opts) {
        210. 
+
      210. 2            return this.__addAction(function (col) {
        211. 
+
      211. 6                return !(!!col.match(val));
        212. 
+
      212.              }, merge({message:"{col} must not be like " + val + "."}, opts));
        213. 
 
      213.          },
        214. 
 
      214.  
        215. 
-
      215.          as: function (alias) {
        216. 
-
      216. 8            return new AliasedExpression(this, alias);
        217. 
+
      217.          isLt:function lt(num, opts) {
        218. 
+
      218. 1            return this.__addAction(function (col) {
        219. 
+
      219. 3                return col < num;
        220. 
+
      220.              }, merge({message:"{col} must be < " + num + " got {val}."}, opts));
        221. 
 
      221.          },
        222. 
 
      222.  
        223. 
-
      223.          /**
        224. 
-
      224.           * Adds an alternate filter to an existing WHERE/HAVING using OR.
        225. 
-
      225.           *
        226. 
-
      226.           * <p>
        227. 
-
      227.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        228. 
-
      228.           * </p>
        229. 
-
      229.           *
        230. 
-
      230.           * @example
        231. 
-
      231.           *
        232. 
-
      232.           * DB.from("items").filter("a").or("b")
        233. 
-
      233.           *      //=> SELECT * FROM items WHERE a OR b
        234. 
-
      234.           *
        235. 
-
      235.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        236. 
-
      236.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
        237. 
-
      237.           */
        238. 
-
      238.          or: function () {
        239. 
-
      239. 12            var tOpts = this.__opts;
        240. 
-
      240. 12            var clause = (tOpts.having ? "having" : "where"), clauseObj = tOpts[clause];
        241. 
-
      241. 12            if (clauseObj) {
        242. 
-
      242. 9                var args = argsToArray(arguments);
        243. 
-
      243. 9                args = args.length == 1 ? args[0] : args;
        244. 
-
      244. 9                var opts = {};
        245. 
-
      245. 9                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args));
        246. 
-
      246. 9                return this.mergeOptions(opts);
        247. 
-
      247.              } else {
        248. 
-
      248. 3                throw new QueryError("No existing filter found");
        249. 
+
      249.          isGt:function gt(num, opts) {
        250. 
+
      250. 1            return this.__addAction(function (col) {
        251. 
+
      251. 3                return col > num;
        252. 
+
      252.              }, merge({message:"{col} must be > " + num + " got {val}."}, opts));
        253. 
+
      253.          },
        254. 
+
      254.  
        255. 
+
      255.          isLte:function lte(num, opts) {
        256. 
+
      256. 1            return this.__addAction(function (col) {
        257. 
+
      257. 3                return col <= num;
        258. 
+
      258.              }, merge({message:"{col} must be <= " + num + " got {val}."}, opts));
        259. 
+
      259.          },
        260. 
+
      260.  
        261. 
+
      261.          isGte:function gte(num, opts) {
        262. 
+
      262. 1            return this.__addAction(function (col) {
        263. 
+
      263. 3                return col >= num;
        264. 
+
      264.              }, merge({message:"{col} must be >= " + num + " got {val}."}, opts));
        265. 
+
      265.          },
        266. 
+
      266.  
        267. 
+
      267.          isIn:function isIn(arr, opts) {
        268. 
+
      268. 2            if (!isArray(arr)) {
        269. 
+
      269. 1                throw new Error("isIn requires an array of values");
        270. 
 
      270.              }
        271. 
+
      271. 1            return this.__addAction(function (col) {
        272. 
+
      272. 3                return arr.indexOf(col) !== -1;
        273. 
+
      273.              }, merge({message:"{col} must be in " + arr.join(",") + " got {val}."}, opts));
        274. 
 
      274.          },
        275. 
 
      275.  
        276. 
-
      276.          /**
        277. 
-
      277.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        278. 
-
      278.           *
        279. 
-
      279.           * <p>
        280. 
-
      280.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        281. 
-
      281.           * </p>
        282. 
-
      282.           *
        283. 
-
      283.           * @example
        284. 
-
      284.           *
        285. 
-
      285.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        286. 
-
      286.           *      //=> SELECT
        287. 
-
      287.           *               *
        288. 
-
      288.           *           FROM
        289. 
-
      289.           *               items
        290. 
-
      290.           *           WHERE
        291. 
-
      291.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        292. 
-
      292.           *
        293. 
-
      293.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        294. 
-
      294.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        295. 
-
      295.           */
        296. 
-
      296.          andGroupedOr: function () {
        297. 
-
      297. 2            var tOpts = this.__opts,
        298. 
-
      298.                  clause = (tOpts.having ? "having" : "where"),
        299. 
-
      299.                  clauseObj = tOpts[clause];
        300. 
-
      300. 2            if (clauseObj) {
        301. 
-
      301. 1                var args = argsToArray(arguments);
        302. 
-
      302. 1                args = args.length == 1 ? args[0] : args;
        303. 
-
      303. 1                var opts = {};
        304. 
-
      304. 1                opts[clause] = new BooleanExpression("AND", clauseObj, this._filterExpr(args, null, "OR"));
        305. 
-
      305. 1                return this.mergeOptions(opts);
        306. 
-
      306.              } else {
        307. 
-
      307. 1                throw new QueryError("No existing filter found");
        308. 
-
      308.              }
        309. 
-
      309.          },
        310. 
-
      310.  
        311. 
-
      311.          /**
        312. 
-
      312.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        313. 
-
      313.           *
        314. 
-
      314.           * <p>
        315. 
-
      315.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        316. 
-
      316.           * </p>
        317. 
-
      317.           *
        318. 
-
      318.           * @example
        319. 
-
      319.           *
        320. 
-
      320.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        321. 
-
      321.           *      //=> SELECT
        322. 
-
      322.           *               *
        323. 
-
      323.           *           FROM
        324. 
-
      324.           *               items
        325. 
-
      325.           *           WHERE
        326. 
-
      326.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        327. 
-
      327.           *
        328. 
-
      328.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        329. 
-
      329.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        330. 
-
      330.           */
        331. 
-
      331.          andGroupedAnd: function () {
        332. 
-
      332. 2            var tOpts = this.__opts,
        333. 
-
      333.                  clause = (tOpts.having ? "having" : "where"),
        334. 
-
      334.                  clauseObj = tOpts[clause];
        335. 
-
      335. 2            if (clauseObj) {
        336. 
-
      336. 1                var args = argsToArray(arguments);
        337. 
-
      337. 1                args = args.length == 1 ? args[0] : args;
        338. 
-
      338. 1                var opts = {};
        339. 
-
      339. 1                opts[clause] = new BooleanExpression("AND", clauseObj, this._filterExpr(args, null, "AND"));
        340. 
-
      340. 1                return this.mergeOptions(opts);
        341. 
-
      341.              } else {
        342. 
-
      342. 1                throw new QueryError("No existing filter found");
        343. 
-
      343.              }
        344. 
-
      344.          },
        345. 
-
      345.  
        346. 
-
      346.          /**
        347. 
-
      347.           * Adds to the where/having clause with an OR a group of ANDed conditions wrapped in parens
        348. 
-
      348.           *
        349. 
-
      349.           * <p>
        350. 
-
      350.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        351. 
-
      351.           * </p>
        352. 
-
      352.           *
        353. 
-
      353.           * @example
        354. 
-
      354.           *
        355. 
-
      355.           * DB.from("items").filter({id, [1,2,3]}).orGroupedAnd([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        356. 
-
      356.           *      //=> SELECT
        357. 
-
      357.           *               *
        358. 
-
      358.           *           FROM
        359. 
-
      359.           *               items
        360. 
-
      360.           *           WHERE
        361. 
-
      361.           *               ((id IN (1, 2, 3)) OR ((price > 0) AND (price < 10)))
        362. 
-
      362.           *
        363. 
-
      363.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        364. 
-
      364.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
        365. 
-
      365.           */
        366. 
-
      366.          orGroupedAnd: function () {
        367. 
-
      367. 3            return this.or.apply(this, arguments);
        368. 
-
      368.          },
        369. 
-
      369.  
        370. 
-
      370.          /**
        371. 
-
      371.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        372. 
-
      372.           *
        373. 
-
      373.           * <p>
        374. 
-
      374.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        375. 
-
      375.           * </p>
        376. 
-
      376.           *
        377. 
-
      377.           * @example
        378. 
-
      378.           *
        379. 
-
      379.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        380. 
-
      380.           *      //=> SELECT
        381. 
-
      381.           *               *
        382. 
-
      382.           *           FROM
        383. 
-
      383.           *               items
        384. 
-
      384.           *           WHERE
        385. 
-
      385.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        386. 
-
      386.           *
        387. 
-
      387.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        388. 
-
      388.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        389. 
-
      389.           */
        390. 
-
      390.          orGroupedOr: function () {
        391. 
-
      391. 1            var tOpts = this.__opts,
        392. 
-
      392.                  clause = (tOpts.having ? "having" : "where"),
        393. 
-
      393.                  clauseObj = tOpts[clause];
        394. 
-
      394. 1            if (clauseObj) {
        395. 
-
      395. 1                var args = argsToArray(arguments);
        396. 
-
      396. 1                args = args.length == 1 ? args[0] : args;
        397. 
-
      397. 1                var opts = {};
        398. 
-
      398. 1                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args, null, "OR"));
        399. 
-
      399. 1                return this.mergeOptions(opts);
        400. 
-
      400.              } else {
        401. 
-
      401. 0                throw new QueryError("No existing filter found");
        402. 
-
      402.              }
        403. 
-
      403.          },
        404. 
-
      404.  
        405. 
-
      405.          /**
        406. 
-
      406.           * Returns a copy of the dataset with the SQL DISTINCT clause.
        407. 
-
      407.           * The DISTINCT clause is used to remove duplicate rows from the
        408. 
-
      408.           * output.  If arguments are provided, uses a DISTINCT ON clause,
        409. 
-
      409.           * in which case it will only be distinct on those columns, instead
        410. 
-
      410.           * of all returned columns.
        411. 
-
      411.           *
        412. 
-
      412.           * @example
        413. 
-
      413.           *
        414. 
-
      414.           * DB.from("items").distinct().sqll
        415. 
-
      415.           *      //=> SELECT DISTINCT * FROM items
        416. 
-
      416.           * DB.from("items").order("id").distinct("id").sql;
        417. 
-
      417.           *      //=> SELECT DISTINCT ON (id) * FROM items ORDER BY id
        418. 
-
      418.           *
        419. 
-
      419.           * @throws {patio.QueryError}  If arguments are given and DISTINCT ON is not supported.
        420. 
-
      420.           * @param {...String|...patio.sql.Identifier} args variable number of arguments used to create
        421. 
-
      421.           *                                                 the DISTINCT ON clause.
        422. 
-
      422.           * @return {patio.Dataset} a cloned dataset with the DISTINCT/DISTINCT ON clause added.
        423. 
-
      423.           */
        424. 
-
      424.          distinct: function (args) {
        425. 
-
      425. 13            args = argsToArray(arguments);
        426. 
-
      426. 13            if (args.length && !this.supportsDistinctOn) {
        427. 
-
      427. 1                throw new QueryError("DISTICT ON is not supported");
        428. 
-
      428.              }
        429. 
-
      429. 12            args = args.map(function (a) {
        430. 
-
      430. 6                return isString(a) ? new Identifier(a) : a;
        431. 
-
      431.              });
        432. 
-
      432. 12            return this.mergeOptions({distinct: args});
        433. 
-
      433.          },
        434. 
-
      434.  
        435. 
-
      435.          /**
        436. 
-
      436.           * Adds an EXCEPT clause using a second dataset object.
        437. 
-
      437.           * An EXCEPT compound dataset returns all rows in the current dataset
        438. 
-
      438.           * that are not in the given dataset.
        439. 
-
      439.           *
        440. 
-
      440.           * @example
        441. 
-
      441.           *
        442. 
-
      442.           * DB.from("items").except(DB.from("other_items")).sql;
        443. 
-
      443.           *      //=> SELECT * FROM items EXCEPT SELECT * FROM other_items
        444. 
-
      444.           *
        445. 
-
      445.           * DB.from("items").except(DB.from("other_items"),
        446. 
-
      446.           *                        {all : true, fromSelf : false}).sql;
        447. 
-
      447.           *      //=> SELECT * FROM items EXCEPT ALL SELECT * FROM other_items
        448. 
-
      448.           *
        449. 
-
      449.           * DB.from("items").except(DB.from("other_items"),
        450. 
-
      450.           *                        {alias : "i"}).sql;
        451. 
-
      451.           *      //=>SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS i
        452. 
-
      452.           *
        453. 
-
      453.           * @throws {patio.QueryError} if the operation is not supported.
        454. 
-
      454.           * @param {patio.Dataset} dataset the dataset to use to create the EXCEPT clause.
        455. 
-
      455.           * @param {Object} [opts] options to use when creating the EXCEPT clause
        456. 
-
      456.           * @param {String|patio.sql.Identifier} [opt.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias.
        457. 
-
      457.           * @param {Boolean} [opts.all] Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
        458. 
-
      458.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}, use with care.
        459. 
-
      459.           *
        460. 
-
      460.           * @return {patio.Dataset} a cloned dataset with the EXCEPT clause added.
        461. 
-
      461.           */
        462. 
-
      462.          except: function (dataset, opts) {
        463. 
-
      463. 18            opts = isUndefined(opts) ? {} : opts;
        464. 
-
      464. 18            if (!isHash(opts)) {
        465. 
-
      465. 5                opts = {all: true};
        466. 
-
      466.              }
        467. 
-
      467. 18            if (!this.supportsIntersectExcept) {
        468. 
-
      468. 2                throw new QueryError("EXCEPT not supoorted");
        469. 
-
      469. 16            } else if (opts.hasOwnProperty("all") && !this.supportsIntersectExceptAll) {
        470. 
-
      470. 1                throw new QueryError("EXCEPT ALL not supported");
        471. 
+
      471.          isNotIn:function notIn(arr, opts) {
        472. 
+
      472. 2            if (!isArray(arr)) {
        473. 
+
      473. 1                throw new Error("notIn requires an array of values");
        474. 
 
      474.              }
        475. 
-
      475. 15            return this.compoundClone("except", dataset, opts);
        476. 
+
      476. 1            return this.__addAction(function (col) {
        477. 
+
      477. 3                return arr.indexOf(col) === -1;
        478. 
+
      478.              }, merge({message:"{col} cannot be in " + arr.join(",") + " got {val}."}, opts));
        479. 
 
      479.          },
        480. 
 
      480.  
        481. 
-
      481.          /**
        482. 
-
      482.           * Performs the inverse of {@link patio.Dataset#filter}.  Note that if you have multiple filter
        483. 
-
      483.           * conditions, this is not the same as a negation of all conditions. For argument types see
        484. 
-
      484.           * {@link patio.Dataset#filter}
        485. 
-
      485.           *
        486. 
-
      486.           * @example
        487. 
-
      487.           *
        488. 
-
      488.           * DB.from("items").exclude({category : "software").sql;
        489. 
-
      489.           *      //=> SELECT * FROM items WHERE (category != 'software')
        490. 
-
      490.           *
        491. 
-
      491.           * DB.from("items").exclude({category : 'software', id : 3}).sql;
        492. 
-
      492.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
        493. 
-
      493.           * @return {patio.Dataset} a cloned dataset with the excluded conditions applied to the HAVING/WHERE clause.
        494. 
-
      494.           */
        495. 
-
      495.          exclude: function () {
        496. 
-
      496. 69            var cond = argsToArray(arguments), tOpts = this.__opts;
        497. 
-
      497. 69            var clause = (tOpts["having"] ? "having" : "where"), clauseObj = tOpts[clause];
        498. 
-
      498. 69            cond = cond.length > 1 ? cond : cond[0];
        499. 
-
      499. 69            cond = this._filterExpr.call(this, cond);
        500. 
-
      500. 69            cond = BooleanExpression.invert(cond);
        501. 
-
      501. 69            if (clauseObj) {
        502. 
-
      502. 58                cond = new BooleanExpression("AND", clauseObj, cond)
        503. 
-
      503.              }
        504. 
-
      504. 69            var opts = {};
        505. 
-
      505. 69            opts[clause] = cond;
        506. 
-
      506. 69            return this.mergeOptions(opts);
        507. 
+
      507.          isMacAddress:function isMaxAddress(opts) {
        508. 
+
      508. 1            return this.__addAction(function (col) {
        509. 
+
      509. 4                return !!col.match(/^([0-9A-F]{2}[:\-]){5}([0-9A-F]{2})$/);
        510. 
+
      510.              }, merge({message:"{col} must be a valid MAC address got {val}."}, opts));
        511. 
 
      511.          },
        512. 
 
      512.  
        513. 
-
      513.          /**
        514. 
-
      514.           * Returns a copy of the dataset with the given conditions applied to it.
        515. 
-
      515.           * If the query already has a HAVING clause, then the conditions are applied to the
        516. 
-
      516.           * HAVING clause otherwise they are applied to the WHERE clause.
        517. 
-
      517.           *
        518. 
-
      518.           * @example
        519. 
-
      519.           *
        520. 
-
      520.           * DB.from("items").filter({id : 3}).sql;
        521. 
-
      521.           *      //=> SELECT * FROM items WHERE (id = 3)
        522. 
-
      522.           *
        523. 
-
      523.           * DB.from("items").filter('price < ?', 100)
        524. 
-
      524.           *      //=> SELECT * FROM items WHERE price < 100
        525. 
-
      525.           *
        526. 
-
      526.           * DB.from("items").filter({id, [1,2,3]}).filter({id : {between : [0, 10]}}).sql;
        527. 
-
      527.           *      //=> SELECT
        528. 
-
      528.           *               *
        529. 
-
      529.           *           FROM
        530. 
-
      530.           *               items
        531. 
-
      531.           *           WHERE
        532. 
-
      532.           *               ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))
        533. 
-
      533.           *
        534. 
-
      534.           * DB.from("items").filter('price < 100');
        535. 
-
      535.           *      //=> SELECT * FROM items WHERE price < 100
        536. 
-
      536.           *
        537. 
-
      537.           * DB.from("items").filter("active").sql;
        538. 
-
      538.           *      //=> SELECT * FROM items WHERE active
        539. 
-
      539.           *
        540. 
-
      540.           * DB.from("items").filter(function(){
        541. 
-
      541.           *      return this.price.lt(100);
        542. 
-
      542.           * });
        543. 
-
      543.           *      //=> SELECT * FROM items WHERE (price < 100)
        544. 
-
      544.           *
        545. 
-
      545.           * //Multiple filter calls can be chained for scoping:
        546. 
-
      546.           * DB.from("items").filter(:category => 'software').filter{price < 100}
        547. 
-
      547.           *      //=> SELECT * FROM items WHERE ((category = 'software') AND (price < 100))
        548. 
-
      548.           *
        549. 
-
      549.           *
        550. 
-
      550.           * @param {Object|Array|String|patio.sql.Identifier|patio.sql.BooleanExpression} args filters to apply to the
        551. 
-
      551.           *  WHERE/HAVING clause. Description of each:
        552. 
-
      552.           *  <ul>
        553. 
-
      553.           *      <li>Hash - list of equality/inclusion expressions</li>
        554. 
-
      554.           *      <li>Array - depends:
        555. 
-
      555.           *          <ul>
        556. 
-
      556.           *              <li>If first member is a string, assumes the rest of the arguments
        557. 
-
      557.           *                  are parameters and interpolates them into the string.</li>
        558. 
-
      558.           *              <li>If all members are arrays of length two, treats the same way
        559. 
-
      559.           *                  as a hash, except it allows for duplicate keys to be
        560. 
-
      560.           *                  specified.</li>
        561. 
-
      561.           *              <li>Otherwise, treats each argument as a separate condition.</li>
        562. 
-
      562.           *           </ul>
        563. 
-
      563.           *       </li>
        564. 
-
      564.           *      <li>String - taken literally</li>
        565. 
-
      565.           *      <li>{@link patio.sql.Identifier} - taken as a boolean column argument (e.g. WHERE active)</li>
        566. 
-
      566.           *      <li>{@link patio.sql.BooleanExpression} - an existing condition expression,
        567. 
-
      567.           *          probably created using the patio.sql methods.
        568. 
-
      568.           *       </li>
        569. 
-
      569.           *
        570. 
-
      570.           * @param {Function} [cb] filter also takes a cb, which should return one of the above argument
        571. 
-
      571.           * types, and is treated the same way.  This block is called with an {@link patio.sql} object which can be used to dynaically create expression.  For more details
        572. 
-
      572.           * on the sql object see {@link patio.sql}
        573. 
-
      573.           *
        574. 
-
      574.           * <p>
        575. 
-
      575.           *     <b>NOTE:</b>If both a cb and regular arguments are provided, they get ANDed together.
        576. 
-
      576.           * </p>
        577. 
-
      577.           *
        578. 
-
      578.           * @return {patio.Dataset} a cloned dataset with the filter arumgents applied to the WHERE/HAVING clause.
        579. 
-
      579.           **/
        580. 
-
      580.          filter: function (args, cb) {
        581. 
-
      581. 3468            args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
        582. 
-
      582. 3468            return this._filter.apply(this, args);
        583. 
+
      583.          isIPAddress:function isIpAddress(opts) {
        584. 
+
      584. 1            return this.__addAction(function (col) {
        585. 
+
      585. 4                return !!isIP(col);
        586. 
+
      586.              }, merge({message:"{col} must be a valid IPv4 or IPv6 address got {val}."}, opts));
        587. 
 
      587.          },
        588. 
 
      588.  
        589. 
-
      589.          /**
        590. 
-
      590.           * @see patio.Dataset#filter
        591. 
-
      591.           */
        592. 
-
      592.          find: function () {
        593. 
-
      593. 30            var args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
        594. 
-
      594. 30            return this._filter.apply(this, args);
        595. 
+
      595.          isIPv4Address:function isIpAddress(opts) {
        596. 
+
      596. 1            return this.__addAction(function (col) {
        597. 
+
      597. 3                return isIPv4(col);
        598. 
+
      598.              }, merge({message:"{col} must be a valid IPv4 address got {val}."}, opts));
        599. 
 
      599.          },
        600. 
 
      600.  
        601. 
-
      601.          /**
        602. 
-
      602.           * @example
        603. 
-
      603.           * DB.from("table").forUpdate()
        604. 
-
      604.           *          //=> SELECT * FROM table FOR UPDATE
        605. 
-
      605.           * @return {patio.Dataset} a cloned dataset with a "update" lock style.
        606. 
-
      606.           */
        607. 
-
      607.          forUpdate: function () {
        608. 
-
      608. 1            return this.lockStyle("update");
        609. 
+
      609.          isIPv6Address:function isIpAddress(opts) {
        610. 
+
      610. 1            return this.__addAction(function (col) {
        611. 
+
      611. 3                return isIPv6(col);
        612. 
+
      612.              }, merge({message:"{col} must be a valid IPv6 address got {val}."}, opts));
        613. 
 
      613.          },
        614. 
 
      614.  
        615. 
-
      615.          /**
        616. 
-
      616.           * Returns a copy of the dataset with the source changed. If no
        617. 
-
      617.           * source is given, removes all tables.  If multiple sources
        618. 
-
      618.           * are given, it is the same as using a CROSS JOIN (cartesian product) between all tables.
        619. 
-
      619.           *
        620. 
-
      620.           * @example
        621. 
-
      621.           * var dataset = DB.from("items");
        622. 
-
      622.           *
        623. 
-
      623.           * dataset.from().sql;
        624. 
-
      624.           *      //=> SELECT *
        625. 
-
      625.           *
        626. 
-
      626.           * dataset.from("blah").sql
        627. 
-
      627.           *      //=> SELECT * FROM blah
        628. 
-
      628.           *
        629. 
-
      629.           * dataset.from("blah", "foo")
        630. 
-
      630.           *      //=> SELECT * FROM blah, foo
        631. 
-
      631.           *
        632. 
-
      632.           * dataset.from({a:"b"}).sql;
        633. 
-
      633.           *      //=> SELECT * FROM a AS b
        634. 
-
      634.           *
        635. 
-
      635.           * dataset.from(dataset.from("a").group("b").as("c")).sql;
        636. 
-
      636.           *          //=> "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
        637. 
-
      637.           *
        638. 
-
      638.           * @param {...String|...patio.sql.Identifier|...patio.Dataset|...Object} [source] tables to select from
        639. 
-
      639.           *
        640. 
-
      640.           * @return {patio.Dataset} a cloned dataset with the FROM clause overridden.
        641. 
-
      641.           */
        642. 
-
      642.          from: function (source) {
        643. 
-
      643. 821            source = argsToArray(arguments);
        644. 
-
      644. 821            var tableAliasNum = 0, sources = [];
        645. 
-
      645. 821            source.forEach(function (s) {
        646. 
-
      646. 1003                if (isInstanceOf(s, Dataset)) {
        647. 
-
      647. 86                    sources.push(new AliasedExpression(s, this._datasetAlias(++tableAliasNum)));
        648. 
-
      648. 917                } else if (isHash(s)) {
        649. 
-
      649. 3                    for (var i in s) {
        650. 
-
      650. 3                        sources.push(new AliasedExpression(new Identifier(i), s[i]));
        651. 
-
      651.                      }
        652. 
-
      652. 914                } else if (isString(s)) {
        653. 
-
      653. 889                    sources.push(this.stringToIdentifier(s))
        654. 
-
      654.                  } else {
        655. 
-
      655. 25                    sources.push(s);
        656. 
-
      656.                  }
        657. 
-
      657.              }, this);
        658. 
-
      658.  
        659. 
-
      659. 821            var o = {from: sources.length ? sources : null}
        660. 
-
      660. 821            if (tableAliasNum) {
        661. 
-
      661. 84                o.numDatasetSources = tableAliasNum;
        662. 
-
      662.              }
        663. 
-
      663. 821            return this.mergeOptions(o)
        664. 
+
      664.          isUUID:function isUUID(opts) {
        665. 
+
      665. 1            return this.__addAction(function (col) {
        666. 
+
      666. 3                return !!col.match(/^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$/);
        667. 
+
      667.              }, merge({message:"{col} must be a valid UUID got {val}"}, opts));
        668. 
 
      668.          },
        669. 
 
      669.  
        670. 
-
      670.          /**
        671. 
-
      671.           * Returns a dataset selecting from the current dataset.
        672. 
-
      672.           * Supplying the alias option controls the alias of the result.
        673. 
-
      673.           *
        674. 
-
      674.           * @example
        675. 
-
      675.           *
        676. 
-
      676.           * ds = DB.from("items").order("name").select("id", "name")
        677. 
-
      677.           *      //=> SELECT id,name FROM items ORDER BY name
        678. 
-
      678.           *
        679. 
-
      679.           * ds.fromSelf().sql;
        680. 
-
      680.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1
        681. 
-
      681.           *
        682. 
-
      682.           * ds.fromSelf({alias : "foo"}).sql;
        683. 
-
      683.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo
        684. 
-
      684.           *
        685. 
-
      685.           * @param {Object} [opts] options
        686. 
-
      686.           * @param {String|patio.sql.Identifier} [opts.alias] alias to use
        687. 
-
      687.           *
        688. 
-
      688.           * @return {patio.Dataset} a cloned dataset with the FROM clause set as the current dataset.
        689. 
-
      689.           */
        690. 
-
      690.          fromSelf: function (opts) {
        691. 
-
      691. 84            opts = isUndefined(opts) ? {} : opts;
        692. 
-
      692. 84            var fs = {};
        693. 
-
      693. 84            var nonSqlOptions = this._static.NON_SQL_OPTIONS;
        694. 
-
      694. 84            Object.keys(this.__opts).forEach(function (k) {
        695. 
-
      695. 302                if (nonSqlOptions.indexOf(k) == -1) {
        696. 
-
      696. 302                    fs[k] = null;
        697. 
-
      697.                  }
        698. 
-
      698.              });
        699. 
-
      699. 84            return this.mergeOptions(fs).from(opts["alias"] ? this.as(opts["alias"]) : this);
        700. 
+
      700.          isEmail:function isEmail(opts) {
        701. 
+
      701. 1            return this.__addAction(function (col) {
        702. 
+
      702. 3                return validatorCheck(col).isEmail();
        703. 
+
      703.              }, merge({message:"{col} must be a valid Email Address got {val}"}, opts));
        704. 
 
      704.          },
        705. 
 
      705.  
        706. 
-
      706.          /**
        707. 
-
      707.           * Match any of the columns to any of the patterns. The terms can be
        708. 
-
      708.           * strings (which use LIKE) or regular expressions (which are only
        709. 
-
      709.           * supported on MySQL and PostgreSQL).  Note that the total number of
        710. 
-
      710.           * pattern matches will be columns[].length * terms[].length,
        711. 
-
      711.           * which could cause performance issues.
        712. 
-
      712.           *
        713. 
-
      713.           * @example
        714. 
-
      714.           *
        715. 
-
      715.           * DB.from("items").grep("a", "%test%").sql;
        716. 
-
      716.           *      //=> SELECT * FROM items WHERE (a LIKE '%test%');
        717. 
-
      717.           *
        718. 
-
      718.           * DB.from("items").grep(["a", "b"], ["%test%" "foo"]).sql;
        719. 
-
      719.           *      //=> SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))
        720. 
-
      720.           *
        721. 
-
      721.           * DB.from("items").grep(['a', 'b'], ["%foo%", "%bar%"], {allPatterns : true}).sql;
        722. 
-
      722.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
        723. 
-
      723.           *
        724. 
-
      724.           * DB.from("items").grep(["a", "b"], ['%foo%", "%bar%", {allColumns : true})sql;
        725. 
-
      725.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
        726. 
-
      726.           *
        727. 
-
      727.           * DB.from("items").grep(["a", "b"], ["%foo%", "%bar%"], {allPatterns : true, allColumns : true}).sql;
        728. 
-
      728.           *      //=> SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
        729. 
-
      729.           *
        730. 
-
      730.           * @param {String[]|patio.sql.Identifier[]} columns columns to search
        731. 
-
      731.           * @param {String|RegExp} patterns patters to search with
        732. 
-
      732.           * @param {Object} [opts] options to use when searching. NOTE If both allColumns and allPatterns are true, all columns must match all patterns
        733. 
-
      733.           * @param {Boolean} [opts.allColumns] All columns must be matched to any of the given patterns.
        734. 
-
      734.           * @param {Boolean} [opts.allPatterns] All patterns must match at least one of the columns.
        735. 
-
      735.           * @param {Boolean} [opts.caseInsensitive] Use a case insensitive pattern match (the default is
        736. 
-
      736.           *                      case sensitive if the database supports it).
        737. 
-
      737.           * @return {patio.Dataset} a dataset with the LIKE clauses added
        738. 
-
      738.           */
        739. 
-
      739.  
        740. 
-
      740.          grep: function (columns, patterns, opts) {
        741. 
-
      741. 15            opts = isUndefined(opts) ? {} : opts;
        742. 
-
      742. 15            var conds;
        743. 
-
      743. 15            if (opts.hasOwnProperty("allPatterns")) {
        744. 
-
      744. 4                conds = array.toArray(patterns).map(function (pat) {
        745. 
-
      745. 8                    return BooleanExpression.fromArgs(
        746. 
-
      746.                          [(opts.allColumns ? "AND" : "OR")]
        747. 
-
      747.                              .concat(array.toArray(columns)
        748. 
-
      748.                                  .map(function (c) {
        749. 
-
      749. 16                                    return StringExpression.like(c, pat, opts);
        750. 
-
      750.                                  })));
        751. 
-
      751.                  });
        752. 
-
      752. 4                return this.filter(BooleanExpression.fromArgs([opts.allPatterns ? "AND" : "OR"].concat(conds)));
        753. 
-
      753.              } else {
        754. 
-
      754. 11                conds = array.toArray(columns)
        755. 
-
      755.                      .map(function (c) {
        756. 
-
      756. 16                        return BooleanExpression.fromArgs(["OR"].concat(array.toArray(patterns).map(function (pat) {
        757. 
-
      757. 26                            return StringExpression.like(c, pat, opts);
        758. 
-
      758.                          })));
        759. 
-
      759.                      });
        760. 
-
      760. 11                return this.filter(BooleanExpression.fromArgs([opts.allColumns ? "AND" : "OR"].concat(conds)));
        761. 
-
      761.              }
        762. 
+
      762.          isUrl:function isUrl(opts) {
        763. 
+
      763. 1            return this.__addAction(function (col) {
        764. 
+
      764. 3                return validatorCheck(col).isUrl();
        765. 
+
      765.              }, merge({message:"{col} must be a valid url got {val}"}, opts));
        766. 
 
      766.          },
        767. 
 
      767.  
        768. 
-
      768.          /**
        769. 
-
      769.           * @see patio.Dataset#grep
        770. 
-
      770.           */
        771. 
-
      771.          like: function () {
        772. 
-
      772. 1            return this.grep.apply(this, arguments);
        773. 
+
      773.          isAlpha:function isAlpha(opts) {
        774. 
+
      774. 2            return this.__addAction(function (col) {
        775. 
+
      775. 11                return validatorCheck(col).isAlpha();
        776. 
+
      776.              }, merge({message:"{col} must be a only letters got {val}"}, opts));
        777. 
 
      777.          },
        778. 
 
      778.  
        779. 
-
      779.  
        780. 
-
      780.          /**
        781. 
-
      781.           * Returns a copy of the dataset with the results grouped by the value of
        782. 
-
      782.           * the given columns.
        783. 
-
      783.           * @example
        784. 
-
      784.           *   DB.from("items").group("id")
        785. 
-
      785.           *          //=>SELECT * FROM items GROUP BY id
        786. 
-
      786.           *   DB.from("items").group("id", "name")
        787. 
-
      787.           *          //=> SELECT * FROM items GROUP BY id, name
        788. 
-
      788.           * @param {String...|patio.sql.Identifier...} columns columns to group by.
        789. 
-
      789.           *
        790. 
-
      790.           * @return {patio.Dataset} a cloned dataset with the GROUP BY clause added.
        791. 
-
      791.           **/
        792. 
-
      792.          group: function (columns) {
        793. 
-
      793. 32            columns = argsToArray(arguments);
        794. 
-
      794. 32            var stringToIdentifier = this.stringToIdentifier.bind(this)
        795. 
-
      795. 32            return this.mergeOptions({group: (array.compact(columns).length == 0 ? null : columns.map(function (c) {
        796. 
-
      796. 32                return isString(c) ? stringToIdentifier(c) : c;
        797. 
-
      797.              }))});
        798. 
+
      798.          isAlphaNumeric:function isAlphaNumeric(opts) {
        799. 
+
      799. 1            return this.__addAction(function (col) {
        800. 
+
      800. 3                return validatorCheck(col).isAlphanumeric();
        801. 
+
      801.              }, merge({message:"{col} must be a alphanumeric got {val}"}, opts));
        802. 
 
      802.          },
        803. 
 
      803.  
        804. 
-
      804.          /**
        805. 
-
      805.           * @see patio.Dataset#group
        806. 
-
      806.           */
        807. 
-
      807.          groupBy: function () {
        808. 
-
      808. 10            return this.group.apply(this, arguments);
        809. 
+
      809.          hasLength:function hasLength(min, max, opts) {
        810. 
+
      810. 2            return this.__addAction(function (col) {
        811. 
+
      811. 6                return validatorCheck(col).len(min, max);
        812. 
+
      812.              }, merge({message:"{col} must have a length between " + min + (max ? " and " + max : "") + "."}, opts));
        813. 
 
      813.          },
        814. 
 
      814.  
        815. 
+
      815.          isLowercase:function isLowercase(opts) {
        816. 
+
      816. 1            return this.__addAction(function (col) {
        817. 
+
      817. 3                return validatorCheck(col).isLowercase();
        818. 
+
      818.              }, merge({message:"{col} must be lowercase got {val}."}, opts));
        819. 
+
      819.          },
        820. 
 
      820.  
        821. 
-
      821.          /**
        822. 
-
      822.           * Returns a dataset grouped by the given column with count by group.
        823. 
-
      823.           * Column aliases may be supplied, and will be included in the select clause.
        824. 
-
      824.           *
        825. 
-
      825.           * @example
        826. 
-
      826.           *
        827. 
-
      827.           * DB.from("items").groupAndCount("name").all()
        828. 
-
      828.           *      //=> SELECT name, count(*) AS count FROM items GROUP BY name
        829. 
-
      829.           *      //=> [{name : 'a', count : 1}, ...]
        830. 
-
      830.           *
        831. 
-
      831.           * DB.from("items").groupAndCount("first_name", "last_name").all()
        832. 
-
      832.           *      //SELECT first_name, last_name, count(*) AS count FROM items GROUP BY first_name, last_name
        833. 
-
      833.           *      //=> [{first_name : 'a', last_name : 'b', count : 1}, ...]
        834. 
-
      834.           *
        835. 
-
      835.           * DB.from("items").groupAndCount("first_name___name").all()
        836. 
-
      836.           *      //=> SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
        837. 
-
      837.           *      //=> [{name : 'a', count:1}, ...]
        838. 
-
      838.           * @param {String...|patio.sql.Identifier...} columns columns to croup and count on.
        839. 
-
      839.           *
        840. 
-
      840.           * @return {patio.Dataset} a cloned dataset with the GROUP clause and count added.
        841. 
-
      841.           */
        842. 
-
      842.          groupAndCount: function (columns) {
        843. 
-
      843. 8            columns = argsToArray(arguments);
        844. 
-
      844. 8            var group = this.group.apply(this, columns.map(function (c) {
        845. 
-
      845. 9                return this._unaliasedIdentifier(c);
        846. 
-
      846.              }, this));
        847. 
-
      847. 8            return group.select.apply(group, columns.concat([this._static.COUNT_OF_ALL_AS_COUNT]));
        848. 
-
      848.  
        849. 
+
      849.          isUppercase:function isUppercase(opts) {
        850. 
+
      850. 1            return this.__addAction(function (col) {
        851. 
+
      851. 3                return validatorCheck(col).isUppercase();
        852. 
+
      852.              }, merge({message:"{col} must be uppercase got {val}."}, opts));
        853. 
 
      853.          },
        854. 
 
      854.  
        855. 
-
      855.          /**
        856. 
-
      856.           * Returns a copy of the dataset with the HAVING conditions changed. See {@link patio.Dataset#filter} for argument types.
        857. 
-
      857.           *
        858. 
-
      858.           * @example
        859. 
-
      859.           * DB.from("items").group("sum").having({sum : 10}).sql;
        860. 
-
      860.           *      //=> SELECT * FROM items GROUP BY sum HAVING (sum = 10)
        861. 
-
      861.           *
        862. 
-
      862.           * @return {patio.Dataset} a cloned dataset with HAVING clause changed or added.
        863. 
-
      863.           **/
        864. 
-
      864.          having: function () {
        865. 
-
      865. 12            var cond = argsToArray(arguments).map(function (s) {
        866. 
-
      866. 12                return isString(s) && s !== '' ? this.stringToIdentifier(s) : s
        867. 
-
      867.              }, this);
        868. 
-
      868. 12            return this._filter.apply(this, ["having"].concat(cond));
        869. 
+
      869.          isEmpty:function isEmpty(opts) {
        870. 
+
      870. 1            return this.__addAction(function (col) {
        871. 
+
      871. 3                try {
        872. 
+
      872. 3                    validatorCheck(col).notEmpty();
        873. 
+
      873. 2                    return false;
        874. 
+
      874.                  } catch (e) {
        875. 
+
      875. 1                    return true;
        876. 
+
      876.                  }
        877. 
+
      877.              }, merge({message:"{col} must be empty got {val}."}, opts));
        878. 
 
      878.          },
        879. 
 
      879.  
        880. 
-
      880.          /**
        881. 
-
      881.           * Adds an INTERSECT clause using a second dataset object.
        882. 
-
      882.           * An INTERSECT compound dataset returns all rows in both the current dataset
        883. 
-
      883.           * and the given dataset.
        884. 
-
      884.           *
        885. 
-
      885.           * @example
        886. 
-
      886.           *
        887. 
-
      887.           * DB.from("items").intersect(DB.from("other_items")).sql;
        888. 
-
      888.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS t1
        889. 
-
      889.           *
        890. 
-
      890.           * DB.from("items").intersect(DB.from("other_items"), {all : true, fromSelf : false}).sql;
        891. 
-
      891.           *   //=> SELECT * FROM items INTERSECT ALL SELECT * FROM other_items
        892. 
-
      892.           *
        893. 
-
      893.           * DB.from("items").intersect(DB.from("other_items"), {alias : "i"}).sql;
        894. 
-
      894.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS i
        895. 
-
      895.           *
        896. 
-
      896.           * @throws {patio.QueryError} if the operation is not supported.
        897. 
-
      897.           * @param  {patio.Dataset} dataset the dataset to intersect
        898. 
-
      898.           * @param  {Object} [opts] options
        899. 
-
      899.           * @param {String|patio.sql.Identifier} [opts.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias
        900. 
-
      900.           * @param {Boolean} [opts.all] Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
        901. 
-
      901.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}.
        902. 
-
      902.           *
        903. 
-
      903.           * @return {patio.Dataset} a cloned dataset with the INTERSECT clause.
        904. 
-
      904.           **/
        905. 
-
      905.          intersect: function (dataset, opts) {
        906. 
-
      906. 18            opts = isUndefined(opts) ? {} : opts;
        907. 
-
      907. 18            if (!isHash(opts)) {
        908. 
-
      908. 5                opts = {all: opts};
        909. 
-
      909.              }
        910. 
-
      910. 18            if (!this.supportsIntersectExcept) {
        911. 
-
      911. 2                throw new QueryError("INTERSECT not supported");
        912. 
-
      912. 16            } else if (opts.all && !this.supportsIntersectExceptAll) {
        913. 
-
      913. 1                throw new QueryError("INTERSECT ALL not supported");
        914. 
-
      914.              }
        915. 
-
      915. 15            return this.compoundClone("intersect", dataset, opts);
        916. 
+
      916.          isNotEmpty:function isNotEmpty(opts) {
        917. 
+
      917. 2            return this.__addAction(function (col) {
        918. 
+
      918. 11                return validatorCheck(col).notEmpty();
        919. 
+
      919.              }, merge({message:"{col} must not be empty."}, opts));
        920. 
 
      920.          },
        921. 
 
      921.  
        922. 
-
      922.          /**
        923. 
-
      923.           * Inverts the current filter.
        924. 
-
      924.           *
        925. 
-
      925.           * @example
        926. 
-
      926.           * DB.from("items").filter({category : 'software'}).invert()
        927. 
-
      927.           *      //=> SELECT * FROM items WHERE (category != 'software')
        928. 
-
      928.           *
        929. 
-
      929.           * @example
        930. 
-
      930.           * DB.from("items").filter({category : 'software', id : 3}).invert()
        931. 
-
      931.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
        932. 
-
      932.           *
        933. 
-
      933.           * @return {patio.Dataset} a cloned dataset with the filter inverted.
        934. 
-
      934.           **/
        935. 
-
      935.          invert: function () {
        936. 
-
      936. 3            var having = this.__opts.having, where = this.__opts.where;
        937. 
-
      937. 3            if (!(having || where)) {
        938. 
-
      938. 1                throw new QueryError("No current filter");
        939. 
-
      939.              }
        940. 
-
      940. 2            var o = {}
        941. 
-
      941. 2            if (having) {
        942. 
-
      942. 1                o.having = BooleanExpression.invert(having);
        943. 
-
      943.              }
        944. 
-
      944. 2            if (where) {
        945. 
-
      945. 2                o.where = BooleanExpression.invert(where);
        946. 
-
      946.              }
        947. 
-
      947. 2            return this.mergeOptions(o);
        948. 
+
      948.          isCreditCard:function isCreditCard(opts) {
        949. 
+
      949. 0            return this.__addAction(function (col) {
        950. 
+
      950. 0                return validatorCheck(col).isCreditCard();
        951. 
+
      951.              }, merge({message:"{col} is an invalid credit card"}, opts));
        952. 
 
      952.          },
        953. 
 
      953.  
        954. 
-
      954.          /**
        955. 
-
      955.           * Returns a cloned dataset with an inner join applied.
        956. 
-
      956.           *
        957. 
-
      957.           * @see patio.Dataset#joinTable
        958. 
-
      958.           */
        959. 
-
      959.          join: function () {
        960. 
-
      960. 212            return this.innerJoin.apply(this, arguments);
        961. 
+
      961.          check:function (fun, opts) {
        962. 
+
      962. 4            return this.__addAction(fun, opts);
        963. 
 
      963.          },
        964. 
 
      964.  
        965. 
+
      965.          validate:function validate(value) {
        966. 
+
      966. 218            var errOpts = {col:this.col, val:value};
        967. 
+
      967. 218            return compact(this.__actions.map(function (action) {
        968. 
+
      968. 248                var actionOpts = action.opts;
        969. 
+
      969. 248                if (!actionOpts.onlyDefined || (combIsDefined(value) &&
        970. 
+
      970.                      (!actionOpts.onlyNotNull || !combIsNull(value)) )) {
        971. 
+
      971. 186                    var ret = null;
        972. 
+
      972. 186                    try {
        973. 
+
      973. 186                        if (!action.action(value)) {
        974. 
+
      974. 69                            ret = format(actionOpts.message, errOpts);
        975. 
+
      975.                          }
        976. 
+
      976.                      } catch (e) {
        977. 
+
      977. 28                        ret = format(actionOpts.message, errOpts);
        978. 
+
      978.                      }
        979. 
+
      979. 186                    return ret;
        980. 
+
      980.                  }
        981. 
+
      981.              }, this));
        982. 
+
      982.          }
        983. 
+
      983.  
        984. 
+
      984.      }
        985. 
+
      985.  });
        986. 
+
      986.  
        987. 
+
      987. 1function shouldValidate(opts, def) {
        988. 
+
      988. 115    opts = opts || {};
        989. 
+
      989. 115    return combIsBoolean(opts.validate) ? opts.validate : def;
        990. 
+
      990.  }
        991. 
+
      991.  
        992. 
+
      992. 1function validateHook(prop, next, opts) {
        993. 
+
      993. 115    if (shouldValidate(opts, prop) && !this.isValid()) {
        994. 
+
      994. 45        next(flatten(toArray(this.errors).map(function (entry) {
        995. 
+
      995. 64            return entry[1].map(function (err) {
        996. 
+
      996. 48                return new Error(err);
        997. 
+
      997.              });
        998. 
+
      998.          })));
        999. 
+
      999.      } else {
        1000. 
+
      1000. 70        next();
        1001. 
+
      1001.      }
        1002. 
+
      1002.  }
        1003. 
+
      1003.  
        1004. 
+
      1004. 1define(null, {
        1005. 
+
      1005.  
        1006. 
+
      1006.      instance:{
        1007. 
+
      1007.  
        1008. 
 
      1008.          /**
        1009. 
-
      1009.           * Returns a joined dataset.  Uses the following arguments:
        1010. 
+
      1010.           * A validation plugin for patio models. This plugin adds a <code>validate</code> method to each {@link patio.Model}
        1011. 
+
      1011.           * class that adds it as a plugin. This plugin does not include most typecast checks as <code>patio</code> already checks
        1012. 
+
      1012.           * types upon column assignment.
        1013. 
 
      1013.           *
        1014. 
-
      1014.           * @example
        1015. 
+
      1015.           * To do single col validation
        1016. 
+
      1016.           * {@code
        1017. 
 
      1017.           *
        1018. 
-
      1018.           * DB.from("items").joinTable("leftOuter", "categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
        1019. 
-
      1019.           *      //=>'SELECT
        1020. 
-
      1020.           *             *
        1021. 
-
      1021.           *            FROM
        1022. 
-
      1022.           *              `items`
        1023. 
-
      1023.           *                  LEFT OUTER JOIN
        1024. 
-
      1024.           *              `categories` ON (
        1025. 
-
      1025.           *                          (`categories`.`categoryId` = `items`.`id`)
        1026. 
-
      1026.           *                              AND
        1027. 
-
      1027.           *                          (`categories`.`categoryId` IN (1,2, 3))
        1028. 
-
      1028.           *                          )
        1029. 
-
      1029.           * DB.from("items").leftOuter("categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
        1030. 
-
      1030.           *      //=>'SELECT
        1031. 
-
      1031.           *             *
        1032. 
-
      1032.           *            FROM
        1033. 
-
      1033.           *              `items`
        1034. 
-
      1034.           *                  LEFT OUTER JOIN
        1035. 
-
      1035.           *              `categories` ON (
        1036. 
-
      1036.           *                          (`categories`.`categoryId` = `items`.`id`)
        1037. 
-
      1037.           *                              AND
        1038. 
-
      1038.           *                          (`categories`.`categoryId` IN (1,2, 3))
        1039. 
-
      1039.           *                          )
        1040. 
+
      1040.           * var Model = patio.addModel("validator", {
        1041. 
+
      1041.           *      plugins:[ValidatorPlugin]
        1042. 
+
      1042.           * });
        1043. 
+
      1043.           * //this ensures column assignment
        1044. 
+
      1044.           * Model.validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
        1045. 
+
      1045.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
        1046. 
+
      1046.           * Model.validate("col2").like(/hello/ig);
        1047. 
+
      1047.           * //Ensures that the emailAddress column is a valid email address.
        1048. 
+
      1048.           * Model.validate("emailAddress").isEmailAddress();
        1049. 
+
      1049.           * }
        1050. 
+
      1050.           *
        1051. 
+
      1051.           * Or you can do a mass validation through a callback.
        1052. 
+
      1052.           * {@code
        1053. 
 
      1053.           *
        1054. 
-
      1054.           * DB.from("items").leftOuterJoin("categories", {categoryId:"id"}).sql
        1055. 
-
      1055.           *          //=> SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1056. 
+
      1056.           * var Model = patio.addModel("validator", {
        1057. 
+
      1057.           *      plugins:[ValidatorPlugin]
        1058. 
+
      1058.           * });
        1059. 
+
      1059.           * Model.validate(function(validate){
        1060. 
+
      1060.           *      //this ensures column assignment
        1061. 
+
      1061.           *      validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
        1062. 
+
      1062.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
        1063. 
+
      1063.           *      validate("col2").isLike(/hello/ig);
        1064. 
+
      1064.           *      //Ensures that the emailAddress column is a valid email address.
        1065. 
+
      1065.           *      validate("emailAddress").isEmail();
        1066. 
+
      1066.           * });
        1067. 
+
      1067.           * }
        1068. 
 
      1068.           *
        1069. 
-
      1069.           * DB.from("items").rightOuterJoin("categories", {categoryId:"id"}).sql
        1070. 
-
      1070.           *          //=> SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1071. 
+
      1071.           * To check if a {@link patio.Model} is valid you can run the <code>isValid</code> method.
        1072. 
 
      1072.           *
        1073. 
-
      1073.           * DB.from("items").fullOuterJoin("categories", {categoryId:"id"}).sql
        1074. 
-
      1074.           *          //=> SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1075. 
+
      1075.           * {@code
        1076. 
+
      1076.           * var model1 = new Model({col2 : 'grape', emailAddress : "test"}),
        1077. 
+
      1077.           *     model2 = new Model({col1 : "grape", col2 : "hello", emailAddress : "test@test.com"});
        1078. 
 
      1078.           *
        1079. 
-
      1079.           * DB.from("items").innerJoin("categories", {categoryId:"id"}).sql
        1080. 
-
      1080.           *          //=> SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1081. 
+
      1081.           * model1.isValid() //false
        1082. 
+
      1082.           * model2.isValid() //true
        1083. 
+
      1083.           * }
        1084. 
 
      1084.           *
        1085. 
-
      1085.           * DB.from("items").leftJoin("categories", {categoryId:"id"}).sql
        1086. 
-
      1086.           *          //=> SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1087. 
+
      1087.           * To get the errors associated with an invalid model you can access the errors property
        1088. 
 
      1088.           *
        1089. 
-
      1089.           * DB.from("items").rightJoin("categories", {categoryId:"id"}).sql
        1090. 
-
      1090.           *          //=> SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1091. 
+
      1091.           * {@code
        1092. 
+
      1092.           * model1.errors; //{ col1: [ 'col1 must be defined.' ],
        1093. 
+
      1093.           *                //  col2: [ 'col2 must be like /hello/gi got grape.' ],
        1094. 
+
      1094.           *                //  emailAddress: [ 'emailAddress must be a valid Email Address got test' ] }
        1095. 
+
      1095.           * }
        1096. 
 
      1096.           *
        1097. 
-
      1097.           * DB.from("items").fullJoin("categories", {categoryId:"id"}).sql
        1098. 
-
      1098.           *          //=> SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1099. 
+
      1099.           * Validation is also run pre save and pre update. To prevent this you can specify the <code>validate</code> option
        1100. 
 
      1100.           *
        1101. 
-
      1101.           * DB.from("items").naturalJoin("categories").sql
        1102. 
-
      1102.           *          //=> SELECT * FROM "items" NATURAL JOIN "categories"
        1103. 
+
      1103.           * {@code
        1104. 
+
      1104.           * model1.save(null, {validate : false});
        1105. 
+
      1105.           * model2.save(null, {validate : false});
        1106. 
+
      1106.           * }
        1107. 
 
      1107.           *
        1108. 
-
      1108.           * DB.from("items").naturalLeftJoin("categories").sql
        1109. 
-
      1109.           *          //=> SELECT * FROM "items" NATURAL LEFT JOIN "categories"
        1110. 
+
      1110.           * Or you can specify the class level properties <code>validateOnSave</code> and <code>validateOnUpdate</code>
        1111. 
+
      1111.           * to false respectively
        1112. 
+
      1112.           * {@code
        1113. 
+
      1113.           * Model.validateOnSave = false;
        1114. 
+
      1114.           * Model.validateOnUpdate = false;
        1115. 
+
      1115.           * }
        1116. 
 
      1116.           *
        1117. 
-
      1117.           * DB.from("items").naturalRightJoin("categories").sql
        1118. 
-
      1118.           *          //=> SELECT * FROM "items" NATURAL RIGHT JOIN "categories"
        1119. 
+
      1119.           * Avaiable validation methods are.
        1120. 
 
      1120.           *
        1121. 
-
      1121.           * DB.from("items").naturalFullJoin("categories").sql
        1122. 
-
      1122.           *          //=> SELECT * FROM "items" NATURAL FULL JOIN "categories"'
        1123. 
+
      1123.           * <ul>
        1124. 
+
      1124.           *  <li><code>isAfter</code> : check that a date is after a specified date</li>
        1125. 
+
      1125.           *  <li><code>isBefore</code> : check that a date is after before a specified date </li>
        1126. 
+
      1126.           *  <li><code>isDefined</code> : ensure that a column is defined</li>
        1127. 
+
      1127.           *  <li><code>isNotDefined</code> : ensure that a column is not defined</li>
        1128. 
+
      1128.           *  <li><code>isNotNull</code> : ensure that a column is defined and not null</li>
        1129. 
+
      1129.           *  <li><code>isNull</code> : ensure that a column is not defined or null</li>
        1130. 
+
      1130.           *  <li><code>isEq</code> : ensure that a column equals a value <b>this uses deep equal</b></li>
        1131. 
+
      1131.           *  <li><code>isNeq</code> : ensure that a column does not equal a value <b>this uses deep equal</b></li>
        1132. 
+
      1132.           *  <li><code>isLike</code> : ensure that a column is like a value, can be a regexp or string</li>
        1133. 
+
      1133.           *  <li><code>isNotLike</code> : ensure that a column is not like a value, can be a regexp or string</li>
        1134. 
+
      1134.           *  <li><code>isLt</code> : ensure that a column is less than a value</li>
        1135. 
+
      1135.           *  <li><code>isGt</code> : ensure that a column is greater than a value</li>
        1136. 
+
      1136.           *  <li><code>isLte</code> : ensure that a column is less than or equal to a value</li>
        1137. 
+
      1137.           *  <li><code>isGte</code> : ensure that a column is greater than or equal to a value</li>
        1138. 
+
      1138.           *  <li><code>isIn</code> : ensure that a column is contained in an array of values</li>
        1139. 
+
      1139.           *  <li><code>isNotIn</code> : ensure that a column is not contained in an array of values</li>
        1140. 
+
      1140.           *  <li><code>isMacAddress</code> : ensure that a column is a valid MAC address</li>
        1141. 
+
      1141.           *  <li><code>isIPAddress</code> : ensure that a column is a valid IPv4 or IPv6 address</li>
        1142. 
+
      1142.           *  <li><code>isIPv4Address</code> : ensure that a column is a valid IPv4 address</li>
        1143. 
+
      1143.           *  <li><code>isIPv6Address</code> : ensure that a column is a valid IPv6 address</li>
        1144. 
+
      1144.           *  <li><code>isUUID</code> : ensure that a column is a valid UUID</li>
        1145. 
+
      1145.           *  <li><code>isEmail</code> : ensure that a column is a valid email address</li>
        1146. 
+
      1146.           *  <li><code>isUrl</code> : ensure than a column is a valid URL</li>
        1147. 
+
      1147.           *  <li><code>isAlpha</code> : ensure than a column is all letters</li>
        1148. 
+
      1148.           *  <li><code>isAlphaNumeric</code> : ensure than a column is all letters or numbers</li>
        1149. 
+
      1149.           *  <li><code>hasLength</code> : ensure than a column is fits within the specified length accepts a min and optional max value</li>
        1150. 
+
      1150.           *  <li><code>isLowercase</code> : ensure than a column is lowercase</li>
        1151. 
+
      1151.           *  <li><code>isUppercase</code> : ensure than a column is uppercase</li>
        1152. 
+
      1152.           *  <li><code>isEmpty</code> : ensure than a column empty (i.e. a blank string)</li>
        1153. 
+
      1153.           *  <li><code>isNotEmpty</code> : ensure than a column not empty (i.e. not a blank string)</li>
        1154. 
+
      1154.           *  <li><code>isCreditCard</code> : ensure than a is a valid credit card number</li>
        1155. 
+
      1155.           *  <li><code>check</code> : accepts a function to perform validation</li>
        1156. 
+
      1156.           * </ul>
        1157. 
 
      1157.           *
        1158. 
-
      1158.           * DB.from("items").crossJoin("categories").sql
        1159. 
-
      1159.           *          //=> SELECT * FROM "items" CROSS JOIN "categories"
        1160. 
+
      1160.           * All of the validation methods are chainable, and accept an options argument.
        1161. 
 
      1161.           *
        1162. 
-
      1162.           * @param {String} type the type of join to do.
        1163. 
-
      1163.           * @param {String|patio.sql.Identifier|patio.Dataset|Object} table depends on the type.
        1164. 
-
      1164.           *  <ul>
        1165. 
-
      1165.           *      <li>{@link patio.Dataset} - a subselect is performed with an alias</li>
        1166. 
-
      1166.           *      <li>Object - an object that has a tableName property.</li>
        1167. 
-
      1167.           *      <li>String|{@link patio.sql.Identifier}  - the name of the table</li>
        1168. 
-
      1168.           *  </ul>
        1169. 
-
      1169.           * @param [expr] - depends on type
        1170. 
+
      1170.           * The options include
        1171. 
 
      1171.           * <ul>
        1172. 
-
      1172.           *     <li>Object|Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already
        1173. 
-
      1173.           *     qualified), and value (2nd arg) is column of the last joined or primary table (or the
        1174. 
-
      1174.           *     implicitQualifier option</li>.
        1175. 
-
      1175.           *     <li>Array - If all members of the array are string or {@link patio.sql.Identifier}, considers
        1176. 
-
      1176.           *     them as columns and uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
        1177. 
-
      1177.           *     the result set if this is used.</li>
        1178. 
-
      1178.           *     <li>null|undefined(not passed in) - If a cb is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
        1179. 
-
      1179.           *     or CROSS join. If a block is given, uses an ON clause based on the block, see below.</li>
        1180. 
-
      1180.           *     <li>Everything else - pretty much the same as a using the argument in a call to {@link patio.Dataset#filter},
        1181. 
-
      1181.           *     so strings are considered literal, {@link patio.sql.Identifiers} specify boolean columns, and patio.sql
        1182. 
-
      1182.           *      expressions can be used. Uses a JOIN with an ON clause.</li>
        1183. 
+
      1183.           *     <li><code>message</code> : a message to return if a column fails validation. The message can include <code>{val}</code> and <code>{col}</code>
        1184. 
+
      1184.           *     replacements which will insert the invalid value and the column name.
        1185. 
+
      1185.           *     </li>
        1186. 
+
      1186.           *     <li><code>[onlyDefined=true]</code> : set to false to run the method even if the column value is not defined.</li>
        1187. 
+
      1187.           *     <li><code>[onlyNotNull=true]</code> : set to false to run the method even if the column value is null.</li>
        1188. 
 
      1188.           * </ul>
        1189. 
-
      1189.           * @param {Object} options an object of options.
        1190. 
-
      1190.           * @param {String|patio.sql.Identifier} [options.tableAlias=undefined] the name of the table's alias when joining, necessary for joining
        1191. 
-
      1191.           *     to the same table more than once.  No alias is used by default.
        1192. 
-
      1192.           * @param {String|patio.sql.Identifier} [options.implicitQualifier=undefined] The name to use for qualifying implicit conditions.  By default,
        1193. 
-
      1193.           *     the last joined or primary table is used.
        1194. 
-
      1194.           * @param {Function} [cb]  cb - The cb argument should only be given if a JOIN with an ON clause is used,
        1195. 
-
      1195.           *   in which case it is called with
        1196. 
-
      1196.           *   <ul>
        1197. 
-
      1197.           *       <li>table alias/name for the table currently being joined</li>
        1198. 
-
      1198.           *       <li> the table alias/name for the last joined (or first table)
        1199. 
-
      1199.           *       <li>array of previous</li>
        1200. 
-
      1200.           *   </ul>
        1201. 
-
      1201.           *   the cb should return an expression to be used in the ON clause.
        1202. 
 
      1202.           *
        1203. 
-
      1203.           * @return {patio.Dataset} a cloned dataset joined using the arguments.
        1204. 
+
      1204.           *
        1205. 
+
      1205.           * @constructs
        1206. 
+
      1206.           * @name ValidatorPlugin
        1207. 
+
      1207.           * @memberOf patio.plugins
        1208. 
+
      1208.           * @property {Object} [errors={}] the validation errors for this model.
        1209. 
+
      1209.           *
        1210. 
 
      1210.           */
        1211. 
+
      1211.          constructor:function () {
        1212. 
+
      1212. 114            this._super(arguments);
        1213. 
+
      1213. 114            this.errors = {};
        1214. 
+
      1214.          },
        1215. 
 
      1215.  
        1216. 
-
      1216.          joinTable: function (type, table, expr, options, cb) {
        1217. 
-
      1217. 634            var args = argsToArray(arguments);
        1218. 
-
      1218. 634            if (isFunction(args[args.length - 1])) {
        1219. 
-
      1219. 12                cb = args[args.length - 1];
        1220. 
-
      1220. 12                args.pop();
        1221. 
-
      1221.              } else {
        1222. 
-
      1222. 622                cb = null;
        1223. 
-
      1223.              }
        1224. 
-
      1224. 634            type = args.shift(), table = args.shift(), expr = args.shift(), options = args.shift();
        1225. 
-
      1225. 634            expr = isUndefined(expr) ? null : expr, options = isUndefined(options) ? {} : options;
        1226. 
+
      1226.          /**
        1227. 
+
      1227.           * Validates a model, returning an array of error messages for each invalid property.
        1228. 
+
      1228.           * @return {String[]} an array of error messages for each invalid property.
        1229. 
+
      1229.           */
        1230. 
+
      1230.          validate:function () {
        1231. 
+
      1231. 159            this.errors = {};
        1232. 
+
      1232. 159            return flatten(this._static.validators.map(function runValidator(validator) {
        1233. 
+
      1233. 218                var col = validator.col, val = this.__values[validator.col], ret = validator.validate(val);
        1234. 
+
      1234. 218                this.errors[col] = ret;
        1235. 
+
      1235. 218                return ret;
        1236. 
+
      1236.              }, this));
        1237. 
+
      1237.          },
        1238. 
 
      1238.  
        1239. 
-
      1239. 634            var h;
        1240. 
-
      1240. 634            var usingJoin = isArray(expr) && expr.length && expr.every(function (x) {
        1241. 
-
      1241. 223                return isString(x) || isInstanceOf(x, Identifier)
        1242. 
-
      1242.              });
        1243. 
-
      1243. 634            if (usingJoin && !this.supportsJoinUsing) {
        1244. 
-
      1244. 1                h = {};
        1245. 
-
      1245. 1                expr.forEach(function (s) {
        1246. 
-
      1246. 1                    h[s] = s;
        1247. 
-
      1247.                  });
        1248. 
-
      1248. 1                return this.joinTable(type, table, h, options);
        1249. 
-
      1249.              }
        1250. 
-
      1250. 633            var tableAlias, lastAlias;
        1251. 
-
      1251. 633            if (isHash(options)) {
        1252. 
-
      1252. 623                tableAlias = options.tableAlias;
        1253. 
-
      1253. 623                lastAlias = options.implicitQualifier;
        1254. 
-
      1254. 10            } else if (isString(options) || isInstanceOf(options, Identifier)) {
        1255. 
-
      1255. 9                tableAlias = options;
        1256. 
-
      1256. 9                lastAlias = null;
        1257. 
-
      1257.              } else {
        1258. 
-
      1258. 1                throw new QueryError("Invalid options format for joinTable %j4", [options]);
        1259. 
-
      1259.              }
        1260. 
-
      1260. 632            var tableAliasNum, tableName;
        1261. 
-
      1261. 632            if (isInstanceOf(table, Dataset)) {
        1262. 
-
      1262. 11                if (!tableAlias) {
        1263. 
-
      1263. 6                    tableAliasNum = (this.__opts.numDatasetSources || 0) + 1;
        1264. 
-
      1264. 6                    tableAlias = this._datasetAlias(tableAliasNum);
        1265. 
-
      1265.                  }
        1266. 
-
      1266. 11                tableName = tableAlias;
        1267. 
-
      1267.              } else {
        1268. 
-
      1268. 621                if (!isUndefined(table.tableName)) {
        1269. 
-
      1269. 1                    table = table.tableName;
        1270. 
-
      1270.                  }
        1271. 
-
      1271. 621                if (isArray(table)) {
        1272. 
-
      1272. 2                    table = table.map(this.stringToIdentifier, this);
        1273. 
-
      1273.                  } else {
        1274. 
-
      1274. 619                    table = isString(table) ? this.stringToIdentifier(table) : table;
        1275. 
-
      1275. 619                    var parts = this._splitAlias(table), implicitTableAlias = parts[1];
        1276. 
-
      1276. 619                    table = parts[0]
        1277. 
-
      1277. 619                    tableAlias = tableAlias || implicitTableAlias;
        1278. 
-
      1278. 619                    tableName = tableAlias || table;
        1279. 
-
      1279.                  }
        1280. 
-
      1280.              }
        1281. 
-
      1281. 632            var join;
        1282. 
-
      1282. 632            if (!expr && !cb) {
        1283. 
-
      1283. 22                join = new JoinClause(type, table, tableAlias);
        1284. 
-
      1284. 610            } else if (usingJoin) {
        1285. 
-
      1285. 9                if (cb) {
        1286. 
-
      1286. 1                    throw new QueryError("cant use a cb if an array is given");
        1287. 
-
      1287.                  }
        1288. 
-
      1288. 8                join = new JoinUsingClause(expr, type, table, tableAlias);
        1289. 
-
      1289.              } else {
        1290. 
-
      1290. 601                lastAlias = lastAlias || this.__opts["lastJoinedTable"] || this.firstSourceAlias;
        1291. 
-
      1291. 600                if (Expression.isConditionSpecifier(expr)) {
        1292. 
-
      1292. 588                    var newExpr = [];
        1293. 
-
      1293. 588                    for (var i in expr) {
        1294. 
-
      1294. 909                        var val = expr[i];
        1295. 
-
      1295. 909                        if (isArray(val) && val.length == 2) {
        1296. 
-
      1296. 418                            i = val[0], val = val[1];
        1297. 
-
      1297.                          }
        1298. 
-
      1298. 909                        var k = this.qualifiedColumnName(i, tableName), v;
        1299. 
-
      1299. 909                        if (isInstanceOf(val, Identifier)) {
        1300. 
-
      1300. 405                            v = val.qualify(lastAlias);
        1301. 
-
      1301.                          } else {
        1302. 
-
      1302. 504                            v = val;
        1303. 
-
      1303.                          }
        1304. 
-
      1304. 909                        newExpr.push([k, v]);
        1305. 
-
      1305.                      }
        1306. 
-
      1306. 588                    expr = newExpr;
        1307. 
-
      1307.                  }
        1308. 
-
      1308. 600                if (isFunction(cb)) {
        1309. 
-
      1309. 11                    var expr2 = cb.apply(sql, [tableName, lastAlias, this.__opts.join || []]);
        1310. 
-
      1310. 11                    expr = expr ? new BooleanExpression("AND", expr, expr2) : expr2;
        1311. 
-
      1311.                  }
        1312. 
-
      1312. 600                join = new JoinOnClause(expr, type, table, tableAlias);
        1313. 
-
      1313.              }
        1314. 
-
      1314. 630            var opts = {join: (this.__opts.join || []).concat([join]), lastJoinedTable: tableName};
        1315. 
-
      1315. 630            if (tableAliasNum) {
        1316. 
-
      1316. 6                opts.numDatasetSources = tableAliasNum;
        1317. 
+
      1317.          /**
        1318. 
+
      1318.           * Returns if this model passes validation.
        1319. 
+
      1319.           *
        1320. 
+
      1320.           * @return {Boolean}
        1321. 
+
      1321.           */
        1322. 
+
      1322.          isValid:function () {
        1323. 
+
      1323. 159            return this.validate().length === 0;
        1324. 
+
      1324.          }
        1325. 
+
      1325.      },
        1326. 
+
      1326.  
        1327. 
+
      1327.      "static":{
        1328. 
+
      1328.          /**@lends patio.plugins.ValidatorPlugin*/
        1329. 
+
      1329.  
        1330. 
+
      1330.          /**
        1331. 
+
      1331.           * Set to false to prevent model validation when saving.
        1332. 
+
      1332.           * @default true
        1333. 
+
      1333.           */
        1334. 
+
      1334.          validateOnSave:true,
        1335. 
+
      1335.  
        1336. 
+
      1336.          /**
        1337. 
+
      1337.           * Set to false to prevent model validation when updating.
        1338. 
+
      1338.           * @default true
        1339. 
+
      1339.           */
        1340. 
+
      1340.          validateOnUpdate:true,
        1341. 
+
      1341.  
        1342. 
+
      1342.          init:function () {
        1343. 
+
      1343. 35            this._super(arguments);
        1344. 
+
      1344.          },
        1345. 
+
      1345.  
        1346. 
+
      1346.          __initValidation:function () {
        1347. 
+
      1347. 43            if (!this.__isValidationInited) {
        1348. 
+
      1348. 34                this.validators = [];
        1349. 
+
      1349. 34                this.pre("save", function preSaveValidate(next, opts) {
        1350. 
+
      1350. 114                    validateHook.call(this, this._static.validateOnSave, next, opts);
        1351. 
+
      1351.                  });
        1352. 
+
      1352. 34                this.pre("update", function preUpdateValidate(next, opts) {
        1353. 
+
      1353. 1                    validateHook.call(this, this._static.validateOnSave, next, opts);
        1354. 
+
      1354.                  });
        1355. 
+
      1355. 34                this.__isValidationInited = true;
        1356. 
 
      1356.              }
        1357. 
-
      1357. 630            return this.mergeOptions(opts);
        1358. 
+
      1358.          },
        1359. 
 
      1359.  
        1360. 
+
      1360.          __getValidator:function validator(name) {
        1361. 
+
      1361. 44            var ret = new Validator(name);
        1362. 
+
      1362. 44            this.validators.push(ret);
        1363. 
+
      1363. 44            return ret;
        1364. 
 
      1364.          },
        1365. 
 
      1365.  
        1366. 
 
      1366.          /**
        1367. 
-
      1367.           * If given an integer, the dataset will contain only the first l results.
        1368. 
-
      1368.           If a second argument is given, it is used as an offset. To use
        1369. 
-
      1369.           * an offset without a limit, pass null as the first argument.
        1370. 
+
      1370.           * Sets up validation for a model.
        1371. 
 
      1371.           *
        1372. 
-
      1372.           * @example
        1373. 
+
      1373.           * To do single col validation
        1374. 
+
      1374.           * {@code
        1375. 
 
      1375.           *
        1376. 
-
      1376.           * DB.from("items").limit(10)
        1377. 
-
      1377.           *      //=> SELECT * FROM items LIMIT 10
        1378. 
-
      1378.           * DB.from("items").limit(10, 20)
        1379. 
-
      1379.           *      //=> SELECT * FROM items LIMIT 10 OFFSET 20
        1380. 
-
      1380.           * DB.from("items").limit([3, 7]).sql
        1381. 
-
      1381.           *      //=> SELECT * FROM items LIMIT 5 OFFSET 3');
        1382. 
-
      1382.           * DB.from("items").limit(null, 20)
        1383. 
-
      1383.           *      //=> SELECT * FROM items OFFSET 20
        1384. 
+
      1384.           * var Model = patio.addModel("validator", {
        1385. 
+
      1385.           *      plugins:[ValidatorPlugin]
        1386. 
+
      1386.           * });
        1387. 
+
      1387.           * //this ensures column assignment
        1388. 
+
      1388.           * Model.validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
        1389. 
+
      1389.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
        1390. 
+
      1390.           * Model.validate("col2").like(/hello/ig);
        1391. 
+
      1391.           * //Ensures that the emailAddress column is a valid email address.
        1392. 
+
      1392.           * Model.validate("emailAddress").isEmailAddress();
        1393. 
+
      1393.           * }
        1394. 
 
      1394.           *
        1395. 
-
      1395.           * DB.from("items").limit('6', sql['a() - 1']).sql
        1396. 
-
      1396.           *      => 'SELECT * FROM items LIMIT 6 OFFSET a() - 1');
        1397. 
+
      1397.           * Or you can do a mass validation through a callback.
        1398. 
+
      1398.           * {@code
        1399. 
 
      1399.           *
        1400. 
-
      1400.           * @param {Number|String|Number[]} limit the limit to apply
        1401. 
-
      1401.           * @param {Number|String|patio.sql.LiteralString} offset the offset to apply
        1402. 
+
      1402.           * var Model = patio.addModel("validator", {
        1403. 
+
      1403.           *      plugins:[ValidatorPlugin]
        1404. 
+
      1404.           * });
        1405. 
+
      1405.           * Model.validate(function(validate){
        1406. 
+
      1406.           *      //this ensures column assignment
        1407. 
+
      1407.           *      validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
        1408. 
+
      1408.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
        1409. 
+
      1409.           *      validate("col2").isLike(/hello/ig);
        1410. 
+
      1410.           *      //Ensures that the emailAddress column is a valid email address.
        1411. 
+
      1411.           *      validate("emailAddress").isEmail();
        1412. 
+
      1412.           * });
        1413. 
+
      1413.           * }
        1414. 
 
      1414.           *
        1415. 
-
      1415.           * @return {patio.Dataset}  a cloned dataset witht the LIMIT and OFFSET applied.
        1416. 
-
      1416.           **/
        1417. 
-
      1417.          limit: function (limit, offset) {
        1418. 
-
      1418. 46            if (this.__opts.sql) {
        1419. 
-
      1419. 7                return this.fromSelf().limit(limit, offset);
        1420. 
-
      1420.              }
        1421. 
-
      1421. 39            if (isArray(limit) && limit.length == 2) {
        1422. 
-
      1422. 1                offset = limit[0];
        1423. 
-
      1423. 1                limit = limit[1] - limit[0] + 1;
        1424. 
-
      1424.              }
        1425. 
-
      1425. 39            if (isString(limit) || isInstanceOf(limit, LiteralString)) {
        1426. 
-
      1426. 2                limit = parseInt("" + limit, 10);
        1427. 
-
      1427.              }
        1428. 
-
      1428. 39            if (isNumber(limit) && limit < 1) {
        1429. 
-
      1429. 2                throw new QueryError("Limit must be >= 1");
        1430. 
+
      1430.           *
        1431. 
+
      1431.           * @param {String|Function} name the name of the column, or a callback that accepts a function to create validators.
        1432. 
+
      1432.           *
        1433. 
+
      1433.           * @throws {patio.ModelError} if name is not a function or string.
        1434. 
+
      1434.           * @return {patio.Model|Validator} returns a validator if name is a string, other wise returns this for chaining.
        1435. 
+
      1435.           */
        1436. 
+
      1436.          validate:function (name) {
        1437. 
+
      1437. 43            this.__initValidation();
        1438. 
+
      1438. 43            var ret;
        1439. 
+
      1439. 43            if (isFunction(name)) {
        1440. 
+
      1440. 1                name.apply(this, [this.__getValidator.bind(this)]);
        1441. 
+
      1441. 1                ret = this;
        1442. 
+
      1442. 42            } else if (isString(name)) {
        1443. 
+
      1443. 42                ret = this.__getValidator(name);
        1444. 
+
      1444.              } else {
        1445. 
+
      1445. 0                throw new ModelError("name is must be a string or function when validating");
        1446. 
 
      1446.              }
        1447. 
-
      1447. 37            var opts = {limit: limit};
        1448. 
-
      1448. 37            if (offset) {
        1449. 
-
      1449. 9                if (isString(offset) || isInstanceOf(offset, LiteralString)) {
        1450. 
-
      1450. 1                    offset = parseInt("" + offset, 10);
        1451. 
-
      1451. 1                    isNaN(offset) && (offset = 0);
        1452. 
+
      1452. 43            return ret;
        1453. 
+
      1453.          }
        1454. 
+
      1454.      }
        1455. 
+
      1455.  
        1456. 
+
      1456.  }).as(module);
        1457. 
+
      1457.  
      
+
    + +
    + + + + + +
    +
    dataset/query.js
    +     		+
    + Coverage97.82 + SLOC2347 + LOC458 + Missed10 +
    +
    + 
    1. 1var comb = require("comb"),
      2. 
+
    2.      array = comb.array,
      3. 
+
    3.      flatten = array.flatten,
      4. 
+
    4.      compact = array.compact,
      5. 
+
    5.      define = comb.define,
      6. 
+
    6.      argsToArray = comb.argsToArray,
      7. 
+
    7.      isString = comb.isString,
      8. 
+
    8.      isEmpty = comb.isEmpty,
      9. 
+
    9.      isNull = comb.isNull,
      10. 
+
    10.      isBoolean = comb.isBoolean,
      11. 
+
    11.      isNumber = comb.isNumber,
      12. 
+
    12.      merge = comb.merge,
      13. 
+
    13.      isArray = comb.isArray,
      14. 
+
    14.      isObject = comb.isObject,
      15. 
+
    15.      isFunction = comb.isFunction,
      16. 
+
    16.      isUndefined = comb.isUndefined,
      17. 
+
    17.      isHash = comb.isHash,
      18. 
+
    18.      isInstanceOf = comb.isInstanceOf,
      19. 
+
    19.      sql = require("../sql").sql,
      20. 
+
    20.      LiteralString = sql.LiteralString,
      21. 
+
    21.      Expression = sql.Expression,
      22. 
+
    22.      ComplexExpression = sql.ComplexExpression,
      23. 
+
    23.      BooleanExpression = sql.BooleanExpression,
      24. 
+
    24.      PlaceHolderLiteralString = sql.PlaceHolderLiteralString,
      25. 
+
    25.      Identifier = sql.Identifier,
      26. 
+
    26.      QualifiedIdentifier = sql.QualifiedIdentifier,
      27. 
+
    27.      AliasedExpression = sql.AliasedExpression,
      28. 
+
    28.      StringExpression = sql.StringExpression,
      29. 
+
    29.      NumericExpression = sql.NumericExpression,
      30. 
+
    30.      OrderedExpression = sql.OrderedExpression,
      31. 
+
    31.      JoinClause = sql.JoinClause,
      32. 
+
    32.      JoinOnClause = sql.JoinOnClause,
      33. 
+
    33.      JoinUsingClause = sql.JoinUsingClause,
      34. 
+
    34.      ColumnAll = sql.ColumnAll,
      35. 
+
    35.      QueryError = require("../errors").QueryError;
      36. 
+
    36.  
      37. 
+
    37.  
      38. 
+
    38. 1var Dataset;
      39. 
+
    39.  
      40. 
+
    40. 1function conditionedJoin(type) {
      41. 
+
    41. 539    var args = argsToArray(arguments, 1);
      42. 
+
    42. 539    return this.joinTable.apply(this, [type].concat(args));
      43. 
+
    43.  }
      44. 
+
    44.  
      45. 
+
    45. 1function unConditionJoin(type, table) {
      46. 
+
    46. 6    var args = argsToArray(arguments, 1);
      47. 
+
    47. 6    return this.joinTable.apply(this, [type, table]);
      48. 
+
    48.  }
      49. 
+
    49.  
      50. 
+
    50.  
      51. 
+
    51. 1define(null, {
      52. 
+
    52.      /**@ignore*/
      53. 
+
    53.      instance: {
      54. 
+
    54.  
      55. 
+
    55.          /**@lends patio.Dataset.prototype*/
      56. 
+
    56.  
      57. 
+
    57.          /**
      58. 
+
    58.           * @ignore
      59. 
+
    59.           */
      60. 
+
    60.          constructor: function () {
      61. 
+
    61. 25745            !Dataset && (Dataset = require("../index").Dataset);
      62. 
+
    62. 25745            this._super(arguments);
      63. 
+
    63. 25745            this._static.CONDITIONED_JOIN_TYPES.forEach(function (type) {
      64. 
+
    64. 180215                if (!this[type + "Join"]) {
      65. 
+
    65. 180215                    this[type + "Join"] = conditionedJoin.bind(this, type);
      66. 
 
    66.                  }
      67. 
-
    67. 9                if (isNumber(offset) && offset < 0) {
      68. 
-
    68. 1                    throw new QueryError("Offset must be >= 0");
      69. 
+
    69.  
      70. 
+
    70.              }, this);
      71. 
+
    71. 25745            this._static.UNCONDITIONED_JOIN_TYPES.forEach(function (type) {
      72. 
+
    72. 128725                if (!this[type + "Join"]) {
      73. 
+
    73. 128725                    this[type + "Join"] = unConditionJoin.bind(this, type);
      74. 
 
    74.                  }
      75. 
-
    75. 8                opts.offset = offset;
      76. 
+
    76.  
      77. 
+
    77.              }, this);
      78. 
+
    78.          },
      79. 
+
    79.  
      80. 
+
    80.          /**
      81. 
+
    81.           * Adds a RETURNING clause, which is not supported by all databases. If returning is
      82. 
+
    82.           * used instead of returning the autogenerated primary key or update/delete returning the number of rows modified.
      83. 
+
    83.           *
      84. 
+
    84.           * @example
      85. 
+
    85.           *
      86. 
+
    86.           * ds.from("items").returning() //"RETURNING *"
      87. 
+
    87.           * ds.from("items").returning(null) //"RETURNING NULL"
      88. 
+
    88.           * ds.from("items").returning("id", "name") //"RETURNING id, name"
      89. 
+
    89.           * ds.from("items").returning(["id", "name"]) //"RETURNING id, name"
      90. 
+
    90.           *
      91. 
+
    91.           * @param values columns to return. If values is an array then the array is assumed to contain the columns to
      92. 
+
    92.           * return. Otherwise the arguments will be used.
      93. 
+
    93.           * @return {patio.Dataset} a new dataset with the retuning option added.
      94. 
+
    94.           */
      95. 
+
    95.          returning: function (values) {
      96. 
+
    96. 1087            var args;
      97. 
+
    97. 1087            if (Array.isArray(values)) {
      98. 
+
    98. 0                args = values;
      99. 
+
    99.              } else {
      100. 
+
    100. 1087                args = argsToArray(arguments);
      101. 
 
    101.              }
      102. 
-
    102. 36            return this.mergeOptions(opts);
      103. 
+
    103. 1087            return this.mergeOptions({returning: args.map(function (v) {
      104. 
+
    104. 1005                return isString(v) ? sql.stringToIdentifier(v) : v;
      105. 
+
    105.              })});
      106. 
 
    106.          },
      107. 
 
    107.  
      108. 
+
    108.  
      109. 
 
    109.          /**
      110. 
+
    110.           * Adds a further filter to an existing filter using AND. This method is identical to {@link patio.Dataset#filter}
      111. 
+
    111.           * except it expects an existing filter.
      112. 
 
    112.           *
      113. 
-
    113.           * Returns a cloned dataset with a not equal expression added to the WHERE
      114. 
-
    114.           * clause.
      115. 
+
    115.           * <p>
      116. 
+
    116.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      117. 
+
    117.           * </p>
      118. 
 
    118.           *
      119. 
 
    119.           * @example
      120. 
-
    120.           *  DB.from("test").neq({x : 1});
      121. 
-
    121.           *          //=> SELECT * FROM test WHERE (x != 1)
      122. 
-
    122.           *  DB.from("test").neq({x : 1, y : 10});
      123. 
-
    123.           *          //=> SELECT * FROM test WHERE ((x != 1) AND (y != 10))
      124. 
+
    124.           * DB.from("table").filter("a").and("b").sql;
      125. 
+
    125.           *      //=>SELECT * FROM table WHERE a AND b
      126. 
 
    126.           *
      127. 
-
    127.           * @param {Object} obj object used to create the not equal expression
      128. 
+
    128.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
      129. 
 
    129.           *
      130. 
-
    130.           * @return {patio.Dataset} a cloned dataset with the not equal expression added to the WHERE clause.
      131. 
+
    131.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
      132. 
 
    132.           */
      133. 
-
    133.          neq: function (obj) {
      134. 
-
    134. 2            return this.filter(this.__createBoolExpression("neq", obj));
      135. 
+
    135.          and: function () {
      136. 
+
    136. 7            var tOpts = this.__opts, clauseObj = tOpts[tOpts.having ? "having" : "where"];
      137. 
+
    137. 7            if (clauseObj) {
      138. 
+
    138. 6                return this.filter.apply(this, arguments);
      139. 
+
    139.              } else {
      140. 
+
    140. 1                throw new QueryError("No existing filter found");
      141. 
+
    141.              }
      142. 
+
    142.          },
      143. 
+
    143.  
      144. 
+
    144.          as: function (alias) {
      145. 
+
    145. 8            return new AliasedExpression(this, alias);
      146. 
 
    146.          },
      147. 
 
    147.  
      148. 
 
    148.          /**
      149. 
+
    149.           * Adds an alternate filter to an existing WHERE/HAVING using OR.
      150. 
 
    150.           *
      151. 
-
    151.           * Returns a cloned dataset with an equal expression added to the WHERE
      152. 
-
    152.           * clause.
      153. 
+
    153.           * <p>
      154. 
+
    154.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      155. 
+
    155.           * </p>
      156. 
 
    156.           *
      157. 
 
    157.           * @example
      158. 
-
    158.           *  DB.from("test").eq({x : 1});
      159. 
-
    159.           *          //=> SELECT * FROM test WHERE (x = 1)
      160. 
-
    160.           *  DB.from("test").eq({x : 1, y : 10});
      161. 
-
    161.           *          //=> SELECT * FROM test WHERE ((x = 1) AND (y = 10))
      162. 
 
    162.           *
      163. 
-
    163.           * @param {Object} obj object used to create the equal expression
      164. 
+
    164.           * DB.from("items").filter("a").or("b")
      165. 
+
    165.           *      //=> SELECT * FROM items WHERE a OR b
      166. 
 
    166.           *
      167. 
-
    167.           * @return {patio.Dataset} a cloned dataset with the equal expression added to the WHERE clause.
      168. 
+
    168.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
      169. 
+
    169.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
      170. 
 
    170.           */
      171. 
-
    171.          eq: function (obj) {
      172. 
-
    172. 2            return this.filter(this.__createBoolExpression("eq", obj));
      173. 
+
    173.          or: function () {
      174. 
+
    174. 10            var tOpts = this.__opts;
      175. 
+
    175. 10            var clause = (tOpts.having ? "having" : "where"), clauseObj = tOpts[clause];
      176. 
+
    176. 10            if (clauseObj) {
      177. 
+
    177. 9                var args = argsToArray(arguments);
      178. 
+
    178. 9                args = args.length == 1 ? args[0] : args;
      179. 
+
    179. 9                var opts = {};
      180. 
+
    180. 9                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args));
      181. 
+
    181. 9                return this.mergeOptions(opts);
      182. 
+
    182.              } else {
      183. 
+
    183. 1                throw new QueryError("No existing filter found");
      184. 
+
    184.              }
      185. 
 
    185.          },
      186. 
 
    186.  
      187. 
 
    187.          /**
      188. 
+
    188.           * Adds a group of ORed conditions wrapped in parens, connected to an existing where/having clause by an AND.
      189. 
+
    189.           * If the where/having clause doesn't yet exist, a where clause is created with the ORed group.
      190. 
 
    190.           *
      191. 
-
    191.           * Returns a cloned dataset with a greater than expression added to the WHERE
      192. 
-
    192.           * clause.
      193. 
+
    193.           * <p>
      194. 
+
    194.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      195. 
+
    195.           * </p>
      196. 
 
    196.           *
      197. 
 
    197.           * @example
      198. 
-
    198.           *  DB.from("test").gt({x : 1});
      199. 
-
    199.           *          //=> SELECT * FROM test WHERE (x > 1)
      200. 
-
    200.           *  DB.from("test").gt({x : 1, y : 10});
      201. 
-
    201.           *          //=> SELECT * FROM test WHERE ((x > 1) AND (y > 10))
      202. 
 
    202.           *
      203. 
-
    203.           * @param {Object} obj object used to create the greater than expression.
      204. 
+
    204.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      205. 
+
    205.           *      //=> SELECT
      206. 
+
    206.           *               *
      207. 
+
    207.           *           FROM
      208. 
+
    208.           *               items
      209. 
+
    209.           *           WHERE
      210. 
+
    210.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      211. 
 
    211.           *
      212. 
-
    212.           * @return {patio.Dataset} a cloned dataset with the greater than expression added to the WHERE clause.
      213. 
+
    213.           * DB.from("items").andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      214. 
+
    214.           *      //=> SELECT
      215. 
+
    215.           *               *
      216. 
+
    216.           *           FROM
      217. 
+
    217.           *               items
      218. 
+
    218.           *           WHERE
      219. 
+
    219.           *               ((price < 0) OR (price > 10))
      220. 
+
    220.           *
      221. 
+
    221.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
      222. 
 
    222.           */
      223. 
-
    223.          gt: function (obj) {
      224. 
-
    224. 2            return this.filter(this.__createBoolExpression("gt", obj));
      225. 
+
    225.          andGroupedOr: function (filterExp) {
      226. 
+
    226. 2            return this._addGroupedCondition("AND", "OR", filterExp);
      227. 
 
    227.          },
      228. 
 
    228.  
      229. 
 
    229.          /**
      230. 
+
    230.           * Adds a group of ANDed conditions wrapped in parens to an existing where/having clause by an AND. If there isn't
      231. 
+
    231.           * yet a clause, a where clause is created with the ANDed conditions
      232. 
 
    232.           *
      233. 
-
    233.           * Returns a cloned dataset with a less than expression added to the WHERE
      234. 
-
    234.           * clause.
      235. 
+
    235.           * <p>
      236. 
+
    236.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      237. 
+
    237.           * </p>
      238. 
 
    238.           *
      239. 
 
    239.           * @example
      240. 
-
    240.           *  DB.from("test").lt({x : 1});
      241. 
-
    241.           *          //=> SELECT * FROM test WHERE (x < 1)
      242. 
-
    242.           *  DB.from("test").lt({x : 1, y : 10});
      243. 
-
    243.           *          //=> SELECT * FROM test WHERE ((x < 1) AND (y < 10))
      244. 
 
    244.           *
      245. 
-
    245.           * @param {Object} obj object used to create the less than expression.
      246. 
+
    246.           * DB.from("items").filter({id, [1,2,3]}).andGroupedAnd([{price: {gt : 0}}, {price: {lt: 10}]).sql;
      247. 
+
    247.           *      //=> SELECT
      248. 
+
    248.           *               *
      249. 
+
    249.           *           FROM
      250. 
+
    250.           *               items
      251. 
+
    251.           *           WHERE
      252. 
+
    252.           *               ((id IN (1, 2, 3)) AND ((price > 0) AND (price < 10)))
      253. 
 
    253.           *
      254. 
-
    254.           * @return {patio.Dataset} a cloned dataset with the less than expression added to the WHERE clause.
      255. 
+
    255.           * DB.from("items").andGroupedAnd([{price: {gt : 0}}, {price: {lt: 10}]).sql;
      256. 
+
    256.           *      //=> SELECT
      257. 
+
    257.           *               *
      258. 
+
    258.           *           FROM
      259. 
+
    259.           *               items
      260. 
+
    260.           *           WHERE
      261. 
+
    261.           *               ((price > 0) AND (price < 10))
      262. 
+
    262.           *
      263. 
+
    263.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
      264. 
 
    264.           */
      265. 
-
    265.          lt: function (obj) {
      266. 
-
    266. 2            return this.filter(this.__createBoolExpression("lt", obj));
      267. 
+
    267.          andGroupedAnd: function (filterExp) {
      268. 
+
    268. 2            return this._addGroupedCondition("AND", "AND", filterExp);
      269. 
 
    269.          },
      270. 
 
    270.  
      271. 
 
    271.          /**
      272. 
-
    272.           * Returnes a cloned dataset with the IS NOT expression added to the WHERE
      273. 
-
    273.           * clause.
      274. 
+
    274.           * Adds a group of ANDed conditions wrapped in parens to an existing where/having clause by an OR. If there isn't
      275. 
+
    275.           * a where/having clause, a where clause is created with the ANDed conditions.
      276. 
 
    276.           *
      277. 
-
    277.           * @example
      278. 
+
    278.           * <p>
      279. 
+
    279.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      280. 
+
    280.           * </p>
      281. 
 
    281.           *
      282. 
-
    282.           * DB.from("test").isNot({boolFlag : null});
      283. 
-
    283.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      284. 
-
    284.           * DB.from("test").isNot({boolFlag : false, otherFlag : true, name : null});
      285. 
-
    285.           *      => SELECT * FROM test WHERE ((boolFlag IS NOT FALSE) AND (otherFlag IS NOT TRUE) AND (name IS NOT NULL));
      286. 
+
    286.           * @example
      287. 
 
    287.           *
      288. 
-
    288.           * @param {Object} obj object used to create the IS NOT expression for.
      289. 
+
    289.           * DB.from("items").filter({id, [1,2,3]}).orGroupedAnd([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      290. 
+
    290.           *      //=> SELECT
      291. 
+
    291.           *               *
      292. 
+
    292.           *           FROM
      293. 
+
    293.           *               items
      294. 
+
    294.           *           WHERE
      295. 
+
    295.           *               ((id IN (1, 2, 3)) OR ((price > 0) AND (price < 10)))
      296. 
 
    296.           *
      297. 
-
    297.           * @return {patio.Dataset} a cloned dataset with the IS NOT expression added to the WHERE clause.
      298. 
+
    298.           * DB.from("items").orGroupedAnd([{price: {gt : 0}}, {price: {gt: 10}]).sql;
      299. 
+
    299.           *      //=> SELECT
      300. 
+
    300.           *               *
      301. 
+
    301.           *           FROM
      302. 
+
    302.           *               items
      303. 
+
    303.           *           WHERE
      304. 
+
    304.           *               ((price > 0) AND (price < 10))
      305. 
 
    305.           *
      306. 
+
    306.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
      307. 
 
    307.           */
      308. 
-
    308.          isNot: function (obj) {
      309. 
-
    309. 4            return this.filter(this.__createBoolExpression("isNot", obj));
      310. 
+
    310. 2        orGroupedAnd: function () {var tOpts = this.__opts,
      311. 
+
    311.              clause = (tOpts.having ? "having" : "where"),
      312. 
+
    312.              clauseObj = tOpts[clause];
      313. 
+
    313. 2            if (clauseObj) {
      314. 
+
    314. 1                return this.or.apply(this, arguments);
      315. 
+
    315.              } else {
      316. 
+
    316. 1                var args = argsToArray(arguments);
      317. 
+
    317. 1                args = args.length == 1 ? args[0] : args;
      318. 
+
    318. 1                var opts = {};
      319. 
+
    319. 1                opts[clause] = this._filterExpr(args, null, "AND");
      320. 
+
    320. 1                return this.mergeOptions(opts);
      321. 
+
    321.              }
      322. 
 
    322.          },
      323. 
 
    323.  
      324. 
 
    324.          /**
      325. 
-
    325.           * Returnes a cloned dataset with the IS expression added to the WHERE
      326. 
-
    326.           * clause.
      327. 
+
    327.           * Adds a group of ORed conditions wrapped in parens to an existing having/where clause with an OR. If there isn't
      328. 
+
    328.           * already a clause, a where clause is created with the ORed group.
      329. 
 
    329.           *
      330. 
-
    330.           * @example
      331. 
+
    331.           * <p>
      332. 
+
    332.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      333. 
+
    333.           * </p>
      334. 
 
    334.           *
      335. 
-
    335.           * DB.from("test").is({boolFlag : null});
      336. 
-
    336.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      337. 
-
    337.           * DB.from("test").is({boolFlag : false, otherFlag : true, name : null});
      338. 
-
    338.           *      => SELECT * FROM test WHERE ((boolFlag IS FALSE) AND (otherFlag IS TRUE) AND (name IS NULL));
      339. 
+
    339.           * @example
      340. 
 
    340.           *
      341. 
-
    341.           * @param {Object} obj object used to create the IS expression for.
      342. 
+
    342.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      343. 
+
    343.           *      //=> SELECT
      344. 
+
    344.           *               *
      345. 
+
    345.           *           FROM
      346. 
+
    346.           *               items
      347. 
+
    347.           *           WHERE
      348. 
+
    348.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      349. 
 
    349.           *
      350. 
-
    350.           * @return {patio.Dataset} a cloned dataset with the IS expression added to the WHERE clause.
      351. 
+
    351.           * DB.from("items").orGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      352. 
+
    352.           *      //=> SELECT
      353. 
+
    353.           *               *
      354. 
+
    354.           *           FROM
      355. 
+
    355.           *               items
      356. 
+
    356.           *           WHERE
      357. 
+
    357.           *               ((price < 0) OR (price > 10))
      358. 
 
    358.           *
      359. 
+
    359.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
      360. 
 
    360.           */
      361. 
-
    361.          is: function (obj) {
      362. 
-
    362. 4            return this.filter(this.__createBoolExpression("is", obj));
      363. 
+
    363.          orGroupedOr: function (filterExp) {
      364. 
+
    364. 2            return this._addGroupedCondition("OR", "OR", filterExp);
      365. 
 
    365.          },
      366. 
 
    366.  
      367. 
 
    367.          /**
      368. 
-
    368.           * Returnes a cloned dataset with the IS NOT NULL boolean expression added to the WHERE
      369. 
-
    369.           * clause.
      370. 
+
    370.           * Returns a copy of the dataset with the SQL DISTINCT clause.
      371. 
+
    371.           * The DISTINCT clause is used to remove duplicate rows from the
      372. 
+
    372.           * output.  If arguments are provided, uses a DISTINCT ON clause,
      373. 
+
    373.           * in which case it will only be distinct on those columns, instead
      374. 
+
    374.           * of all returned columns.
      375. 
 
    375.           *
      376. 
 
    376.           * @example
      377. 
 
    377.           *
      378. 
-
    378.           * DB.from("test").isNotNull("boolFlag");
      379. 
-
    379.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      380. 
-
    380.           * DB.from("test").isNotNull("boolFlag", "otherFlag");
      381. 
-
    381.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL AND otherFlag IS NOT NULL);
      382. 
-
    382.           *
      383. 
-
    383.           * @param {String...} arr variable number of arguments to create an IS NOT NULL expression for.
      384. 
-
    384.           *
      385. 
-
    385.           * @return {patio.Dataset} a cloned dataset with the IS NOT NULL expression added to the WHERE clause.
      386. 
+
    386.           * DB.from("items").distinct().sqll
      387. 
+
    387.           *      //=> SELECT DISTINCT * FROM items
      388. 
+
    388.           * DB.from("items").order("id").distinct("id").sql;
      389. 
+
    389.           *      //=> SELECT DISTINCT ON (id) * FROM items ORDER BY id
      390. 
 
    390.           *
      391. 
+
    391.           * @throws {patio.QueryError}  If arguments are given and DISTINCT ON is not supported.
      392. 
+
    392.           * @param {...String|...patio.sql.Identifier} args variable number of arguments used to create
      393. 
+
    393.           *                                                 the DISTINCT ON clause.
      394. 
+
    394.           * @return {patio.Dataset} a cloned dataset with the DISTINCT/DISTINCT ON clause added.
      395. 
 
    395.           */
      396. 
-
    396.          isNotNull: function (arr) {
      397. 
-
    397. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      398. 
-
    398. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      399. 
+
    399.          distinct: function (args) {
      400. 
+
    400. 13            args = argsToArray(arguments);
      401. 
+
    401. 13            if (args.length && !this.supportsDistinctOn) {
      402. 
+
    402. 1                throw new QueryError("DISTICT ON is not supported");
      403. 
+
    403.              }
      404. 
+
    404. 12            args = args.map(function (a) {
      405. 
+
    405. 6                return isString(a) ? new Identifier(a) : a;
      406. 
+
    406.              });
      407. 
+
    407. 12            return this.mergeOptions({distinct: args});
      408. 
 
    408.          },
      409. 
 
    409.  
      410. 
 
    410.          /**
      411. 
-
    411.           * Returnes a cloned dataset with the IS NULL boolean expression added to the WHERE
      412. 
-
    412.           * clause.
      413. 
+
    413.           * Adds an EXCEPT clause using a second dataset object.
      414. 
+
    414.           * An EXCEPT compound dataset returns all rows in the current dataset
      415. 
+
    415.           * that are not in the given dataset.
      416. 
 
    416.           *
      417. 
 
    417.           * @example
      418. 
 
    418.           *
      419. 
-
    419.           * DB.from("test").isNull("boolFlag");
      420. 
-
    420.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      421. 
-
    421.           * DB.from("test").isNull("boolFlag", "otherFlag");
      422. 
-
    422.           *      => SELECT * FROM test WHERE (boolFlag IS NULL AND otherFlag IS NULL);
      423. 
+
    423.           * DB.from("items").except(DB.from("other_items")).sql;
      424. 
+
    424.           *      //=> SELECT * FROM items EXCEPT SELECT * FROM other_items
      425. 
 
    425.           *
      426. 
-
    426.           * @param {String...} arr variable number of arguments to create an IS NULL expression for.
      427. 
+
    427.           * DB.from("items").except(DB.from("other_items"),
      428. 
+
    428.           *                        {all : true, fromSelf : false}).sql;
      429. 
+
    429.           *      //=> SELECT * FROM items EXCEPT ALL SELECT * FROM other_items
      430. 
 
    430.           *
      431. 
-
    431.           * @return {patio.Dataset} a cloned dataset with the IS NULL expression added to the WHERE clause.
      432. 
+
    432.           * DB.from("items").except(DB.from("other_items"),
      433. 
+
    433.           *                        {alias : "i"}).sql;
      434. 
+
    434.           *      //=>SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS i
      435. 
+
    435.           *
      436. 
+
    436.           * @throws {patio.QueryError} if the operation is not supported.
      437. 
+
    437.           * @param {patio.Dataset} dataset the dataset to use to create the EXCEPT clause.
      438. 
+
    438.           * @param {Object} [opts] options to use when creating the EXCEPT clause
      439. 
+
    439.           * @param {String|patio.sql.Identifier} [opt.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias.
      440. 
+
    440.           * @param {Boolean} [opts.all] Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
      441. 
+
    441.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}, use with care.
      442. 
 
    442.           *
      443. 
+
    443.           * @return {patio.Dataset} a cloned dataset with the EXCEPT clause added.
      444. 
 
    444.           */
      445. 
-
    445.          isNull: function (arr) {
      446. 
-
    446. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      447. 
-
    447. 2            return this.filter(this.__createBoolExpression("is", arr));
      448. 
+
    448.          except: function (dataset, opts) {
      449. 
+
    449. 18            opts = isUndefined(opts) ? {} : opts;
      450. 
+
    450. 18            if (!isHash(opts)) {
      451. 
+
    451. 5                opts = {all: true};
      452. 
+
    452.              }
      453. 
+
    453. 18            if (!this.supportsIntersectExcept) {
      454. 
+
    454. 2                throw new QueryError("EXCEPT not supoorted");
      455. 
+
    455. 16            } else if (opts.hasOwnProperty("all") && !this.supportsIntersectExceptAll) {
      456. 
+
    456. 1                throw new QueryError("EXCEPT ALL not supported");
      457. 
+
    457.              }
      458. 
+
    458. 15            return this.compoundClone("except", dataset, opts);
      459. 
 
    459.          },
      460. 
 
    460.  
      461. 
 
    461.          /**
      462. 
-
    462.           * Returnes a cloned dataset with the IS NOT TRUE boolean expression added to the WHERE
      463. 
-
    463.           * clause.
      464. 
+
    464.           * Performs the inverse of {@link patio.Dataset#filter}.  Note that if you have multiple filter
      465. 
+
    465.           * conditions, this is not the same as a negation of all conditions. For argument types see
      466. 
+
    466.           * {@link patio.Dataset#filter}
      467. 
 
    467.           *
      468. 
 
    468.           * @example
      469. 
 
    469.           *
      470. 
-
    470.           * DB.from("test").isNotTrue("boolFlag");
      471. 
-
    471.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE);
      472. 
-
    472.           * DB.from("test").isNotTrue("boolFlag", "otherFlag");
      473. 
-
    473.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE AND otherFlag IS NOT TRUE);
      474. 
-
    474.           *
      475. 
-
    475.           * @param {String...} arr variable number of arguments to create an IS NOT TRUE expression for.
      476. 
-
    476.           *
      477. 
-
    477.           * @return {patio.Dataset} a cloned dataset with the IS NOT TRUE expression added to the WHERE clause.
      478. 
+
    478.           * DB.from("items").exclude({category : "software").sql;
      479. 
+
    479.           *      //=> SELECT * FROM items WHERE (category != 'software')
      480. 
 
    480.           *
      481. 
+
    481.           * DB.from("items").exclude({category : 'software', id : 3}).sql;
      482. 
+
    482.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
      483. 
+
    483.           * @return {patio.Dataset} a cloned dataset with the excluded conditions applied to the HAVING/WHERE clause.
      484. 
 
    484.           */
      485. 
-
    485.          isNotTrue: function (arr) {
      486. 
-
    486. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      487. 
-
    487. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      488. 
+
    488.          exclude: function () {
      489. 
+
    489. 69            var cond = argsToArray(arguments), tOpts = this.__opts;
      490. 
+
    490. 69            var clause = (tOpts["having"] ? "having" : "where"), clauseObj = tOpts[clause];
      491. 
+
    491. 69            cond = cond.length > 1 ? cond : cond[0];
      492. 
+
    492. 69            cond = this._filterExpr.call(this, cond);
      493. 
+
    493. 69            cond = BooleanExpression.invert(cond);
      494. 
+
    494. 69            if (clauseObj) {
      495. 
+
    495. 58                cond = new BooleanExpression("AND", clauseObj, cond)
      496. 
+
    496.              }
      497. 
+
    497. 69            var opts = {};
      498. 
+
    498. 69            opts[clause] = cond;
      499. 
+
    499. 69            return this.mergeOptions(opts);
      500. 
 
    500.          },
      501. 
 
    501.  
      502. 
 
    502.          /**
      503. 
-
    503.           * Returnes a cloned dataset with the IS TRUE boolean expression added to the WHERE
      504. 
-
    504.           * clause.
      505. 
+
    505.           * Returns a copy of the dataset with the given conditions applied to it.
      506. 
+
    506.           * If the query already has a HAVING clause, then the conditions are applied to the
      507. 
+
    507.           * HAVING clause otherwise they are applied to the WHERE clause.
      508. 
 
    508.           *
      509. 
 
    509.           * @example
      510. 
 
    510.           *
      511. 
-
    511.           * DB.from("test").isTrue("boolFlag");
      512. 
-
    512.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE);
      513. 
-
    513.           * DB.from("test").isTrue("boolFlag", "otherFlag");
      514. 
-
    514.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE AND otherFlag IS TRUE);
      515. 
+
    515.           * DB.from("items").filter({id : 3}).sql;
      516. 
+
    516.           *      //=> SELECT * FROM items WHERE (id = 3)
      517. 
 
    517.           *
      518. 
-
    518.           * @param {String...} arr variable number of arguments to create an IS TRUE expression for.
      519. 
+
    519.           * DB.from("items").filter('price < ?', 100)
      520. 
+
    520.           *      //=> SELECT * FROM items WHERE price < 100
      521. 
 
    521.           *
      522. 
-
    522.           * @return {patio.Dataset} a cloned dataset with the IS TRUE expression added to the WHERE clause.
      523. 
+
    523.           * DB.from("items").filter({id, [1,2,3]}).filter({id : {between : [0, 10]}}).sql;
      524. 
+
    524.           *      //=> SELECT
      525. 
+
    525.           *               *
      526. 
+
    526.           *           FROM
      527. 
+
    527.           *               items
      528. 
+
    528.           *           WHERE
      529. 
+
    529.           *               ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))
      530. 
 
    530.           *
      531. 
-
    531.           */
      532. 
-
    532.          isTrue: function (arr) {
      533. 
-
    533. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      534. 
-
    534. 2            return this.filter(this.__createBoolExpression("is", arr));
      535. 
-
    535.          },
      536. 
-
    536.  
      537. 
-
    537.          /**
      538. 
-
    538.           * Returnes a cloned dataset with the IS NOT FALSE boolean expression added to the WHERE
      539. 
-
    539.           * clause.
      540. 
+
    540.           * DB.from("items").filter('price < 100');
      541. 
+
    541.           *      //=> SELECT * FROM items WHERE price < 100
      542. 
 
    542.           *
      543. 
-
    543.           * @example
      544. 
+
    544.           * DB.from("items").filter("active").sql;
      545. 
+
    545.           *      //=> SELECT * FROM items WHERE active
      546. 
 
    546.           *
      547. 
-
    547.           * DB.from("test").isNotFalse("boolFlag");
      548. 
-
    548.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE);
      549. 
-
    549.           * DB.from("test").isNotFalse("boolFlag", "otherFlag");
      550. 
-
    550.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE AND otherFlag IS NOT FALSE);
      551. 
-
    551.           * @param {String...} arr variable number of arguments to create an IS NOT FALSE expression for.
      552. 
+
    552.           * DB.from("items").filter(function(){
      553. 
+
    553.           *      return this.price.lt(100);
      554. 
+
    554.           * });
      555. 
+
    555.           *      //=> SELECT * FROM items WHERE (price < 100)
      556. 
 
    556.           *
      557. 
-
    557.           * @return {patio.Dataset} a cloned dataset with the IS NOT FALSE expression added to the WHERE clause.
      558. 
+
    558.           * //Multiple filter calls can be chained for scoping:
      559. 
+
    559.           * DB.from("items").filter(:category => 'software').filter{price < 100}
      560. 
+
    560.           *      //=> SELECT * FROM items WHERE ((category = 'software') AND (price < 100))
      561. 
 
    561.           *
      562. 
-
    562.           */
      563. 
-
    563.          isNotFalse: function (arr) {
      564. 
-
    564. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      565. 
-
    565. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      566. 
-
    566.          },
      567. 
-
    567.  
      568. 
-
    568.          /**
      569. 
-
    569.           * Returnes a cloned dataset with the IS FALSE boolean expression added to the WHERE
      570. 
-
    570.           * clause.
      571. 
 
    571.           *
      572. 
-
    572.           * @example
      573. 
+
    573.           * @param {Object|Array|String|patio.sql.Identifier|patio.sql.BooleanExpression} args filters to apply to the
      574. 
+
    574.           *  WHERE/HAVING clause. Description of each:
      575. 
+
    575.           *  <ul>
      576. 
+
    576.           *      <li>Hash - list of equality/inclusion expressions</li>
      577. 
+
    577.           *      <li>Array - depends:
      578. 
+
    578.           *          <ul>
      579. 
+
    579.           *              <li>If first member is a string, assumes the rest of the arguments
      580. 
+
    580.           *                  are parameters and interpolates them into the string.</li>
      581. 
+
    581.           *              <li>If all members are arrays of length two, treats the same way
      582. 
+
    582.           *                  as a hash, except it allows for duplicate keys to be
      583. 
+
    583.           *                  specified.</li>
      584. 
+
    584.           *              <li>Otherwise, treats each argument as a separate condition.</li>
      585. 
+
    585.           *           </ul>
      586. 
+
    586.           *       </li>
      587. 
+
    587.           *      <li>String - taken literally</li>
      588. 
+
    588.           *      <li>{@link patio.sql.Identifier} - taken as a boolean column argument (e.g. WHERE active)</li>
      589. 
+
    589.           *      <li>{@link patio.sql.BooleanExpression} - an existing condition expression,
      590. 
+
    590.           *          probably created using the patio.sql methods.
      591. 
+
    591.           *       </li>
      592. 
 
    592.           *
      593. 
-
    593.           * DB.from("test").isFalse("boolFlag");
      594. 
-
    594.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE);
      595. 
-
    595.           * DB.from("test").isFalse("boolFlag", "otherFlag");
      596. 
-
    596.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE AND otherFlag IS FALSE);
      597. 
-
    597.           * @param {String...} arr variable number of arguments to create an IS FALSE expression for.
      598. 
+
    598.           * @param {Function} [cb] filter also takes a cb, which should return one of the above argument
      599. 
+
    599.           * types, and is treated the same way.  This block is called with an {@link patio.sql} object which can be used to dynaically create expression.  For more details
      600. 
+
    600.           * on the sql object see {@link patio.sql}
      601. 
 
    601.           *
      602. 
-
    602.           * @return {patio.Dataset} a cloned dataset with the IS FALSE expression added to the WHERE clause.
      603. 
+
    603.           * <p>
      604. 
+
    604.           *     <b>NOTE:</b>If both a cb and regular arguments are provided, they get ANDed together.
      605. 
+
    605.           * </p>
      606. 
 
    606.           *
      607. 
-
    607.           */
      608. 
-
    608.          isFalse: function (arr) {
      609. 
-
    609. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      610. 
-
    610. 2            return this.filter(this.__createBoolExpression("is", arr));
      611. 
+
    611.           * @return {patio.Dataset} a cloned dataset with the filter arumgents applied to the WHERE/HAVING clause.
      612. 
+
    612.           **/
      613. 
+
    613.          filter: function (args, cb) {
      614. 
+
    614. 3468            args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
      615. 
+
    615. 3468            return this._filter.apply(this, args);
      616. 
 
    616.          },
      617. 
 
    617.  
      618. 
 
    618.          /**
      619. 
-
    619.           *
      620. 
-
    620.           * Returns a cloned dataset with a greater than or equal to expression added to the WHERE
      621. 
-
    621.           * clause.
      622. 
-
    622.           *
      623. 
-
    623.           * @example
      624. 
-
    624.           *  DB.from("test").gte({x : 1});
      625. 
-
    625.           *          //=> SELECT * FROM test WHERE (x >= 1)
      626. 
-
    626.           *  DB.from("test").gte({x : 1, y : 10});
      627. 
-
    627.           *          //=> SELECT * FROM test WHERE ((x >= 1) AND (y >= 10))
      628. 
-
    628.           *
      629. 
-
    629.           * @param {Object} obj object used to create the greater than or equal to expression.
      630. 
-
    630.           *
      631. 
-
    631.           * @return {patio.Dataset} a cloned dataset with the greater than or equal to expression added to the WHERE clause.
      632. 
+
    632.           * @see patio.Dataset#filter
      633. 
 
    633.           */
      634. 
-
    634.          gte: function (arr) {
      635. 
-
    635. 2            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "gte");
      636. 
-
    636. 2            return this.filter(this.__createBoolExpression("gte", arr));
      637. 
+
    637.          find: function () {
      638. 
+
    638. 30            var args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
      639. 
+
    639. 30            return this._filter.apply(this, args);
      640. 
 
    640.          },
      641. 
 
    641.  
      642. 
 
    642.          /**
      643. 
-
    643.           *
      644. 
-
    644.           * Returns a cloned dataset with a less than or equal to expression added to the WHERE
      645. 
-
    645.           * clause.
      646. 
-
    646.           *
      647. 
 
    647.           * @example
      648. 
-
    648.           *  DB.from("test").gte({x : 1});
      649. 
-
    649.           *          //=> SELECT * FROM test WHERE (x <= 1)
      650. 
-
    650.           *  DB.from("test").gte({x : 1, y : 10});
      651. 
-
    651.           *          //=> SELECT * FROM test WHERE ((x <= 1) AND (y <= 10))
      652. 
-
    652.           *
      653. 
-
    653.           * @param {Object} obj object used to create the less than or equal to expression.
      654. 
-
    654.           *
      655. 
-
    655.           * @return {patio.Dataset} a cloned dataset with the less than or equal to expression added to the WHERE clause.
      656. 
+
    656.           * DB.from("table").forUpdate()
      657. 
+
    657.           *          //=> SELECT * FROM table FOR UPDATE
      658. 
+
    658.           * @return {patio.Dataset} a cloned dataset with a "update" lock style.
      659. 
 
    659.           */
      660. 
-
    660.          lte: function (obj) {
      661. 
-
    661. 2            var arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "lte");
      662. 
-
    662. 2            return this.filter(this.__createBoolExpression("lte", obj));
      663. 
+
    663.          forUpdate: function () {
      664. 
+
    664. 1            return this.lockStyle("update");
      665. 
 
    665.          },
      666. 
 
    666.  
      667. 
 
    667.          /**
      668. 
-
    668.           * Returns a cloned dataset with a between clause added
      669. 
-
    669.           * to the where clause.
      670. 
+
    670.           * Returns a copy of the dataset with the source changed. If no
      671. 
+
    671.           * source is given, removes all tables.  If multiple sources
      672. 
+
    672.           * are given, it is the same as using a CROSS JOIN (cartesian product) between all tables.
      673. 
 
    673.           *
      674. 
 
    674.           * @example
      675. 
-
    675.           *  ds.notBetween({x:[1, 2]}).sql;
      676. 
-
    676.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      677. 
+
    677.           * var dataset = DB.from("items");
      678. 
 
    678.           *
      679. 
-
    679.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      680. 
-
    680.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      681. 
-
    681.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      682. 
-
    682.           *                     is the item to be greater than or equal to than and the second item is less than or equal to than.
      683. 
+
    683.           * dataset.from().sql;
      684. 
+
    684.           *      //=> SELECT *
      685. 
 
    685.           *
      686. 
-
    686.           * @return {patio.Dataset} a cloned dataset with a between clause added
      687. 
-
    687.           * to the where clause.
      688. 
-
    688.           */
      689. 
-
    689.          between: function (obj) {
      690. 
-
    690. 2            return this.filter(this.__createBetweenExpression(obj));
      691. 
-
    691.          },
      692. 
-
    692.  
      693. 
-
    693.          /**
      694. 
-
    694.           * Returns a cloned dataset with a not between clause added
      695. 
-
    695.           * to the where clause.
      696. 
+
    696.           * dataset.from("blah").sql
      697. 
+
    697.           *      //=> SELECT * FROM blah
      698. 
 
    698.           *
      699. 
-
    699.           * @example
      700. 
-
    700.           *  ds.notBetween({x:[1, 2]}).sql;
      701. 
-
    701.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      702. 
+
    702.           * dataset.from("blah", "foo")
      703. 
+
    703.           *      //=> SELECT * FROM blah, foo
      704. 
 
    704.           *
      705. 
-
    705.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      706. 
-
    706.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      707. 
-
    707.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      708. 
-
    708.           *                     is the item to be less than and the second item is greater than.
      709. 
+
    709.           * dataset.from({a:"b"}).sql;
      710. 
+
    710.           *      //=> SELECT * FROM a AS b
      711. 
 
    711.           *
      712. 
-
    712.           * @return {patio.Dataset} a cloned dataset with a not between clause added
      713. 
-
    713.           * to the where clause.
      714. 
+
    714.           * dataset.from(dataset.from("a").group("b").as("c")).sql;
      715. 
+
    715.           *          //=> "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
      716. 
+
    716.           *
      717. 
+
    717.           * @param {...String|...patio.sql.Identifier|...patio.Dataset|...Object} [source] tables to select from
      718. 
+
    718.           *
      719. 
+
    719.           * @return {patio.Dataset} a cloned dataset with the FROM clause overridden.
      720. 
 
    720.           */
      721. 
-
    721.          notBetween: function (obj) {
      722. 
-
    722. 2            return this.filter(this.__createBetweenExpression(obj, true));
      723. 
+
    723.          from: function (source) {
      724. 
+
    724. 821            source = argsToArray(arguments);
      725. 
+
    725. 821            var tableAliasNum = 0, sources = [];
      726. 
+
    726. 821            source.forEach(function (s) {
      727. 
+
    727. 1003                if (isInstanceOf(s, Dataset)) {
      728. 
+
    728. 86                    sources.push(new AliasedExpression(s, this._datasetAlias(++tableAliasNum)));
      729. 
+
    729. 917                } else if (isHash(s)) {
      730. 
+
    730. 3                    for (var i in s) {
      731. 
+
    731. 3                        sources.push(new AliasedExpression(new Identifier(i), s[i]));
      732. 
+
    732.                      }
      733. 
+
    733. 914                } else if (isString(s)) {
      734. 
+
    734. 889                    sources.push(this.stringToIdentifier(s))
      735. 
+
    735.                  } else {
      736. 
+
    736. 25                    sources.push(s);
      737. 
+
    737.                  }
      738. 
+
    738.              }, this);
      739. 
+
    739.  
      740. 
+
    740. 821            var o = {from: sources.length ? sources : null}
      741. 
+
    741. 821            if (tableAliasNum) {
      742. 
+
    742. 84                o.numDatasetSources = tableAliasNum;
      743. 
+
    743.              }
      744. 
+
    744. 821            return this.mergeOptions(o)
      745. 
 
    745.          },
      746. 
 
    746.  
      747. 
 
    747.          /**
      748. 
-
    748.           * Returns a cloned dataset with the given lock style.  If style is a
      749. 
-
    749.           * string, it will be used directly.Currently "update" is respected
      750. 
-
    750.           * by most databases, and "share" is supported by some.
      751. 
+
    751.           * Returns a dataset selecting from the current dataset.
      752. 
+
    752.           * Supplying the alias option controls the alias of the result.
      753. 
 
    753.           *
      754. 
 
    754.           * @example
      755. 
-
    755.           * DB.from("items").lockStyle('FOR SHARE') # SELECT * FROM items FOR SHARE
      756. 
 
    756.           *
      757. 
-
    757.           * @param {String} style the lock style to use.
      758. 
+
    758.           * ds = DB.from("items").order("name").select("id", "name")
      759. 
+
    759.           *      //=> SELECT id,name FROM items ORDER BY name
      760. 
 
    760.           *
      761. 
-
    761.           * @return {patio.Dataset} a cloned datase with the given lock style.
      762. 
-
    762.           **/
      763. 
-
    763.          lockStyle: function (style) {
      764. 
-
    764. 4            return this.mergeOptions({lock: style});
      765. 
-
    765.          },
      766. 
-
    766.  
      767. 
-
    767.          /**
      768. 
-
    768.           * Returns a copy of the dataset with the order changed. If the dataset has an
      769. 
-
    769.           * existing order, it is ignored and overwritten with this order. If null is given
      770. 
-
    770.           * the returned dataset has no order. This can accept multiple arguments
      771. 
-
    771.           * of varying kinds, such as SQL functions.  This also takes a function similar
      772. 
-
    772.           * to {@link patio.Dataset#filter}
      773. 
+
    773.           * ds.fromSelf().sql;
      774. 
+
    774.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1
      775. 
 
    775.           *
      776. 
-
    776.           * @example
      777. 
+
    777.           * ds.fromSelf({alias : "foo"}).sql;
      778. 
+
    778.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo
      779. 
 
    779.           *
      780. 
-
    780.           *  DB.from("items").order("name")
      781. 
-
    781.           *          //=> SELECT * FROM items ORDER BY name
      782. 
+
    782.           * @param {Object} [opts] options
      783. 
+
    783.           * @param {String|patio.sql.Identifier} [opts.alias] alias to use
      784. 
 
    784.           *
      785. 
-
    785.           *  DB.from("items").order("a", "b")
      786. 
-
    786.           *          //=> SELECT * FROM items ORDER BY a, b
      787. 
+
    787.           * @return {patio.Dataset} a cloned dataset with the FROM clause set as the current dataset.
      788. 
+
    788.           */
      789. 
+
    789.          fromSelf: function (opts) {
      790. 
+
    790. 84            opts = isUndefined(opts) ? {} : opts;
      791. 
+
    791. 84            var fs = {};
      792. 
+
    792. 84            var nonSqlOptions = this._static.NON_SQL_OPTIONS;
      793. 
+
    793. 84            Object.keys(this.__opts).forEach(function (k) {
      794. 
+
    794. 302                if (nonSqlOptions.indexOf(k) == -1) {
      795. 
+
    795. 302                    fs[k] = null;
      796. 
+
    796.                  }
      797. 
+
    797.              });
      798. 
+
    798. 84            return this.mergeOptions(fs).from(opts["alias"] ? this.as(opts["alias"]) : this);
      799. 
+
    799.          },
      800. 
+
    800.  
      801. 
+
    801.          /**
      802. 
+
    802.           * Match any of the columns to any of the patterns. The terms can be
      803. 
+
    803.           * strings (which use LIKE) or regular expressions (which are only
      804. 
+
    804.           * supported on MySQL and PostgreSQL).  Note that the total number of
      805. 
+
    805.           * pattern matches will be columns[].length * terms[].length,
      806. 
+
    806.           * which could cause performance issues.
      807. 
 
    807.           *
      808. 
-
    808.           *  DB.from("items").order(sql.literal('a + b'))
      809. 
-
    809.           *          //=> SELECT * FROM items ORDER BY a + b
      810. 
+
    810.           * @example
      811. 
 
    811.           *
      812. 
-
    812.           *  DB.from("items").order(sql.identifier("a").plus("b"))
      813. 
-
    813.           *          //=> SELECT * FROM items ORDER BY (a + b)
      814. 
+
    814.           * DB.from("items").grep("a", "%test%").sql;
      815. 
+
    815.           *      //=> SELECT * FROM items WHERE (a LIKE '%test%');
      816. 
 
    816.           *
      817. 
-
    817.           *  DB.from("items").order(sql.identifier("name").desc())
      818. 
-
    818.           *          //=> SELECT * FROM items ORDER BY name DESC
      819. 
+
    819.           * DB.from("items").grep(["a", "b"], ["%test%" "foo"]).sql;
      820. 
+
    820.           *      //=> SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))
      821. 
 
    821.           *
      822. 
-
    822.           *  DB.from("items").order(sql.identifier("name").asc({nulls : "last"))
      823. 
-
    823.           *          //=> SELECT * FROM items ORDER BY name ASC NULLS LAST
      824. 
+
    824.           * DB.from("items").grep(['a', 'b'], ["%foo%", "%bar%"], {allPatterns : true}).sql;
      825. 
+
    825.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
      826. 
 
    826.           *
      827. 
-
    827.           *  DB.from("items").order(function(){
      828. 
-
    828.           *          return this.sum("name").desc();
      829. 
-
    829.           *  }); //=> SELECT * FROM items ORDER BY sum(name) DESC
      830. 
+
    830.           * DB.from("items").grep(["a", "b"], ['%foo%", "%bar%", {allColumns : true})sql;
      831. 
+
    831.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
      832. 
 
    832.           *
      833. 
-
    833.           *  DB.from("items").order(null)
      834. 
-
    834.           *          //=>SELECT * FROM items
      835. 
-
    835.           *  @param arg variable number of arguments similar to {@link patio.Dataset#filter}
      836. 
+
    836.           * DB.from("items").grep(["a", "b"], ["%foo%", "%bar%"], {allPatterns : true, allColumns : true}).sql;
      837. 
+
    837.           *      //=> SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
      838. 
 
    838.           *
      839. 
-
    839.           *  @return {patio.Dataset} a cloned dataset with the order changed.
      840. 
-
    840.           * */
      841. 
-
    841.          order: function (args) {
      842. 
-
    842. 381            args = argsToArray(arguments);
      843. 
-
    843. 381            var order = [];
      844. 
-
    844. 381            args = compact(args).length ? args : null;
      845. 
-
    845. 381            if (args) {
      846. 
-
    846. 263                args.forEach(function (a) {
      847. 
-
    847. 326                    if (isString(a)) {
      848. 
-
    848. 204                        order.push(this.stringToIdentifier(a));
      849. 
-
    849. 122                    } else if (isFunction(a)) {
      850. 
-
    850. 16                        var res = a.apply(sql, [sql]);
      851. 
-
    851. 16                        order = order.concat(isArray(res) ? res : [res]);
      852. 
-
    852.                      } else {
      853. 
-
    853. 106                        order.push(a);
      854. 
-
    854.                      }
      855. 
-
    855.                  }, this);
      856. 
+
    856.           * @param {String[]|patio.sql.Identifier[]} columns columns to search
      857. 
+
    857.           * @param {String|RegExp} patterns patters to search with
      858. 
+
    858.           * @param {Object} [opts] options to use when searching. NOTE If both allColumns and allPatterns are true, all columns must match all patterns
      859. 
+
    859.           * @param {Boolean} [opts.allColumns] All columns must be matched to any of the given patterns.
      860. 
+
    860.           * @param {Boolean} [opts.allPatterns] All patterns must match at least one of the columns.
      861. 
+
    861.           * @param {Boolean} [opts.caseInsensitive] Use a case insensitive pattern match (the default is
      862. 
+
    862.           *                      case sensitive if the database supports it).
      863. 
+
    863.           * @return {patio.Dataset} a dataset with the LIKE clauses added
      864. 
+
    864.           */
      865. 
+
    865.  
      866. 
+
    866.          grep: function (columns, patterns, opts) {
      867. 
+
    867. 15            opts = isUndefined(opts) ? {} : opts;
      868. 
+
    868. 15            var conds;
      869. 
+
    869. 15            if (opts.hasOwnProperty("allPatterns")) {
      870. 
+
    870. 4                conds = array.toArray(patterns).map(function (pat) {
      871. 
+
    871. 8                    return BooleanExpression.fromArgs(
      872. 
+
    872.                          [(opts.allColumns ? "AND" : "OR")]
      873. 
+
    873.                              .concat(array.toArray(columns)
      874. 
+
    874.                                  .map(function (c) {
      875. 
+
    875. 16                                    return StringExpression.like(c, pat, opts);
      876. 
+
    876.                                  })));
      877. 
+
    877.                  });
      878. 
+
    878. 4                return this.filter(BooleanExpression.fromArgs([opts.allPatterns ? "AND" : "OR"].concat(conds)));
      879. 
 
    879.              } else {
      880. 
-
    880. 118                order = null;
      881. 
+
    881. 11                conds = array.toArray(columns)
      882. 
+
    882.                      .map(function (c) {
      883. 
+
    883. 16                        return BooleanExpression.fromArgs(["OR"].concat(array.toArray(patterns).map(function (pat) {
      884. 
+
    884. 26                            return StringExpression.like(c, pat, opts);
      885. 
+
    885.                          })));
      886. 
+
    886.                      });
      887. 
+
    887. 11                return this.filter(BooleanExpression.fromArgs([opts.allColumns ? "AND" : "OR"].concat(conds)));
      888. 
 
    888.              }
      889. 
-
    889. 381            return this.mergeOptions({order: order});
      890. 
 
    890.          },
      891. 
 
    891.  
      892. 
 
    892.          /**
      893. 
-
    893.           * Alias of {@link patio.Dataset#orderMore};
      894. 
+
    894.           * @see patio.Dataset#grep
      895. 
 
    895.           */
      896. 
-
    896.          orderAppend: function () {
      897. 
-
    897. 4            return this.orderMore.apply(this, arguments);
      898. 
+
    898.          like: function () {
      899. 
+
    899. 1            return this.grep.apply(this, arguments);
      900. 
 
    900.          },
      901. 
 
    901.  
      902. 
-
    902.          /**
      903. 
-
    903.           * @see patio.Dataset#order
      904. 
-
    904.           */
      905. 
-
    905.          orderBy: function () {
      906. 
-
    906. 6            return this.order.apply(this, arguments);
      907. 
-
    907.          },
      908. 
 
    908.  
      909. 
 
    909.          /**
      910. 
-
    910.           * Returns a copy of the dataset with the order columns added
      911. 
-
    911.           * to the end of the existing order. For more detail
      912. 
-
    912.           * @see patio.Dataset#order
      913. 
-
    913.           *
      914. 
+
    914.           * Returns a copy of the dataset with the results grouped by the value of
      915. 
+
    915.           * the given columns.
      916. 
 
    916.           * @example
      917. 
+
    917.           *   DB.from("items").group("id")
      918. 
+
    918.           *          //=>SELECT * FROM items GROUP BY id
      919. 
+
    919.           *   DB.from("items").group("id", "name")
      920. 
+
    920.           *          //=> SELECT * FROM items GROUP BY id, name
      921. 
+
    921.           * @param {String...|patio.sql.Identifier...} columns columns to group by.
      922. 
 
    922.           *
      923. 
-
    923.           * DB.from("items").order("a").order("b");
      924. 
-
    924.           *      //=> SELECT * FROM items ORDER BY b
      925. 
-
    925.           *
      926. 
-
    926.           * DB.from("items").order("a").orderMore("b");
      927. 
-
    927.           *      //=>SELECT * FROM items ORDER BY a, b
      928. 
-
    928.           */
      929. 
-
    929.          orderMore: function () {
      930. 
-
    930. 11            var args = argsToArray(arguments);
      931. 
-
    931. 11            if (this.__opts.order) {
      932. 
-
    932. 9                args = this.__opts.order.concat(args);
      933. 
-
    933.              }
      934. 
-
    934. 11            return this.order.apply(this, args);
      935. 
+
    935.           * @return {patio.Dataset} a cloned dataset with the GROUP BY clause added.
      936. 
+
    936.           **/
      937. 
+
    937.          group: function (columns) {
      938. 
+
    938. 32            columns = argsToArray(arguments);
      939. 
+
    939. 32            var stringToIdentifier = this.stringToIdentifier.bind(this)
      940. 
+
    940. 32            return this.mergeOptions({group: (array.compact(columns).length == 0 ? null : columns.map(function (c) {
      941. 
+
    941. 32                return isString(c) ? stringToIdentifier(c) : c;
      942. 
+
    942.              }))});
      943. 
 
    943.          },
      944. 
 
    944.  
      945. 
 
    945.          /**
      946. 
-
    946.           * Returns a copy of the dataset with the order columns added
      947. 
-
    947.           * to the beginning of the existing order. For more detail
      948. 
-
    948.           * @see patio.Dataset#order
      949. 
-
    949.           *
      950. 
-
    950.           * @example
      951. 
-
    951.           * DB.from("items").order("a").order("b");
      952. 
-
    952.           *      //=> SELECT * FROM items ORDER BY b
      953. 
-
    953.           *
      954. 
-
    954.           * DB.from("items").order("a").orderPrepend("b");
      955. 
-
    955.           *      //=>SELECT * FROM items ORDER BY b, a
      956. 
-
    956.           *
      957. 
-
    957.           *
      958. 
-
    958.           **/
      959. 
-
    959.          orderPrepend: function () {
      960. 
-
    960. 4            var ds = this.order.apply(this, arguments);
      961. 
-
    961. 4            return this.__opts.order ? ds.orderMore.apply(ds, this.__opts.order) : ds;
      962. 
+
    962.           * @see patio.Dataset#group
      963. 
+
    963.           */
      964. 
+
    964.          groupBy: function () {
      965. 
+
    965. 10            return this.group.apply(this, arguments);
      966. 
 
    966.          },
      967. 
 
    967.  
      968. 
+
    968.  
      969. 
 
    969.          /**
      970. 
-
    970.           * Qualify to the given table, or {@link patio.Dataset#firstSourceAlias} if not table is given.
      971. 
+
    971.           * Returns a dataset grouped by the given column with count by group.
      972. 
+
    972.           * Column aliases may be supplied, and will be included in the select clause.
      973. 
 
    973.           *
      974. 
 
    974.           * @example
      975. 
-
    975.           * DB.from("items").filter({id : 1}).qualify();
      976. 
-
    976.           *    //=> SELECT items.* FROM items WHERE (items.id = 1)
      977. 
 
    977.           *
      978. 
-
    978.           * DB.from("items").filter({id : 1}).qualify("i");
      979. 
-
    979.           *   //=> SELECT i.* FROM items WHERE (i.id = 1)
      980. 
-
    980.           *
      981. 
-
    981.           * @param {String|patio.sql.Identifier} [table={@link patio.Dataset#firstSourceAlias}] the table name to qualify to.
      982. 
-
    982.           *
      983. 
-
    983.           * @return {patio.Dataset} a cloned dataset qualified to the table or {@link patio.Dataset#firstSourceAlias}
      984. 
-
    984.           **/
      985. 
-
    985.          qualify: function (table) {
      986. 
-
    986. 19            table = table || this.firstSourceAlias;
      987. 
-
    987. 19            return this.qualifyTo(table);
      988. 
-
    988.          },
      989. 
-
    989.  
      990. 
-
    990.          /**
      991. 
-
    991.           * Qualify the dataset to its current first source(first from clause).  This is useful
      992. 
-
    992.           * if you have unqualified identifiers in the query that all refer to
      993. 
-
    993.           * the first source, and you want to join to another table which
      994. 
-
    994.           * has columns with the same name as columns in the current dataset.
      995. 
-
    995.           * See {@link patio.Dataset#qualifyTo}
      996. 
+
    996.           * DB.from("items").groupAndCount("name").all()
      997. 
+
    997.           *      //=> SELECT name, count(*) AS count FROM items GROUP BY name
      998. 
+
    998.           *      //=> [{name : 'a', count : 1}, ...]
      999. 
 
    999.           *
      1000. 
-
    1000.           * @example
      1001. 
+
    1001.           * DB.from("items").groupAndCount("first_name", "last_name").all()
      1002. 
+
    1002.           *      //SELECT first_name, last_name, count(*) AS count FROM items GROUP BY first_name, last_name
      1003. 
+
    1003.           *      //=> [{first_name : 'a', last_name : 'b', count : 1}, ...]
      1004. 
 
    1004.           *
      1005. 
-
    1005.           * DB.from("items").filter({id : 1}).qualifyToFirstSource();
      1006. 
-
    1006.           *      //=> SELECT items.* FROM items WHERE (items.id = 1)
      1007. 
+
    1007.           * DB.from("items").groupAndCount("first_name___name").all()
      1008. 
+
    1008.           *      //=> SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
      1009. 
+
    1009.           *      //=> [{name : 'a', count:1}, ...]
      1010. 
+
    1010.           * @param {String...|patio.sql.Identifier...} columns columns to croup and count on.
      1011. 
 
    1011.           *
      1012. 
-
    1012.           * @return {patio.Dataset} a cloned dataset that is qualified with the first source.
      1013. 
-
    1013.           * */
      1014. 
-
    1014.          qualifyToFirstSource: function () {
      1015. 
-
    1015. 18            return this.qualifyTo(this.firstSourceAlias);
      1016. 
+
    1016.           * @return {patio.Dataset} a cloned dataset with the GROUP clause and count added.
      1017. 
+
    1017.           */
      1018. 
+
    1018.          groupAndCount: function (columns) {
      1019. 
+
    1019. 8            columns = argsToArray(arguments);
      1020. 
+
    1020. 8            var group = this.group.apply(this, columns.map(function (c) {
      1021. 
+
    1021. 9                return this._unaliasedIdentifier(c);
      1022. 
+
    1022.              }, this));
      1023. 
+
    1023. 8            return group.select.apply(group, columns.concat([this._static.COUNT_OF_ALL_AS_COUNT]));
      1024. 
+
    1024.  
      1025. 
 
    1025.          },
      1026. 
 
    1026.  
      1027. 
 
    1027.          /**
      1028. 
-
    1028.           * Return a copy of the dataset with unqualified identifiers in the
      1029. 
-
    1029.           * SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
      1030. 
-
    1030.           * given table. If no columns are currently selected, select all
      1031. 
-
    1031.           * columns of the given table.
      1032. 
+
    1032.           * Returns a copy of the dataset with the HAVING conditions changed. See {@link patio.Dataset#filter} for argument types.
      1033. 
 
    1033.           *
      1034. 
 
    1034.           * @example
      1035. 
-
    1035.           *   DB.from("items").filter({id : 1}).qualifyTo("i");
      1036. 
-
    1036.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      1037. 
-
    1037.           *
      1038. 
-
    1038.           * @param {String} table the name to qualify identifier to.
      1039. 
+
    1039.           * DB.from("items").group("sum").having({sum : 10}).sql;
      1040. 
+
    1040.           *      //=> SELECT * FROM items GROUP BY sum HAVING (sum = 10)
      1041. 
 
    1041.           *
      1042. 
-
    1042.           * @return {patio.Dataset} a cloned dataset with unqualified identifiers qualified.
      1043. 
-
    1043.           */
      1044. 
-
    1044.          qualifyTo: function (table) {
      1045. 
-
    1045. 40            var o = this.__opts;
      1046. 
-
    1046. 40            if (o.sql) {
      1047. 
-
    1047. 2                return this.mergeOptions();
      1048. 
-
    1048.              }
      1049. 
-
    1049. 38            var h = {};
      1050. 
-
    1050. 38            array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
      1051. 
-
    1051. 65                h[k] = this._qualifiedExpression(o[k], table);
      1052. 
+
    1052.           * @return {patio.Dataset} a cloned dataset with HAVING clause changed or added.
      1053. 
+
    1053.           **/
      1054. 
+
    1054.          having: function () {
      1055. 
+
    1055. 12            var cond = argsToArray(arguments).map(function (s) {
      1056. 
+
    1056. 12                return isString(s) && s !== '' ? this.stringToIdentifier(s) : s
      1057. 
 
    1057.              }, this);
      1058. 
-
    1058. 38            if (!o.select || isEmpty(o.select)) {
      1059. 
-
    1059. 14                h.select = [new ColumnAll(table)];
      1060. 
-
    1060.              }
      1061. 
-
    1061. 38            return this.mergeOptions(h);
      1062. 
+
    1062. 12            return this._filter.apply(this, ["having"].concat(cond));
      1063. 
 
    1063.          },
      1064. 
 
    1064.  
      1065. 
 
    1065.          /**
      1066. 
-
    1066.           * Same as {@link patio.Dataset@qualifyTo} except that it forces qualification on methods called
      1067. 
-
    1067.           * after it has been called.
      1068. 
+
    1068.           * Adds an INTERSECT clause using a second dataset object.
      1069. 
+
    1069.           * An INTERSECT compound dataset returns all rows in both the current dataset
      1070. 
+
    1070.           * and the given dataset.
      1071. 
 
    1071.           *
      1072. 
 
    1072.           * @example
      1073. 
 
    1073.           *
      1074. 
-
    1074.           * //qualfyTo would generate
      1075. 
-
    1075.           * DB.from("items").qualifyTo("i").filter({id : 1});
      1076. 
-
    1076.           *      //=> SELECT i.* FROM items WHERE (id = 1)
      1077. 
+
    1077.           * DB.from("items").intersect(DB.from("other_items")).sql;
      1078. 
+
    1078.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS t1
      1079. 
 
    1079.           *
      1080. 
-
    1080.           * //alwaysQualify qualifies filter also.
      1081. 
-
    1081.           * DB.from("items").alwaysQualify("i").filter({id : 1});
      1082. 
-
    1082.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      1083. 
+
    1083.           * DB.from("items").intersect(DB.from("other_items"), {all : true, fromSelf : false}).sql;
      1084. 
+
    1084.           *   //=> SELECT * FROM items INTERSECT ALL SELECT * FROM other_items
      1085. 
 
    1085.           *
      1086. 
+
    1086.           * DB.from("items").intersect(DB.from("other_items"), {alias : "i"}).sql;
      1087. 
+
    1087.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS i
      1088. 
 
    1088.           *
      1089. 
-
    1089.           * @param {String|patio.sql.Identifier} [table=this.firstSourceAlias] the table to qualify to.
      1090. 
-
    1090.           * @return {patio.Dataset} a cloned dataset that will always qualify.
      1091. 
-
    1091.           */
      1092. 
-
    1092.          alwaysQualify: function (table) {
      1093. 
-
    1093. 3            return this.mergeOptions({alwaysQualify: table || this.firstSourceAlias});
      1094. 
+
    1094.           * @throws {patio.QueryError} if the operation is not supported.
      1095. 
+
    1095.           * @param  {patio.Dataset} dataset the dataset to intersect
      1096. 
+
    1096.           * @param  {Object} [opts] options
      1097. 
+
    1097.           * @param {String|patio.sql.Identifier} [opts.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias
      1098. 
+
    1098.           * @param {Boolean} [opts.all] Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
      1099. 
+
    1099.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}.
      1100. 
+
    1100.           *
      1101. 
+
    1101.           * @return {patio.Dataset} a cloned dataset with the INTERSECT clause.
      1102. 
+
    1102.           **/
      1103. 
+
    1103.          intersect: function (dataset, opts) {
      1104. 
+
    1104. 18            opts = isUndefined(opts) ? {} : opts;
      1105. 
+
    1105. 18            if (!isHash(opts)) {
      1106. 
+
    1106. 5                opts = {all: opts};
      1107. 
+
    1107.              }
      1108. 
+
    1108. 18            if (!this.supportsIntersectExcept) {
      1109. 
+
    1109. 2                throw new QueryError("INTERSECT not supported");
      1110. 
+
    1110. 16            } else if (opts.all && !this.supportsIntersectExceptAll) {
      1111. 
+
    1111. 1                throw new QueryError("INTERSECT ALL not supported");
      1112. 
+
    1112.              }
      1113. 
+
    1113. 15            return this.compoundClone("intersect", dataset, opts);
      1114. 
 
    1114.          },
      1115. 
 
    1115.  
      1116. 
-
    1116.  
      1117. 
 
    1117.          /**
      1118. 
-
    1118.           * Returns a copy of the dataset with the order reversed. If no order is
      1119. 
-
    1119.           * given, the existing order is inverted.
      1120. 
+
    1120.           * Inverts the current filter.
      1121. 
 
    1121.           *
      1122. 
 
    1122.           * @example
      1123. 
-
    1123.           * DB.from("items").reverse("id");
      1124. 
-
    1124.           *      //=> SELECT * FROM items ORDER BY id DESC
      1125. 
-
    1125.           *
      1126. 
-
    1126.           * DB.from("items").order("id").reverse();
      1127. 
-
    1127.           *      //=> SELECT * FROM items ORDER BY id DESC
      1128. 
-
    1128.           *
      1129. 
-
    1129.           * DB.from("items").order("id").reverse(sql.identifier("name").asc);
      1130. 
-
    1130.           *      //=> SELECT * FROM items ORDER BY name ASC
      1131. 
-
    1131.           *
      1132. 
-
    1132.           * @param {String|patio.sql.Identifier|Function} args variable number of columns add to order before reversing.
      1133. 
+
    1133.           * DB.from("items").filter({category : 'software'}).invert()
      1134. 
+
    1134.           *      //=> SELECT * FROM items WHERE (category != 'software')
      1135. 
 
    1135.           *
      1136. 
-
    1136.           * @return {patio.Dataset} a cloned dataset with the order reversed.
      1137. 
+
    1137.           * @example
      1138. 
+
    1138.           * DB.from("items").filter({category : 'software', id : 3}).invert()
      1139. 
+
    1139.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
      1140. 
 
    1140.           *
      1141. 
+
    1141.           * @return {patio.Dataset} a cloned dataset with the filter inverted.
      1142. 
 
    1142.           **/
      1143. 
-
    1143.          reverse: function (args) {
      1144. 
-
    1144. 46            args = argsToArray(arguments);
      1145. 
-
    1145. 46            return this.order.apply(this, this._invertOrder(args.length ? args : this.__opts.order));
      1146. 
+
    1146.          invert: function () {
      1147. 
+
    1147. 3            var having = this.__opts.having, where = this.__opts.where;
      1148. 
+
    1148. 3            if (!(having || where)) {
      1149. 
+
    1149. 1                throw new QueryError("No current filter");
      1150. 
+
    1150.              }
      1151. 
+
    1151. 2            var o = {}
      1152. 
+
    1152. 2            if (having) {
      1153. 
+
    1153. 1                o.having = BooleanExpression.invert(having);
      1154. 
+
    1154.              }
      1155. 
+
    1155. 2            if (where) {
      1156. 
+
    1156. 2                o.where = BooleanExpression.invert(where);
      1157. 
+
    1157.              }
      1158. 
+
    1158. 2            return this.mergeOptions(o);
      1159. 
 
    1159.          },
      1160. 
 
    1160.  
      1161. 
 
    1161.          /**
      1162. 
-
    1162.           * @see patio.Dataset#reverse
      1163. 
+
    1163.           * Returns a cloned dataset with an inner join applied.
      1164. 
+
    1164.           *
      1165. 
+
    1165.           * @see patio.Dataset#joinTable
      1166. 
 
    1166.           */
      1167. 
-
    1167.          reverseOrder: function () {
      1168. 
-
    1168. 16            return this.reverse.apply(this, arguments);
      1169. 
+
    1169.          join: function () {
      1170. 
+
    1170. 212            return this.innerJoin.apply(this, arguments);
      1171. 
 
    1171.          },
      1172. 
 
    1172.  
      1173. 
 
    1173.          /**
      1174. 
-
    1174.           * Returns a copy of the dataset with the columns selected changed
      1175. 
-
    1175.           * to the given columns. This also takes a function similar to {@link patio.Dataset#filter}
      1176. 
+
    1176.           * Returns a joined dataset.  Uses the following arguments:
      1177. 
 
    1177.           *
      1178. 
 
    1178.           * @example
      1179. 
-
    1179.           *   DB.from("items").select("a");
      1180. 
-
    1180.           *      //=> SELECT a FROM items
      1181. 
 
    1181.           *
      1182. 
-
    1182.           *   DB.from("items").select("a", "b");
      1183. 
-
    1183.           *      //=> SELECT a, b FROM items
      1184. 
+
    1184.           * DB.from("items").joinTable("leftOuter", "categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
      1185. 
+
    1185.           *      //=>'SELECT
      1186. 
+
    1186.           *             *
      1187. 
+
    1187.           *            FROM
      1188. 
+
    1188.           *              `items`
      1189. 
+
    1189.           *                  LEFT OUTER JOIN
      1190. 
+
    1190.           *              `categories` ON (
      1191. 
+
    1191.           *                          (`categories`.`categoryId` = `items`.`id`)
      1192. 
+
    1192.           *                              AND
      1193. 
+
    1193.           *                          (`categories`.`categoryId` IN (1,2, 3))
      1194. 
+
    1194.           *                          )
      1195. 
+
    1195.           * DB.from("items").leftOuter("categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
      1196. 
+
    1196.           *      //=>'SELECT
      1197. 
+
    1197.           *             *
      1198. 
+
    1198.           *            FROM
      1199. 
+
    1199.           *              `items`
      1200. 
+
    1200.           *                  LEFT OUTER JOIN
      1201. 
+
    1201.           *              `categories` ON (
      1202. 
+
    1202.           *                          (`categories`.`categoryId` = `items`.`id`)
      1203. 
+
    1203.           *                              AND
      1204. 
+
    1204.           *                          (`categories`.`categoryId` IN (1,2, 3))
      1205. 
+
    1205.           *                          )
      1206. 
 
    1206.           *
      1207. 
-
    1207.           *   DB.from("items").select("a", function(){
      1208. 
-
    1208.           *          return this.sum("b")
      1209. 
-
    1209.           *   }).sql;  //=> SELECT a, sum(b) FROM items
      1210. 
+
    1210.           * DB.from("items").leftOuterJoin("categories", {categoryId:"id"}).sql
      1211. 
+
    1211.           *          //=> SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1212. 
 
    1212.           *
      1213. 
-
    1213.           *  @param {String|patio.sql.Identifier|Function} args variable number of colums to select
      1214. 
-
    1214.           *  @return {patio.Dataset} a cloned dataset with the columns selected changed.
      1215. 
-
    1215.           */
      1216. 
-
    1216.          select: function (args) {
      1217. 
-
    1217. 663            args = flatten(argsToArray(arguments));
      1218. 
-
    1218. 663            var columns = [];
      1219. 
-
    1219. 663            args.forEach(function (c) {
      1220. 
-
    1220. 1043                if (isFunction(c)) {
      1221. 
-
    1221. 23                    var res = c.apply(sql, [sql]);
      1222. 
-
    1222. 23                    columns = columns.concat(isArray(res) ? res : [res]);
      1223. 
-
    1223.                  } else {
      1224. 
-
    1224. 1020                    columns.push(c);
      1225. 
-
    1225.                  }
      1226. 
-
    1226.              });
      1227. 
-
    1227. 663            var select = [];
      1228. 
-
    1228. 663            columns.forEach(function (c) {
      1229. 
-
    1229. 1046                if (isHash(c)) {
      1230. 
-
    1230. 3                    for (var i in c) {
      1231. 
-
    1231. 4                        select.push(new AliasedExpression(new Identifier(i), c[i]));
      1232. 
-
    1232.                      }
      1233. 
-
    1233. 1043                } else if (isString(c)) {
      1234. 
-
    1234. 344                    select.push(this.stringToIdentifier(c));
      1235. 
-
    1235.                  } else {
      1236. 
-
    1236. 699                    select.push(c);
      1237. 
-
    1237.                  }
      1238. 
-
    1238.              }, this);
      1239. 
-
    1239. 663            return this.mergeOptions({select: select});
      1240. 
-
    1240.  
      1241. 
-
    1241.          },
      1242. 
-
    1242.  
      1243. 
-
    1243.          /**
      1244. 
-
    1244.           * Returns a cloned dataset that selects *.
      1245. 
+
    1245.           * DB.from("items").rightOuterJoin("categories", {categoryId:"id"}).sql
      1246. 
+
    1246.           *          //=> SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1247. 
 
    1247.           *
      1248. 
-
    1248.           * @return {patio.Dataset}  a cloned dataset that selects *.
      1249. 
-
    1249.           */
      1250. 
-
    1250.          selectAll: function () {
      1251. 
-
    1251. 6            return this.mergeOptions({select: null});
      1252. 
-
    1252.          },
      1253. 
-
    1253.  
      1254. 
-
    1254.          /**
      1255. 
-
    1255.           * Selects the columns if only if there is not already select sources.
      1256. 
+
    1256.           * DB.from("items").fullOuterJoin("categories", {categoryId:"id"}).sql
      1257. 
+
    1257.           *          //=> SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1258. 
 
    1258.           *
      1259. 
-
    1259.           * @example
      1260. 
+
    1260.           * DB.from("items").innerJoin("categories", {categoryId:"id"}).sql
      1261. 
+
    1261.           *          //=> SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1262. 
 
    1262.           *
      1263. 
-
    1263.           * var ds = DB.from("items"); //SELECT * FROM items
      1264. 
+
    1264.           * DB.from("items").leftJoin("categories", {categoryId:"id"}).sql
      1265. 
+
    1265.           *          //=> SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1266. 
 
    1266.           *
      1267. 
-
    1267.           * ds.select("a"); //SELECT a FROM items;
      1268. 
-
    1268.           * ds.select("a").selectIfNoSource("a", "b"). //SELECT a FROM items;
      1269. 
-
    1269.           * ds.selectIfNoSource("a", "b"). //SELECT a, b FROM items;
      1270. 
+
    1270.           * DB.from("items").rightJoin("categories", {categoryId:"id"}).sql
      1271. 
+
    1271.           *          //=> SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1272. 
 
    1272.           *
      1273. 
-
    1273.           * @param cols columns to select if there is not already select sources.
      1274. 
-
    1274.           * @return {patio.Dataset} a cloned dataset with the appropriate select sources.
      1275. 
+
    1275.           * DB.from("items").fullJoin("categories", {categoryId:"id"}).sql
      1276. 
+
    1276.           *          //=> SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1277. 
+
    1277.           *
      1278. 
+
    1278.           * DB.from("items").naturalJoin("categories").sql
      1279. 
+
    1279.           *          //=> SELECT * FROM "items" NATURAL JOIN "categories"
      1280. 
+
    1280.           *
      1281. 
+
    1281.           * DB.from("items").naturalLeftJoin("categories").sql
      1282. 
+
    1282.           *          //=> SELECT * FROM "items" NATURAL LEFT JOIN "categories"
      1283. 
+
    1283.           *
      1284. 
+
    1284.           * DB.from("items").naturalRightJoin("categories").sql
      1285. 
+
    1285.           *          //=> SELECT * FROM "items" NATURAL RIGHT JOIN "categories"
      1286. 
+
    1286.           *
      1287. 
+
    1287.           * DB.from("items").naturalFullJoin("categories").sql
      1288. 
+
    1288.           *          //=> SELECT * FROM "items" NATURAL FULL JOIN "categories"'
      1289. 
+
    1289.           *
      1290. 
+
    1290.           * DB.from("items").crossJoin("categories").sql
      1291. 
+
    1291.           *          //=> SELECT * FROM "items" CROSS JOIN "categories"
      1292. 
+
    1292.           *
      1293. 
+
    1293.           * @param {String} type the type of join to do.
      1294. 
+
    1294.           * @param {String|patio.sql.Identifier|patio.Dataset|Object} table depends on the type.
      1295. 
+
    1295.           *  <ul>
      1296. 
+
    1296.           *      <li>{@link patio.Dataset} - a subselect is performed with an alias</li>
      1297. 
+
    1297.           *      <li>Object - an object that has a tableName property.</li>
      1298. 
+
    1298.           *      <li>String|{@link patio.sql.Identifier}  - the name of the table</li>
      1299. 
+
    1299.           *  </ul>
      1300. 
+
    1300.           * @param [expr] - depends on type
      1301. 
+
    1301.           * <ul>
      1302. 
+
    1302.           *     <li>Object|Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already
      1303. 
+
    1303.           *     qualified), and value (2nd arg) is column of the last joined or primary table (or the
      1304. 
+
    1304.           *     implicitQualifier option</li>.
      1305. 
+
    1305.           *     <li>Array - If all members of the array are string or {@link patio.sql.Identifier}, considers
      1306. 
+
    1306.           *     them as columns and uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
      1307. 
+
    1307.           *     the result set if this is used.</li>
      1308. 
+
    1308.           *     <li>null|undefined(not passed in) - If a cb is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
      1309. 
+
    1309.           *     or CROSS join. If a block is given, uses an ON clause based on the block, see below.</li>
      1310. 
+
    1310.           *     <li>Everything else - pretty much the same as a using the argument in a call to {@link patio.Dataset#filter},
      1311. 
+
    1311.           *     so strings are considered literal, {@link patio.sql.Identifiers} specify boolean columns, and patio.sql
      1312. 
+
    1312.           *      expressions can be used. Uses a JOIN with an ON clause.</li>
      1313. 
+
    1313.           * </ul>
      1314. 
+
    1314.           * @param {Object} options an object of options.
      1315. 
+
    1315.           * @param {String|patio.sql.Identifier} [options.tableAlias=undefined] the name of the table's alias when joining, necessary for joining
      1316. 
+
    1316.           *     to the same table more than once.  No alias is used by default.
      1317. 
+
    1317.           * @param {String|patio.sql.Identifier} [options.implicitQualifier=undefined] The name to use for qualifying implicit conditions.  By default,
      1318. 
+
    1318.           *     the last joined or primary table is used.
      1319. 
+
    1319.           * @param {Function} [cb]  cb - The cb argument should only be given if a JOIN with an ON clause is used,
      1320. 
+
    1320.           *   in which case it is called with
      1321. 
+
    1321.           *   <ul>
      1322. 
+
    1322.           *       <li>table alias/name for the table currently being joined</li>
      1323. 
+
    1323.           *       <li> the table alias/name for the last joined (or first table)
      1324. 
+
    1324.           *       <li>array of previous</li>
      1325. 
+
    1325.           *   </ul>
      1326. 
+
    1326.           *   the cb should return an expression to be used in the ON clause.
      1327. 
+
    1327.           *
      1328. 
+
    1328.           * @return {patio.Dataset} a cloned dataset joined using the arguments.
      1329. 
 
    1329.           */
      1330. 
-
    1330.          selectIfNoSource: function (cols) {
      1331. 
-
    1331. 0            var ret;
      1332. 
-
    1332. 0            if (!this.hasSelectSource) {
      1333. 
-
    1333. 0                ret = this.select.apply(this, arguments);
      1334. 
+
    1334.  
      1335. 
+
    1335.          joinTable: function (type, table, expr, options, cb) {
      1336. 
+
    1336. 634            var args = argsToArray(arguments);
      1337. 
+
    1337. 634            if (isFunction(args[args.length - 1])) {
      1338. 
+
    1338. 12                cb = args[args.length - 1];
      1339. 
+
    1339. 12                args.pop();
      1340. 
+
    1340.              } else {
      1341. 
+
    1341. 622                cb = null;
      1342. 
+
    1342.              }
      1343. 
+
    1343. 634            type = args.shift(), table = args.shift(), expr = args.shift(), options = args.shift();
      1344. 
+
    1344. 634            expr = isUndefined(expr) ? null : expr, options = isUndefined(options) ? {} : options;
      1345. 
+
    1345.  
      1346. 
+
    1346. 634            var h;
      1347. 
+
    1347. 634            var usingJoin = isArray(expr) && expr.length && expr.every(function (x) {
      1348. 
+
    1348. 223                return isString(x) || isInstanceOf(x, Identifier)
      1349. 
+
    1349.              });
      1350. 
+
    1350. 634            if (usingJoin && !this.supportsJoinUsing) {
      1351. 
+
    1351. 1                h = {};
      1352. 
+
    1352. 1                expr.forEach(function (s) {
      1353. 
+
    1353. 1                    h[s] = s;
      1354. 
+
    1354.                  });
      1355. 
+
    1355. 1                return this.joinTable(type, table, h, options);
      1356. 
+
    1356.              }
      1357. 
+
    1357. 633            var tableAlias, lastAlias;
      1358. 
+
    1358. 633            if (isHash(options)) {
      1359. 
+
    1359. 623                tableAlias = options.tableAlias;
      1360. 
+
    1360. 623                lastAlias = options.implicitQualifier;
      1361. 
+
    1361. 10            } else if (isString(options) || isInstanceOf(options, Identifier)) {
      1362. 
+
    1362. 9                tableAlias = options;
      1363. 
+
    1363. 9                lastAlias = null;
      1364. 
+
    1364.              } else {
      1365. 
+
    1365. 1                throw new QueryError("Invalid options format for joinTable %j4", [options]);
      1366. 
+
    1366.              }
      1367. 
+
    1367. 632            var tableAliasNum, tableName;
      1368. 
+
    1368. 632            if (isInstanceOf(table, Dataset)) {
      1369. 
+
    1369. 11                if (!tableAlias) {
      1370. 
+
    1370. 6                    tableAliasNum = (this.__opts.numDatasetSources || 0) + 1;
      1371. 
+
    1371. 6                    tableAlias = this._datasetAlias(tableAliasNum);
      1372. 
+
    1372.                  }
      1373. 
+
    1373. 11                tableName = tableAlias;
      1374. 
+
    1374.              } else {
      1375. 
+
    1375. 621                if (!isUndefined(table.tableName)) {
      1376. 
+
    1376. 1                    table = table.tableName;
      1377. 
+
    1377.                  }
      1378. 
+
    1378. 621                if (isArray(table)) {
      1379. 
+
    1379. 2                    table = table.map(this.stringToIdentifier, this);
      1380. 
+
    1380.                  } else {
      1381. 
+
    1381. 619                    table = isString(table) ? this.stringToIdentifier(table) : table;
      1382. 
+
    1382. 619                    var parts = this._splitAlias(table), implicitTableAlias = parts[1];
      1383. 
+
    1383. 619                    table = parts[0]
      1384. 
+
    1384. 619                    tableAlias = tableAlias || implicitTableAlias;
      1385. 
+
    1385. 619                    tableName = tableAlias || table;
      1386. 
+
    1386.                  }
      1387. 
+
    1387.              }
      1388. 
+
    1388. 632            var join;
      1389. 
+
    1389. 632            if (!expr && !cb) {
      1390. 
+
    1390. 22                join = new JoinClause(type, table, tableAlias);
      1391. 
+
    1391. 610            } else if (usingJoin) {
      1392. 
+
    1392. 9                if (cb) {
      1393. 
+
    1393. 1                    throw new QueryError("cant use a cb if an array is given");
      1394. 
+
    1394.                  }
      1395. 
+
    1395. 8                join = new JoinUsingClause(expr, type, table, tableAlias);
      1396. 
 
    1396.              } else {
      1397. 
-
    1397. 0                ret = this.mergeOptions();
      1398. 
+
    1398. 601                lastAlias = lastAlias || this.__opts["lastJoinedTable"] || this.firstSourceAlias;
      1399. 
+
    1399. 600                if (Expression.isConditionSpecifier(expr)) {
      1400. 
+
    1400. 588                    var newExpr = [];
      1401. 
+
    1401. 588                    for (var i in expr) {
      1402. 
+
    1402. 909                        var val = expr[i];
      1403. 
+
    1403. 909                        if (isArray(val) && val.length == 2) {
      1404. 
+
    1404. 418                            i = val[0], val = val[1];
      1405. 
+
    1405.                          }
      1406. 
+
    1406. 909                        var k = this.qualifiedColumnName(i, tableName), v;
      1407. 
+
    1407. 909                        if (isInstanceOf(val, Identifier)) {
      1408. 
+
    1408. 405                            v = val.qualify(lastAlias);
      1409. 
+
    1409.                          } else {
      1410. 
+
    1410. 504                            v = val;
      1411. 
+
    1411.                          }
      1412. 
+
    1412. 909                        newExpr.push([k, v]);
      1413. 
+
    1413.                      }
      1414. 
+
    1414. 588                    expr = newExpr;
      1415. 
+
    1415.                  }
      1416. 
+
    1416. 600                if (isFunction(cb)) {
      1417. 
+
    1417. 11                    var expr2 = cb.apply(sql, [tableName, lastAlias, this.__opts.join || []]);
      1418. 
+
    1418. 11                    expr = expr ? new BooleanExpression("AND", expr, expr2) : expr2;
      1419. 
+
    1419.                  }
      1420. 
+
    1420. 600                join = new JoinOnClause(expr, type, table, tableAlias);
      1421. 
 
    1421.              }
      1422. 
-
    1422. 0            return ret;
      1423. 
+
    1423. 630            var opts = {join: (this.__opts.join || []).concat([join]), lastJoinedTable: tableName};
      1424. 
+
    1424. 630            if (tableAliasNum) {
      1425. 
+
    1425. 6                opts.numDatasetSources = tableAliasNum;
      1426. 
+
    1426.              }
      1427. 
+
    1427. 630            return this.mergeOptions(opts);
      1428. 
+
    1428.  
      1429. 
 
    1429.          },
      1430. 
 
    1430.  
      1431. 
 
    1431.          /**
      1432. 
-
    1432.           * Returns a copy of the dataset with the given columns added
      1433. 
-
    1433.           * to the existing selected columns. If no columns are currently selected,
      1434. 
-
    1434.           * it will select the columns given in addition to *.
      1435. 
+
    1435.           * If given an integer, the dataset will contain only the first l results.
      1436. 
+
    1436.           If a second argument is given, it is used as an offset. To use
      1437. 
+
    1437.           * an offset without a limit, pass null as the first argument.
      1438. 
 
    1438.           *
      1439. 
 
    1439.           * @example
      1440. 
-
    1440.           *   DB.from("items").select("a").selectAppend("b").sql;
      1441. 
-
    1441.           *      //=> SELECT b FROM items
      1442. 
 
    1442.           *
      1443. 
-
    1443.           *   DB.from("items").select("a").selectAppend("b", "c", "d").sql
      1444. 
-
    1444.           *      //=> SELECT a, b, c, d FROM items
      1445. 
+
    1445.           * DB.from("items").limit(10)
      1446. 
+
    1446.           *      //=> SELECT * FROM items LIMIT 10
      1447. 
+
    1447.           * DB.from("items").limit(10, 20)
      1448. 
+
    1448.           *      //=> SELECT * FROM items LIMIT 10 OFFSET 20
      1449. 
+
    1449.           * DB.from("items").limit([3, 7]).sql
      1450. 
+
    1450.           *      //=> SELECT * FROM items LIMIT 5 OFFSET 3');
      1451. 
+
    1451.           * DB.from("items").limit(null, 20)
      1452. 
+
    1452.           *      //=> SELECT * FROM items OFFSET 20
      1453. 
 
    1453.           *
      1454. 
-
    1454.           *   DB.from("items").selectAppend("b").sql
      1455. 
-
    1455.           *      //=> SELECT *, b FROM items
      1456. 
+
    1456.           * DB.from("items").limit('6', sql['a() - 1']).sql
      1457. 
+
    1457.           *      => 'SELECT * FROM items LIMIT 6 OFFSET a() - 1');
      1458. 
 
    1458.           *
      1459. 
-
    1459.           * @param [...] cols variable number of columns to add to the select statement
      1460. 
+
    1460.           * @param {Number|String|Number[]} limit the limit to apply
      1461. 
+
    1461.           * @param {Number|String|patio.sql.LiteralString} offset the offset to apply
      1462. 
 
    1462.           *
      1463. 
-
    1463.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      1464. 
-
    1464.           */
      1465. 
-
    1465.          selectAppend: function (cols) {
      1466. 
-
    1466. 7            cols = argsToArray(arguments);
      1467. 
-
    1467. 7            var currentSelect = this.__opts.select;
      1468. 
-
    1468. 7            if (!currentSelect || !currentSelect.length) {
      1469. 
-
    1469. 3                currentSelect = [this._static.WILDCARD];
      1470. 
+
    1470.           * @return {patio.Dataset}  a cloned dataset witht the LIMIT and OFFSET applied.
      1471. 
+
    1471.           **/
      1472. 
+
    1472.          limit: function (limit, offset) {
      1473. 
+
    1473. 46            if (this.__opts.sql) {
      1474. 
+
    1474. 7                return this.fromSelf().limit(limit, offset);
      1475. 
 
    1475.              }
      1476. 
-
    1476. 7            return this.select.apply(this, currentSelect.concat(cols));
      1477. 
+
    1477. 39            if (isArray(limit) && limit.length == 2) {
      1478. 
+
    1478. 1                offset = limit[0];
      1479. 
+
    1479. 1                limit = limit[1] - limit[0] + 1;
      1480. 
+
    1480.              }
      1481. 
+
    1481. 39            if (isString(limit) || isInstanceOf(limit, LiteralString)) {
      1482. 
+
    1482. 2                limit = parseInt("" + limit, 10);
      1483. 
+
    1483.              }
      1484. 
+
    1484. 39            if (isNumber(limit) && limit < 1) {
      1485. 
+
    1485. 2                throw new QueryError("Limit must be >= 1");
      1486. 
+
    1486.              }
      1487. 
+
    1487. 37            var opts = {limit: limit};
      1488. 
+
    1488. 37            if (offset) {
      1489. 
+
    1489. 9                if (isString(offset) || isInstanceOf(offset, LiteralString)) {
      1490. 
+
    1490. 1                    offset = parseInt("" + offset, 10);
      1491. 
+
    1491. 1                    isNaN(offset) && (offset = 0);
      1492. 
+
    1492.                  }
      1493. 
+
    1493. 9                if (isNumber(offset) && offset < 0) {
      1494. 
+
    1494. 1                    throw new QueryError("Offset must be >= 0");
      1495. 
+
    1495.                  }
      1496. 
+
    1496. 8                opts.offset = offset;
      1497. 
+
    1497.              }
      1498. 
+
    1498. 36            return this.mergeOptions(opts);
      1499. 
 
    1499.          },
      1500. 
 
    1500.  
      1501. 
 
    1501.          /**
      1502. 
-
    1502.           * Returns a copy of the dataset with the given columns added
      1503. 
-
    1503.           * to the existing selected columns. If no columns are currently selected
      1504. 
-
    1504.           * it will just select the columns given.
      1505. 
-
    1505.           *
      1506. 
-
    1506.           * @example
      1507. 
-
    1507.           *   DB.from("items").select("a").select("b").sql;
      1508. 
-
    1508.           *      //=> SELECT b FROM items
      1509. 
 
    1509.           *
      1510. 
-
    1510.           *   DB.from("items").select("a").selectMore("b", "c", "d").sql
      1511. 
-
    1511.           *      //=> SELECT a, b, c, d FROM items
      1512. 
+
    1512.           * Returns a cloned dataset with a not equal expression added to the WHERE
      1513. 
+
    1513.           * clause.
      1514. 
 
    1514.           *
      1515. 
-
    1515.           *   DB.from("items").selectMore("b").sql
      1516. 
-
    1516.           *      //=> SELECT b FROM items
      1517. 
+
    1517.           * @example
      1518. 
+
    1518.           *  DB.from("test").neq({x : 1});
      1519. 
+
    1519.           *          //=> SELECT * FROM test WHERE (x != 1)
      1520. 
+
    1520.           *  DB.from("test").neq({x : 1, y : 10});
      1521. 
+
    1521.           *          //=> SELECT * FROM test WHERE ((x != 1) AND (y != 10))
      1522. 
 
    1522.           *
      1523. 
-
    1523.           * @param [...] cols variable number of columns to add to the select statement
      1524. 
+
    1524.           * @param {Object} obj object used to create the not equal expression
      1525. 
 
    1525.           *
      1526. 
-
    1526.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      1527. 
+
    1527.           * @return {patio.Dataset} a cloned dataset with the not equal expression added to the WHERE clause.
      1528. 
 
    1528.           */
      1529. 
-
    1529.          selectMore: function (cols) {
      1530. 
-
    1530. 10            cols = argsToArray(arguments);
      1531. 
-
    1531. 10            var currentSelect = this.__opts.select;
      1532. 
-
    1532. 10            return this.select.apply(this, (currentSelect || []).concat(cols));
      1533. 
+
    1533.          neq: function (obj) {
      1534. 
+
    1534. 2            return this.filter(this.__createBoolExpression("neq", obj));
      1535. 
 
    1535.          },
      1536. 
 
    1536.  
      1537. 
 
    1537.          /**
      1538. 
-
    1538.           * Set the default values for insert and update statements.  The values hash passed
      1539. 
-
    1539.           * to insert or update are merged into this hash, so any values in the hash passed
      1540. 
-
    1540.           * to insert or update will override values passed to this method.
      1541. 
-
    1541.           *
      1542. 
-
    1542.           *  @example
      1543. 
-
    1543.           *   DB.from("items").setDefaults({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      1544. 
-
    1544.           *      //=> INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
      1545. 
-
    1545.           *
      1546. 
-
    1546.           * @param {Object} hash object with key value pairs to use as override values
      1547. 
 
    1547.           *
      1548. 
-
    1548.           * @return {patio.Dataset} a cloned dataset with the defaults added to the current datasets defaults.
      1549. 
-
    1549.           */
      1550. 
-
    1550.          setDefaults: function (hash) {
      1551. 
-
    1551. 5            return this.mergeOptions({defaults: merge({}, this.__opts.defaults || {}, hash)});
      1552. 
-
    1552.          },
      1553. 
-
    1553.  
      1554. 
-
    1554.          /**
      1555. 
-
    1555.           * Set values that override hash arguments given to insert and update statements.
      1556. 
-
    1556.           * This hash is merged into the hash provided to insert or update, so values
      1557. 
-
    1557.           * will override any values given in the insert/update hashes.
      1558. 
+
    1558.           * Returns a cloned dataset with an equal expression added to the WHERE
      1559. 
+
    1559.           * clause.
      1560. 
 
    1560.           *
      1561. 
 
    1561.           * @example
      1562. 
-
    1562.           *   DB.from("items").setOverrides({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      1563. 
-
    1563.           *      //=> INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
      1564. 
+
    1564.           *  DB.from("test").eq({x : 1});
      1565. 
+
    1565.           *          //=> SELECT * FROM test WHERE (x = 1)
      1566. 
+
    1566.           *  DB.from("test").eq({x : 1, y : 10});
      1567. 
+
    1567.           *          //=> SELECT * FROM test WHERE ((x = 1) AND (y = 10))
      1568. 
 
    1568.           *
      1569. 
-
    1569.           * @param {Object} hash object with key value pairs to use as override values
      1570. 
+
    1570.           * @param {Object} obj object used to create the equal expression
      1571. 
 
    1571.           *
      1572. 
-
    1572.           * @return {patio.Dataset} a cloned dataset with the overrides added to the current datasets overrides.
      1573. 
+
    1573.           * @return {patio.Dataset} a cloned dataset with the equal expression added to the WHERE clause.
      1574. 
 
    1574.           */
      1575. 
-
    1575.          setOverrides: function (hash) {
      1576. 
-
    1576. 5            return this.mergeOptions({overrides: merge({}, this.__opts.overrides || {}, hash)});
      1577. 
+
    1577.          eq: function (obj) {
      1578. 
+
    1578. 2            return this.filter(this.__createBoolExpression("eq", obj));
      1579. 
 
    1579.          },
      1580. 
 
    1580.  
      1581. 
 
    1581.          /**
      1582. 
-
    1582.           * Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
      1583. 
-
    1583.           * @example
      1584. 
-
    1584.           *  DB.from("items").group("a").having({a : 1}).where("b").unfiltered().sql;
      1585. 
-
    1585.           *      //=> SELECT * FROM items GROUP BY a
      1586. 
 
    1586.           *
      1587. 
-
    1587.           * @return {patio.Dataset} a cloned dataset with no HAVING or WHERE clause.
      1588. 
-
    1588.           */
      1589. 
-
    1589.          unfiltered: function () {
      1590. 
-
    1590. 14            return this.mergeOptions({where: null, having: null});
      1591. 
-
    1591.          },
      1592. 
-
    1592.  
      1593. 
-
    1593.          /**
      1594. 
-
    1594.           * Returns a copy of the dataset with no GROUP or HAVING clause.
      1595. 
+
    1595.           * Returns a cloned dataset with a greater than expression added to the WHERE
      1596. 
+
    1596.           * clause.
      1597. 
 
    1597.           *
      1598. 
 
    1598.           * @example
      1599. 
-
    1599.           *  DB.from("t").group("a").having({a : 1}).where("b").ungrouped().sql;
      1600. 
-
    1600.           *      //=> SELECT * FROM t WHERE b
      1601. 
+
    1601.           *  DB.from("test").gt({x : 1});
      1602. 
+
    1602.           *          //=> SELECT * FROM test WHERE (x > 1)
      1603. 
+
    1603.           *  DB.from("test").gt({x : 1, y : 10});
      1604. 
+
    1604.           *          //=> SELECT * FROM test WHERE ((x > 1) AND (y > 10))
      1605. 
 
    1605.           *
      1606. 
-
    1606.           * @return {patio.Dataset} a cloned dataset with no GROUP or HAVING clause.
      1607. 
+
    1607.           * @param {Object} obj object used to create the greater than expression.
      1608. 
+
    1608.           *
      1609. 
+
    1609.           * @return {patio.Dataset} a cloned dataset with the greater than expression added to the WHERE clause.
      1610. 
 
    1610.           */
      1611. 
-
    1611.          ungrouped: function () {
      1612. 
-
    1612. 1            return this.mergeOptions({group: null, having: null});
      1613. 
+
    1613.          gt: function (obj) {
      1614. 
+
    1614. 2            return this.filter(this.__createBoolExpression("gt", obj));
      1615. 
 
    1615.          },
      1616. 
 
    1616.  
      1617. 
 
    1617.          /**
      1618. 
-
    1618.           * Adds a UNION clause using a second dataset object.
      1619. 
-
    1619.           * A UNION compound dataset returns all rows in either the current dataset
      1620. 
-
    1620.           * or the given dataset.
      1621. 
-
    1621.           * Options:
      1622. 
-
    1622.           * :alias :: Use the given value as the from_self alias
      1623. 
-
    1623.           * :all :: Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
      1624. 
-
    1624.           * :from_self :: Set to false to not wrap the returned dataset in a from_self, use with care.
      1625. 
-
    1625.           *
      1626. 
-
    1626.           * @example
      1627. 
-
    1627.           * DB.from("items").union(DB.from("otherItems")).sql;
      1628. 
-
    1628.           *      //=> SELECT * FROM items UNION SELECT * FROM other_items
      1629. 
-
    1629.           *
      1630. 
-
    1630.           * DB.from("items").union(DB.from("otherItems"), {all : true, fromSelf : false}).sql;
      1631. 
-
    1631.           *      //=> SELECT * FROM items UNION ALL SELECT * FROM other_items
      1632. 
 
    1632.           *
      1633. 
-
    1633.           * DB.from("items").union(DB.from("otherItems"), {alias : "i"})
      1634. 
-
    1634.           *      //=> SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS i
      1635. 
+
    1635.           * Returns a cloned dataset with a less than expression added to the WHERE
      1636. 
+
    1636.           * clause.
      1637. 
 
    1637.           *
      1638. 
-
    1638.           * @param {patio.Dataset} dataset dataset to union with
      1639. 
-
    1639.           * @param {Object} opts addional options
      1640. 
-
    1640.           * @param {String|patio.sql.Identifier} [opts.alias] Alias to use as the fromSelf alias.
      1641. 
-
    1641.           * @param {Boolean} [opt.all=false] Set to true to use UNION ALL instead of UNION so duplicate rows can occur
      1642. 
-
    1642.           * @param {Boolean} [opts.fromSelf=true] Set to false to not wrap the returned dataset in a fromSelf.
      1643. 
+
    1643.           * @example
      1644. 
+
    1644.           *  DB.from("test").lt({x : 1});
      1645. 
+
    1645.           *          //=> SELECT * FROM test WHERE (x < 1)
      1646. 
+
    1646.           *  DB.from("test").lt({x : 1, y : 10});
      1647. 
+
    1647.           *          //=> SELECT * FROM test WHERE ((x < 1) AND (y < 10))
      1648. 
 
    1648.           *
      1649. 
-
    1649.           * @return {patio.Dataset} a cloned dataset with the union.
      1650. 
+
    1650.           * @param {Object} obj object used to create the less than expression.
      1651. 
 
    1651.           *
      1652. 
+
    1652.           * @return {patio.Dataset} a cloned dataset with the less than expression added to the WHERE clause.
      1653. 
 
    1653.           */
      1654. 
-
    1654.          union: function (dataset, opts) {
      1655. 
-
    1655. 21            opts = isUndefined(opts) ? {} : opts;
      1656. 
-
    1656. 21            if (!isHash(opts)) {
      1657. 
-
    1657. 3                opts = {all: opts};
      1658. 
-
    1658.              }
      1659. 
-
    1659. 21            return this.compoundClone("union", dataset, opts);
      1660. 
+
    1660.          lt: function (obj) {
      1661. 
+
    1661. 2            return this.filter(this.__createBoolExpression("lt", obj));
      1662. 
 
    1662.          },
      1663. 
 
    1663.  
      1664. 
 
    1664.          /**
      1665. 
-
    1665.           * Returns a copy of the dataset with no limit or offset.
      1666. 
+
    1666.           * Returnes a cloned dataset with the IS NOT expression added to the WHERE
      1667. 
+
    1667.           * clause.
      1668. 
 
    1668.           *
      1669. 
 
    1669.           * @example
      1670. 
-
    1670.           *  DB.from("t").limit(10, 20).unlimited().sql;
      1671. 
-
    1671.           *      //=> SELECT * FROM t
      1672. 
-
    1672.           *
      1673. 
-
    1673.           * @return {patio.Dataset} a cloned dataset with no limit or offset.
      1674. 
-
    1674.           */
      1675. 
-
    1675.          unlimited: function () {
      1676. 
-
    1676. 1            return this.mergeOptions({limit: null, offset: null});
      1677. 
-
    1677.          },
      1678. 
-
    1678.  
      1679. 
-
    1679.          /**
      1680. 
-
    1680.           * Returns a copy of the dataset with no order.
      1681. 
 
    1681.           *
      1682. 
-
    1682.           * @example
      1683. 
-
    1683.           *  DB.from("t").order("a", sql.identifier("b").desc()).unordered().sql;
      1684. 
-
    1684.           *      //=> SELECT * FROM t
      1685. 
+
    1685.           * DB.from("test").isNot({boolFlag : null});
      1686. 
+
    1686.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      1687. 
+
    1687.           * DB.from("test").isNot({boolFlag : false, otherFlag : true, name : null});
      1688. 
+
    1688.           *      => SELECT * FROM test WHERE ((boolFlag IS NOT FALSE) AND (otherFlag IS NOT TRUE) AND (name IS NOT NULL));
      1689. 
 
    1689.           *
      1690. 
-
    1690.           * @return {patio.Dataset} a cloned dataset with no order.
      1691. 
-
    1691.           */
      1692. 
-
    1692.          unordered: function () {
      1693. 
-
    1693. 115            return this.order(null);
      1694. 
-
    1694.          },
      1695. 
-
    1695.  
      1696. 
-
    1696.          /**
      1697. 
-
    1697.           * Add a condition to the WHERE clause.  See {@link patio.Dataset#filter} for argument types.
      1698. 
+
    1698.           * @param {Object} obj object used to create the IS NOT expression for.
      1699. 
 
    1699.           *
      1700. 
-
    1700.           * @example
      1701. 
-
    1701.           *   DB.from("test").where('price < ? AND id in ?', 100, [1, 2, 3]).sql;
      1702. 
-
    1702.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
      1703. 
-
    1703.           *   DB.from("test").where('price < {price} AND id in {ids}', {price:100, ids:[1, 2, 3]}).sql;
      1704. 
-
    1704.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))")
      1705. 
+
    1705.           * @return {patio.Dataset} a cloned dataset with the IS NOT expression added to the WHERE clause.
      1706. 
 
    1706.           *
      1707. 
 
    1707.           */
      1708. 
-
    1708.          where: function () {
      1709. 
-
    1709. 252            return this._filter.apply(this, ["where"].concat(argsToArray(arguments)));
      1710. 
+
    1710.          isNot: function (obj) {
      1711. 
+
    1711. 4            return this.filter(this.__createBoolExpression("isNot", obj));
      1712. 
 
    1712.          },
      1713. 
 
    1713.  
      1714. 
 
    1714.          /**
      1715. 
-
    1715.           * Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
      1716. 
-
    1716.           * A common table expression acts as an inline view for the query.
      1717. 
+
    1717.           * Returnes a cloned dataset with the IS expression added to the WHERE
      1718. 
+
    1718.           * clause.
      1719. 
 
    1719.           *
      1720. 
-
    1720.           * @name with
      1721. 
 
    1721.           * @example
      1722. 
 
    1722.           *
      1723. 
-
    1723.           * DB.from("t")["with"]("t", db.from("x"))["with"]("j", db.from("y")).sql;
      1724. 
-
    1724.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y) SELECT * FROM t'
      1725. 
-
    1725.           *
      1726. 
-
    1726.           * DB.from("t")["with"]("t", db.from("x")).withRecursive("j", db.from("y"), db.from("j")).sql;
      1727. 
-
    1727.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
      1728. 
+
    1728.           * DB.from("test").is({boolFlag : null});
      1729. 
+
    1729.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      1730. 
+
    1730.           * DB.from("test").is({boolFlag : false, otherFlag : true, name : null});
      1731. 
+
    1731.           *      => SELECT * FROM test WHERE ((boolFlag IS FALSE) AND (otherFlag IS TRUE) AND (name IS NULL));
      1732. 
 
    1732.           *
      1733. 
-
    1733.           * DB.from("t")["with"]("t", db.from("x"), {args:["b"]}).sql;
      1734. 
-
    1734.           *      //=> 'WITH t(b) AS (SELECT * FROM x) SELECT * FROM t'
      1735. 
+
    1735.           * @param {Object} obj object used to create the IS expression for.
      1736. 
 
    1736.           *
      1737. 
-
    1737.           * @param {String} name the name of the to assign to the CTE.
      1738. 
-
    1738.           * @param {patio.Dataset} dataset the dataset to use for the CTE.
      1739. 
-
    1739.           * @param {Object} opts extra options.
      1740. 
-
    1740.           * @param {String[]} [opts.args] colums/args for the CTE.
      1741. 
-
    1741.           * @param {Boolean} [opts.recursive] set to true that the CTE is recursive.
      1742. 
+
    1742.           * @return {patio.Dataset} a cloned dataset with the IS expression added to the WHERE clause.
      1743. 
 
    1743.           *
      1744. 
-
    1744.           * @return {patio.Dataset} a cloned dataset with the CTE.
      1745. 
 
    1745.           */
      1746. 
-
    1746.          "with": function (name, dataset, opts) {
      1747. 
-
    1747. 6            if (!this.supportsCte) {
      1748. 
-
    1748. 1                throw new QueryError("this dataset does not support common table expressions");
      1749. 
-
    1749.              }
      1750. 
-
    1750. 5            return this.mergeOptions({
      1751. 
-
    1751.                  "with": (this.__opts["with"] || []).concat([merge(opts || {}, {name: this.stringToIdentifier(name), dataset: dataset})])
      1752. 
-
    1752.              });
      1753. 
+
    1753.          is: function (obj) {
      1754. 
+
    1754. 4            return this.filter(this.__createBoolExpression("is", obj));
      1755. 
 
    1755.          },
      1756. 
 
    1756.  
      1757. 
 
    1757.          /**
      1758. 
-
    1758.           * Add a recursive common table expression (CTE) with the given name, a dataset that
      1759. 
-
    1759.           * defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
      1760. 
-
    1760.           * of the CTE.
      1761. 
-
    1761.           *
      1762. 
-
    1762.           *  @example
      1763. 
-
    1763.           *
      1764. 
-
    1764.           * //Sing withRecursive call.
      1765. 
-
    1765.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t")).sql;
      1766. 
-
    1766.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      1767. 
+
    1767.           * Returnes a cloned dataset with the IS NOT NULL boolean expression added to the WHERE
      1768. 
+
    1768.           * clause.
      1769. 
 
    1769.           *
      1770. 
-
    1770.           * //Multiple withRecursive calls.
      1771. 
-
    1771.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"))
      1772. 
-
    1772.           *    .withRecursive("j", db.from("y"), db.from("j")).sql;
      1773. 
-
    1773.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t),
      1774. 
-
    1774.           *                     j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t';
      1775. 
+
    1775.           * @example
      1776. 
 
    1776.           *
      1777. 
-
    1777.           * //Adding args
      1778. 
-
    1778.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {args:["b", "c"]}).sql;
      1779. 
-
    1779.           *          //=> 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      1780. 
+
    1780.           * DB.from("test").isNotNull("boolFlag");
      1781. 
+
    1781.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      1782. 
+
    1782.           * DB.from("test").isNotNull("boolFlag", "otherFlag");
      1783. 
+
    1783.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL AND otherFlag IS NOT NULL);
      1784. 
 
    1784.           *
      1785. 
-
    1785.           * //Setting union all to false
      1786. 
-
    1786.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {unionAll:false}).sql;
      1787. 
-
    1787.           *          //=> 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t');
      1788. 
+
    1788.           * @param {String...} arr variable number of arguments to create an IS NOT NULL expression for.
      1789. 
 
    1789.           *
      1790. 
-
    1790.           * @param {String} name the name to assign to the CTE
      1791. 
-
    1791.           * @param {patio.Dataset} nonRecursive the non-recursive part of the CTE
      1792. 
-
    1792.           * @param {patio.Dataset} recursive the recursive part of the CTE
      1793. 
-
    1793.           * @param {Object} [opts={}] extra options
      1794. 
-
    1794.           * @param {String[]} [opts.args] columns to include with the CTE
      1795. 
-
    1795.           * @param {Boolena} [opts.unionAll] set to false to use UNION instead of UNION ALL when combining non recursive
      1796. 
-
    1796.           *                                with recursive.
      1797. 
+
    1797.           * @return {patio.Dataset} a cloned dataset with the IS NOT NULL expression added to the WHERE clause.
      1798. 
 
    1798.           *
      1799. 
-
    1799.           * @return {patio.Dataset} a cloned dataset with the CTE.
      1800. 
 
    1800.           */
      1801. 
-
    1801.          withRecursive: function (name, nonRecursive, recursive, opts) {
      1802. 
-
    1802. 7            if (!this.supportsCte) {
      1803. 
-
    1803. 1                throw new QueryError("This dataset does not support common table expressions");
      1804. 
-
    1804.              }
      1805. 
-
    1805. 6            opts = opts || {};
      1806. 
-
    1806. 6            var wit = (this.__opts["with"] || []).concat([merge(opts, {recursive: true, name: this.stringToIdentifier(name), dataset: nonRecursive.union(recursive, {all: opts.unionAll != false, fromSelf: false})})]);
      1807. 
-
    1807. 6            return this.mergeOptions({"with": wit});
      1808. 
+
    1808.          isNotNull: function (arr) {
      1809. 
+
    1809. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      1810. 
+
    1810. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      1811. 
 
    1811.          },
      1812. 
 
    1812.  
      1813. 
 
    1813.          /**
      1814. 
-
    1814.           * Returns a copy of the dataset with the static SQL used.  This is useful if you want
      1815. 
-
    1815.           * to keep the same {@link patio.Dataset#rowCb}/{@link patio.Dataset#graph},
      1816. 
-
    1816.           *  but change the SQL used to custom SQL.
      1817. 
+
    1817.           * Returnes a cloned dataset with the IS NULL boolean expression added to the WHERE
      1818. 
+
    1818.           * clause.
      1819. 
 
    1819.           *
      1820. 
 
    1820.           * @example
      1821. 
-
    1821.           *  DB.from("items").withSql('SELECT * FROM foo')
      1822. 
-
    1822.           *          //=> SELECT * FROM foo
      1823. 
 
    1823.           *
      1824. 
-
    1824.           *  @param {String} sql sql for the dataset to use.
      1825. 
+
    1825.           * DB.from("test").isNull("boolFlag");
      1826. 
+
    1826.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      1827. 
+
    1827.           * DB.from("test").isNull("boolFlag", "otherFlag");
      1828. 
+
    1828.           *      => SELECT * FROM test WHERE (boolFlag IS NULL AND otherFlag IS NULL);
      1829. 
 
    1829.           *
      1830. 
-
    1830.           *  @return {patio.Dataset} a cloned dataset with the static sql set.
      1831. 
-
    1831.           */
      1832. 
-
    1832.          withSql: function (sql) {
      1833. 
-
    1833. 46            var args = argsToArray(arguments).slice(1);
      1834. 
-
    1834. 46            if (args.length) {
      1835. 
-
    1835. 23                sql = new PlaceHolderLiteralString(sql, args)
      1836. 
-
    1836.              }
      1837. 
-
    1837. 46            return this.mergeOptions({sql: sql});
      1838. 
-
    1838.          },
      1839. 
-
    1839.  
      1840. 
-
    1840.  
      1841. 
-
    1841.          /**
      1842. 
-
    1842.           * Add the dataset to the list of compounds
      1843. 
+
    1843.           * @param {String...} arr variable number of arguments to create an IS NULL expression for.
      1844. 
 
    1844.           *
      1845. 
-
    1845.           * @param {String} type the type of compound (i.e. "union", "intersect")
      1846. 
-
    1846.           * @param {patio.Dataset} dataset the dataset to add to
      1847. 
-
    1847.           * @param [Object] [options={}] compound option to use (i.e {all : true})
      1848. 
+
    1848.           * @return {patio.Dataset} a cloned dataset with the IS NULL expression added to the WHERE clause.
      1849. 
 
    1849.           *
      1850. 
-
    1850.           * @return {patio.Dataset} ds with the dataset added to the compounds.
      1851. 
 
    1851.           */
      1852. 
-
    1852.          compoundClone: function (type, dataset, options) {
      1853. 
-
    1853. 51            var ds = this._compoundFromSelf().mergeOptions({compounds: (array.toArray(this.__opts.compounds || [])).concat([
      1854. 
-
    1854.                  [type, dataset._compoundFromSelf(), options.all]
      1855. 
-
    1855.              ])});
      1856. 
-
    1856. 51            return options.fromSelf === false ? ds : ds.fromSelf(options);
      1857. 
+
    1857.          isNull: function (arr) {
      1858. 
+
    1858. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      1859. 
+
    1859. 2            return this.filter(this.__createBoolExpression("is", arr));
      1860. 
 
    1860.          },
      1861. 
 
    1861.  
      1862. 
 
    1862.          /**
      1863. 
-
    1863.           * Returns the a cloned dataset with out the {@link patio.Dataset#rowCb}
      1864. 
+
    1864.           * Returnes a cloned dataset with the IS NOT TRUE boolean expression added to the WHERE
      1865. 
+
    1865.           * clause.
      1866. 
 
    1866.           *
      1867. 
 
    1867.           * @example
      1868. 
-
    1868.           * var ds = DB.from("test");
      1869. 
-
    1869.           * ds.rowCb = function(r){
      1870. 
-
    1870.           *     r.a = r.a * 2;
      1871. 
-
    1871.           * }
      1872. 
 
    1872.           *
      1873. 
-
    1873.           * ds.all().then(function(ret){
      1874. 
-
    1874.           *      //ret === [{a : 4}, {a : 6}]
      1875. 
-
    1875.           * });
      1876. 
-
    1876.           * ds.naked().all().then(function(ret){
      1877. 
-
    1877.           *      //ret ===  [{a : 2}, {a : 3}];
      1878. 
-
    1878.           * });
      1879. 
+
    1879.           * DB.from("test").isNotTrue("boolFlag");
      1880. 
+
    1880.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE);
      1881. 
+
    1881.           * DB.from("test").isNotTrue("boolFlag", "otherFlag");
      1882. 
+
    1882.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE AND otherFlag IS NOT TRUE);
      1883. 
 
    1883.           *
      1884. 
-
    1884.           * @return {patio.Dataset} a cloned dataset with out the {@link patio.Dataset#rowCb}
      1885. 
-
    1885.           */
      1886. 
-
    1886.          naked: function () {
      1887. 
-
    1887. 2266            var ds = this.mergeOptions({});
      1888. 
-
    1888. 2266            ds.rowCb = null;
      1889. 
-
    1889. 2266            return ds;
      1890. 
-
    1890.          },
      1891. 
-
    1891.  
      1892. 
-
    1892.          /**
      1893. 
-
    1893.           * @private
      1894. 
-
    1894.           * Protected
      1895. 
+
    1895.           * @param {String...} arr variable number of arguments to create an IS NOT TRUE expression for.
      1896. 
 
    1896.           *
      1897. 
-
    1897.           * Internal filter method so it works on either the having or where clauses.
      1898. 
-
    1898.           */
      1899. 
-
    1899.          _filter: function (clause) {
      1900. 
-
    1900. 3765            var cond = argsToArray(arguments).slice(1), cb;
      1901. 
-
    1901. 3765            if (cond.length && isFunction(cond[cond.length - 1])) {
      1902. 
-
    1902. 59                cb = cond.pop();
      1903. 
-
    1903.              }
      1904. 
-
    1904. 3765            cond = cond.length == 1 ? cond[0] : cond
      1905. 
-
    1905. 3765            if ((cond == null || cond == undefined || cond === "") || (isArray(cond) && cond.length == 0 && !cb) || (isObject(cond) && isEmpty(cond) && !cb)) {
      1906. 
-
    1906. 293                return this.mergeOptions();
      1907. 
-
    1907.              } else {
      1908. 
-
    1908. 3472                cond = this._filterExpr(cond, cb);
      1909. 
-
    1909. 3469                var cl = this.__opts[clause];
      1910. 
-
    1910. 3469                cl && (cond = new BooleanExpression("AND", cl, cond));
      1911. 
-
    1911. 3469                var opts = {};
      1912. 
-
    1912. 3469                opts[clause] = cond;
      1913. 
-
    1913. 3469                return this.mergeOptions(opts);
      1914. 
-
    1914.              }
      1915. 
-
    1915.          },
      1916. 
-
    1916.  
      1917. 
-
    1917.          /**
      1918. 
-
    1918.           * Splits a possible implicit alias, handling both {@link patio.sql.AliasedExpression}s
      1919. 
-
    1919.           * and strings.  Returns an array of two elements, with the first being the
      1920. 
-
    1920.           * main expression, and the second being the alias. Alias may be null if it is a
      1921. 
-
    1921.           * string that does not contain an alias {table}___{alias}.
      1922. 
-
    1922.           */
      1923. 
-
    1923.          _splitAlias: function (c) {
      1924. 
-
    1924. 619            var ret;
      1925. 
-
    1925. 619            if (isInstanceOf(c, AliasedExpression)) {
      1926. 
-
    1926. 5                ret = [c.expression, c.alias];
      1927. 
-
    1927. 614            } else if (isString(c)) {
      1928. 
-
    1928. 0                var parts = this._splitString(c), cTable = parts[0], column = parts[1], alias = parts[2];
      1929. 
-
    1929. 0                if (alias) {
      1930. 
-
    1930. 0                    ret = [cTable ? new QualifiedIdentifier(cTable, column) : column, alias];
      1931. 
-
    1931.                  } else {
      1932. 
-
    1932. 0                    ret = [c, null];
      1933. 
-
    1933.                  }
      1934. 
-
    1934.              } else {
      1935. 
-
    1935. 614                ret = [c, null];
      1936. 
-
    1936.              }
      1937. 
-
    1937. 619            return ret;
      1938. 
-
    1938.          },
      1939. 
-
    1939.  
      1940. 
-
    1940.  
      1941. 
-
    1941.          /**
      1942. 
-
    1942.           * @private
      1943. 
-
    1943.           * Inverts the given order by breaking it into a list of column references
      1944. 
-
    1944.           * and inverting them.
      1945. 
+
    1945.           * @return {patio.Dataset} a cloned dataset with the IS NOT TRUE expression added to the WHERE clause.
      1946. 
 
    1946.           *
      1947. 
-
    1947.           *   ds.invertOrder([sql.identifier("id").desc()]]) //=> [id]
      1948. 
-
    1948.           *   ds.invertOrder("category", sql.identifier("price").desc()]) #=> [category.desc(), price]
      1949. 
 
    1949.           */
      1950. 
-
    1950.  
      1951. 
-
    1951.          _invertOrder: function (order) {
      1952. 
-
    1952. 46            var ret = order;
      1953. 
-
    1953. 46            if (order) {
      1954. 
-
    1954. 45                ret = order.map(function (o) {
      1955. 
-
    1955. 57                    if (isInstanceOf(o, OrderedExpression)) {
      1956. 
-
    1956. 17                        return o.invert();
      1957. 
-
    1957.                      } else {
      1958. 
-
    1958. 40                        return new OrderedExpression(isString(o) ? new Identifier(o) : o);
      1959. 
-
    1959.                      }
      1960. 
-
    1960.                  }, this);
      1961. 
-
    1961.              }
      1962. 
-
    1962. 46            return ret;
      1963. 
+
    1963.          isNotTrue: function (arr) {
      1964. 
+
    1964. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      1965. 
+
    1965. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      1966. 
 
    1966.          },
      1967. 
 
    1967.  
      1968. 
 
    1968.          /**
      1969. 
-
    1969.           * Creates a boolean expression that each key is compared to its value using the provided operator.
      1970. 
+
    1970.           * Returnes a cloned dataset with the IS TRUE boolean expression added to the WHERE
      1971. 
+
    1971.           * clause.
      1972. 
 
    1972.           *
      1973. 
 
    1973.           * @example
      1974. 
 
    1974.           *
      1975. 
-
    1975.           * ds.__createBoolExpression("gt", {x : 1, y:2, z : 5}) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1976. 
-
    1976.           * ds.__createBoolExpression("gt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1977. 
-
    1977.           * ds.__createBoolExpression("lt", {x : 1, y:2, z : 5}) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1978. 
-
    1978.           * ds.__createBoolExpression("lt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1979. 
+
    1979.           * DB.from("test").isTrue("boolFlag");
      1980. 
+
    1980.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE);
      1981. 
+
    1981.           * DB.from("test").isTrue("boolFlag", "otherFlag");
      1982. 
+
    1982.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE AND otherFlag IS TRUE);
      1983. 
 
    1983.           *
      1984. 
-
    1984.           * @param {String} op valid boolean expression operator to capare each K,V pair with
      1985. 
-
    1985.           * @param {Object| Array } obj object or two dimensional array containing key value pairs
      1986. 
+
    1986.           * @param {String...} arr variable number of arguments to create an IS TRUE expression for.
      1987. 
+
    1987.           *
      1988. 
+
    1988.           * @return {patio.Dataset} a cloned dataset with the IS TRUE expression added to the WHERE clause.
      1989. 
 
    1989.           *
      1990. 
-
    1990.           * @return {patio.sql.BooleanExpression} boolean expression joined by a AND of each key value pair compared by the op
      1991. 
 
    1991.           */
      1992. 
-
    1992.          __createBoolExpression: function (op, obj) {
      1993. 
-
    1993. 32            var pairs = [];
      1994. 
-
    1994. 32            if (Expression.isConditionSpecifier(obj)) {
      1995. 
-
    1995. 32                if (isHash(obj)) {
      1996. 
-
    1996. 18                    obj = array.toArray(obj);
      1997. 
-
    1997.                  }
      1998. 
-
    1998. 32                obj.forEach(function (pair) {
      1999. 
-
    1999. 42                    pairs.push(new BooleanExpression(op, new Identifier(pair[0]), pair[1]));
      2000. 
-
    2000.                  });
      2001. 
-
    2001.              }
      2002. 
-
    2002. 32            return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
      2003. 
+
    2003.          isTrue: function (arr) {
      2004. 
+
    2004. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      2005. 
+
    2005. 2            return this.filter(this.__createBoolExpression("is", arr));
      2006. 
 
    2006.          },
      2007. 
 
    2007.  
      2008. 
 
    2008.          /**
      2009. 
-
    2009.           * @private
      2010. 
-
    2010.           *
      2011. 
-
    2011.           * Creates a boolean expression where the key is '>=' value 1 and '<=' value two.
      2012. 
+
    2012.           * Returnes a cloned dataset with the IS NOT FALSE boolean expression added to the WHERE
      2013. 
+
    2013.           * clause.
      2014. 
 
    2014.           *
      2015. 
 
    2015.           * @example
      2016. 
 
    2016.           *
      2017. 
-
    2017.           * ds.__createBetweenExpression({x : [1,2]}) => //=> WHERE ((x >= 1) AND (x <= 10))
      2018. 
-
    2018.           * ds.__createBetweenExpression({x : [1,2]}, true) => //=> WHERE ((x < 1) OR (x > 10))
      2019. 
+
    2019.           * DB.from("test").isNotFalse("boolFlag");
      2020. 
+
    2020.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE);
      2021. 
+
    2021.           * DB.from("test").isNotFalse("boolFlag", "otherFlag");
      2022. 
+
    2022.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE AND otherFlag IS NOT FALSE);
      2023. 
+
    2023.           * @param {String...} arr variable number of arguments to create an IS NOT FALSE expression for.
      2024. 
 
    2024.           *
      2025. 
-
    2025.           * @param {Object} obj object where the keys are columns and the values are two element arrays.
      2026. 
-
    2026.           * @param {Boolean} [invert] if set to true it inverts the between to make it not between the two values
      2027. 
+
    2027.           * @return {patio.Dataset} a cloned dataset with the IS NOT FALSE expression added to the WHERE clause.
      2028. 
 
    2028.           *
      2029. 
-
    2029.           * @return {patio.sql.BooleanExpression} a boolean expression containing the between expression.
      2030. 
 
    2030.           */
      2031. 
-
    2031.          __createBetweenExpression: function (obj, invert) {
      2032. 
-
    2032. 4            var pairs = [];
      2033. 
-
    2033. 4            for (var i in obj) {
      2034. 
-
    2034. 4                var v = obj[i];
      2035. 
-
    2035. 4                if (isArray(v) && v.length) {
      2036. 
-
    2036. 2                    var ident = this.stringToIdentifier(i);
      2037. 
-
    2037. 2                    pairs.push(new BooleanExpression("AND", new BooleanExpression("gte", ident, v[0]), new BooleanExpression("lte", ident, v[1])));
      2038. 
-
    2038.                  } else {
      2039. 
-
    2039. 2                    throw new QueryError("Between requires an array for the value");
      2040. 
-
    2040.                  }
      2041. 
-
    2041.              }
      2042. 
-
    2042. 2            var ret = pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs))
      2043. 
-
    2043. 2            return invert ? BooleanExpression.invert(ret) : ret;
      2044. 
+
    2044.          isNotFalse: function (arr) {
      2045. 
+
    2045. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      2046. 
+
    2046. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      2047. 
 
    2047.          },
      2048. 
 
    2048.  
      2049. 
-
    2049.  
      2050. 
 
    2050.          /**
      2051. 
-
    2051.           * @private
      2052. 
-
    2052.           * Converts an array to a two dimensional array where the first element
      2053. 
-
    2053.           * is the identifier and the second argument is the value that the value should equal
      2054. 
-
    2054.           * used by is{Null|NotNull|True|NotTrue|False|notFalse} functions to join all the values passed in.
      2055. 
-
    2055.           * @param {String[]|patio.sql.Identifier} arr array of elements to make a condition specifier out of
      2056. 
-
    2056.           * @param defaultOp the value to assign a value if one is not provided.
      2057. 
+
    2057.           * Returnes a cloned dataset with the IS FALSE boolean expression added to the WHERE
      2058. 
+
    2058.           * clause.
      2059. 
+
    2059.           *
      2060. 
+
    2060.           * @example
      2061. 
+
    2061.           *
      2062. 
+
    2062.           * DB.from("test").isFalse("boolFlag");
      2063. 
+
    2063.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE);
      2064. 
+
    2064.           * DB.from("test").isFalse("boolFlag", "otherFlag");
      2065. 
+
    2065.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE AND otherFlag IS FALSE);
      2066. 
+
    2066.           * @param {String...} arr variable number of arguments to create an IS FALSE expression for.
      2067. 
+
    2067.           *
      2068. 
+
    2068.           * @return {patio.Dataset} a cloned dataset with the IS FALSE expression added to the WHERE clause.
      2069. 
 
    2069.           *
      2070. 
-
    2070.           * @return { [[]] } an array of two element arrays.
      2071. 
 
    2071.           */
      2072. 
-
    2072.          __arrayToConditionSpecifier: function (arr, defaultOp) {
      2073. 
-
    2073. 22            var ret = [];
      2074. 
-
    2074. 22            arr.forEach(function (a) {
      2075. 
-
    2075. 28                if (isString(a)) {
      2076. 
-
    2076. 18                    a = this.stringToIdentifier(a);
      2077. 
-
    2077.                  }
      2078. 
-
    2078. 28                if (isInstanceOf(a, Identifier)) {
      2079. 
-
    2079. 18                    ret.push([a, defaultOp]);
      2080. 
-
    2080. 10                } else if (isHash(a)) {
      2081. 
-
    2081. 4                    ret = ret.concat(array.toArray(a));
      2082. 
-
    2082.                  } else {
      2083. 
-
    2083. 6                    throw new QueryError("Invalid condition specifier " + a);
      2084. 
-
    2084.                  }
      2085. 
-
    2085.              }, this);
      2086. 
-
    2086. 16            return ret;
      2087. 
+
    2087.          isFalse: function (arr) {
      2088. 
+
    2088. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      2089. 
+
    2089. 2            return this.filter(this.__createBoolExpression("is", arr));
      2090. 
 
    2090.          },
      2091. 
 
    2091.  
      2092. 
 
    2092.          /**
      2093. 
-
    2093.           * @private
      2094. 
 
    2094.           *
      2095. 
-
    2095.           * SQL expression object based on the expr type.  See {@link patio.Dataset#filter}
      2096. 
+
    2096.           * Returns a cloned dataset with a greater than or equal to expression added to the WHERE
      2097. 
+
    2097.           * clause.
      2098. 
+
    2098.           *
      2099. 
+
    2099.           * @example
      2100. 
+
    2100.           *  DB.from("test").gte({x : 1});
      2101. 
+
    2101.           *          //=> SELECT * FROM test WHERE (x >= 1)
      2102. 
+
    2102.           *  DB.from("test").gte({x : 1, y : 10});
      2103. 
+
    2103.           *          //=> SELECT * FROM test WHERE ((x >= 1) AND (y >= 10))
      2104. 
+
    2104.           *
      2105. 
+
    2105.           * @param {Object} obj object used to create the greater than or equal to expression.
      2106. 
+
    2106.           *
      2107. 
+
    2107.           * @return {patio.Dataset} a cloned dataset with the greater than or equal to expression added to the WHERE clause.
      2108. 
 
    2108.           */
      2109. 
-
    2109.          _filterExpr: function (expr, cb, joinCond) {
      2110. 
-
    2110. 4283            expr = (isUndefined(expr) || isNull(expr) || (isArray(expr) && !expr.length)) ? null : expr;
      2111. 
-
    2111. 4283            if (expr && cb) {
      2112. 
-
    2112. 1                return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond))
      2113. 
-
    2113. 4282            } else if (cb) {
      2114. 
-
    2114. 58                expr = cb
      2115. 
-
    2115.              }
      2116. 
-
    2116. 4282            if (isInstanceOf(expr, Expression)) {
      2117. 
-
    2117. 459                if (isInstanceOf(expr, NumericExpression, StringExpression)) {
      2118. 
-
    2118. 2                    throw new QueryError("Invalid SQL Expression type : " + expr);
      2119. 
-
    2119.                  }
      2120. 
-
    2120. 457                return expr;
      2121. 
-
    2121. 3823            } else if (isArray(expr)) {
      2122. 
-
    2122. 740                if (expr.length) {
      2123. 
-
    2123. 740                    var first = expr[0];
      2124. 
-
    2124. 740                    if (isString(first)) {
      2125. 
-
    2125. 25                        return new PlaceHolderLiteralString(first, expr.slice(1), true);
      2126. 
-
    2126. 715                    } else if (Expression.isConditionSpecifier(expr)) {
      2127. 
-
    2127. 708                        return BooleanExpression.fromValuePairs(expr, joinCond)
      2128. 
-
    2128.                      } else {
      2129. 
-
    2129. 7                        return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
      2130. 
-
    2130. 15                            return this._filterExpr(e, null, joinCond);
      2131. 
-
    2131.                          }, this)));
      2132. 
-
    2132.                      }
      2133. 
-
    2133.                  }
      2134. 
-
    2134. 3083            } else if (isFunction(expr)) {
      2135. 
-
    2135. 59                return this._filterExpr(expr.call(sql, sql), null, joinCond);
      2136. 
-
    2136. 3024            } else if (isBoolean(expr)) {
      2137. 
-
    2137. 7                return new BooleanExpression("NOOP", expr);
      2138. 
-
    2138. 3017            } else if (isString(expr)) {
      2139. 
-
    2139. 1                return this.stringToIdentifier(expr);
      2140. 
-
    2140. 3016            } else if (isInstanceOf(expr, LiteralString)) {
      2141. 
-
    2141. 16                return new LiteralString("(" + expr + ")");
      2142. 
-
    2142. 3000            } else if (isHash(expr)) {
      2143. 
-
    2143. 2999                return BooleanExpression.fromValuePairs(expr, joinCond);
      2144. 
-
    2144.              } else {
      2145. 
-
    2145. 1                throw new QueryError("Invalid filter argument");
      2146. 
-
    2146.              }
      2147. 
+
    2147.          gte: function (arr) {
      2148. 
+
    2148. 2            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "gte");
      2149. 
+
    2149. 2            return this.filter(this.__createBoolExpression("gte", arr));
      2150. 
 
    2150.          },
      2151. 
 
    2151.  
      2152. 
-
    2152.  
      2153. 
-
    2153.          /**@ignore*/
      2154. 
-
    2154.          getters: {
      2155. 
-
    2155.  
      2156. 
-
    2156.              /**
      2157. 
-
    2157.               * @ignore
      2158. 
-
    2158.               * Returns true if this dataset is a simple SELECT * FROM {table}, otherwise false.
      2159. 
-
    2159.               */
      2160. 
-
    2160.              isSimpleSelectAll: function () {
      2161. 
-
    2161. 33                var o = {}, opts = this.__opts, count = 0;
      2162. 
-
    2162. 33                for (var i in opts) {
      2163. 
-
    2163. 70                    if (opts[i] != null && this._static.NON_SQL_OPTIONS.indexOf(i) == -1) {
      2164. 
-
    2164. 37                        o[i] = opts[i];
      2165. 
-
    2165. 37                        count++;
      2166. 
-
    2166.                      }
      2167. 
-
    2167.                  }
      2168. 
-
    2168. 33                var f = o.from
      2169. 
-
    2169. 33                return count == 1 && f.length == 1 && (isString(f[0]) || isInstanceOf(f[0], AliasedExpression, Identifier));
      2170. 
-
    2170.              }
      2171. 
-
    2171.          }
      2172. 
-
    2172.      },
      2173. 
-
    2173.  
      2174. 
-
    2174.      static: {
      2175. 
-
    2175.          /**@lends patio.Dataset*/
      2176. 
-
    2176.  
      2177. 
-
    2177.          /**
      2178. 
-
    2178.           * These strings have {name}Join methods created (e.g. {@link patio.Dataset#innerJoin}) that
      2179. 
-
    2179.           * call {@link patio.Dataset#joinTable} with the string, passing along the arguments and
      2180. 
-
    2180.           * block from the method call.
      2181. 
-
    2181.           **/
      2182. 
-
    2182.          CONDITIONED_JOIN_TYPES: ["inner", "fullOuter", "rightOuter", "leftOuter", "full", "right", "left"],
      2183. 
-
    2183.  
      2184. 
 
    2184.          /**
      2185. 
 
    2185.           *
      2186. 
-
    2186.           * These strings have {name}Join methods created (e.g. naturalJoin) that
      2187. 
-
    2187.           * call {@link patio.Dataset#joinTable}.  They only accept a single table
      2188. 
-
    2188.           * argument which is passed to {@link patio.Dataset#joinTable}, and they throw an error
      2189. 
-
    2189.           * if called with a block.
      2190. 
-
    2190.           **/
      2191. 
-
    2191.          UNCONDITIONED_JOIN_TYPES: ["natural", "naturalLeft", "naturalRight", "naturalFull", "cross"],
      2192. 
-
    2192.  
      2193. 
-
    2193.          /**
      2194. 
-
    2194.           *  The dataset options that require the removal of cached columns
      2195. 
-
    2195.           *  if changed.
      2196. 
-
    2196.           */
      2197. 
-
    2197.          COLUMN_CHANGE_OPTS: ["select", "sql", "from", "join"],
      2198. 
-
    2198.  
      2199. 
-
    2199.          /**
      2200. 
-
    2200.           * Which options don't affect the SQL generation.  Used by {@link patio.Dataset#simpleSelectAll}
      2201. 
-
    2201.           * to determine if this is a simple SELECT * FROM table.
      2202. 
-
    2202.           */
      2203. 
-
    2203.          NON_SQL_OPTIONS: ["server", "defaults", "overrides", "graph", "eagerGraph", "graphAliases"],
      2204. 
-
    2204.  
      2205. 
-
    2205.  
      2206. 
-
    2206.          /**
      2207. 
-
    2207.           *  All methods that return modified datasets with a joined table added.
      2208. 
+
    2208.           * Returns a cloned dataset with a less than or equal to expression added to the WHERE
      2209. 
+
    2209.           * clause.
      2210. 
+
    2210.           *
      2211. 
+
    2211.           * @example
      2212. 
+
    2212.           *  DB.from("test").gte({x : 1});
      2213. 
+
    2213.           *          //=> SELECT * FROM test WHERE (x <= 1)
      2214. 
+
    2214.           *  DB.from("test").gte({x : 1, y : 10});
      2215. 
+
    2215.           *          //=> SELECT * FROM test WHERE ((x <= 1) AND (y <= 10))
      2216. 
+
    2216.           *
      2217. 
+
    2217.           * @param {Object} obj object used to create the less than or equal to expression.
      2218. 
+
    2218.           *
      2219. 
+
    2219.           * @return {patio.Dataset} a cloned dataset with the less than or equal to expression added to the WHERE clause.
      2220. 
 
    2220.           */
      2221. 
-
    2221.          JOIN_METHODS: ["join", "joinTable"],
      2222. 
+
    2222.          lte: function (obj) {
      2223. 
+
    2223. 2            var arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "lte");
      2224. 
+
    2224. 2            return this.filter(this.__createBoolExpression("lte", obj));
      2225. 
+
    2225.          },
      2226. 
 
    2226.  
      2227. 
 
    2227.          /**
      2228. 
-
    2228.           * Methods that return modified datasets
      2229. 
-
    2229.           */
      2230. 
-
    2230.          QUERY_METHODS: ['addGraphAliases', "and", "distinct", "except", "exclude", "filter", "find", "is", "isNot",
      2231. 
-
    2231.              "eq", "neq", "lt", "lte", "gt", "gte", "forUpdate", "from", "fromSelf", "graph", "grep", "group",
      2232. 
-
    2232.              "groupAndCount", "groupBy", "having", "intersect", "invert", "limit", "lockStyle", "naked", "or", "order",
      2233. 
-
    2233.              "orderAppend", "orderBy", "orderMore", "orderPrepend", "qualify", "reverse",
      2234. 
-
    2234.              "reverseOrder", "select", "selectAll", "selectAppend", "selectMore", "setDefaults",
      2235. 
-
    2235.              "setGraphAliases", "setOverrides", "unfiltered", "ungraphed", "ungrouped", "union", "unlimited",
      2236. 
-
    2236.              "unordered", "where", "with", "withRecursive", "withSql"],
      2237. 
-
    2237.  
      2238. 
-
    2238.          init: function () {
      2239. 
-
    2239. 35            this._super(arguments);
      2240. 
-
    2240.              //initialize our join methods array
      2241. 
-
    2241. 35            var joinMethods = this.JOIN_METHODS;
      2242. 
-
    2242. 35            var queryMethods = this.QUERY_METHODS;
      2243. 
-
    2243. 35            this.UNCONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      2244. 
-
    2244. 175                var m = joinType + "Join";
      2245. 
-
    2245. 175                joinMethods.push(m);
      2246. 
-
    2246. 175                queryMethods.push(m);
      2247. 
-
    2247.              });
      2248. 
-
    2248. 35            this.CONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      2249. 
-
    2249. 245                var m = joinType + "Join";
      2250. 
-
    2250. 245                joinMethods.push(m);
      2251. 
-
    2251. 245                queryMethods.push(m);
      2252. 
-
    2252.              });
      2253. 
-
    2253. 35            this.QUERY_METHODS = queryMethods.concat(joinMethods);
      2254. 
-
    2254.          }
      2255. 
-
    2255.      }
      2256. 
-
    2256.  }).
      2257. 
-
    2257.      as(module);
    -
    - -
    - - - - - -
    -
    plugins/validation.js
    -     		-
    - Coverage97.66 - SLOC535 - LOC128 - Missed3 -
    -
    - 
    1. 1var comb = require("comb"),
      2. 
-
    2.      array = comb.array,
      3. 
-
    3.      compact = array.compact,
      4. 
-
    4.      flatten = array.flatten,
      5. 
-
    5.      toArray = array.toArray,
      6. 
-
    6.      net = require("net"),
      7. 
-
    7.      isIP = net.isIP,
      8. 
-
    8.      isIPv4 = net.isIPv4,
      9. 
-
    9.      isIPv6 = net.isIPv6,
      10. 
-
    10.      validator = require("validator"),
      11. 
-
    11.      validatorCheck = validator.check,
      12. 
-
    12.      dateCmp = comb.date.compare,
      13. 
-
    13.      isArray = comb.isArray,
      14. 
-
    14.      combDeepEqual = comb.deepEqual,
      15. 
-
    15.      combIsBoolean = comb.isBoolean,
      16. 
-
    16.      isString = comb.isString,
      17. 
-
    17.      combIsDefined = comb.isDefined,
      18. 
-
    18.      combIsNull = comb.isNull,
      19. 
-
    19.      ModelError = require("../errors.js").ModelError,
      20. 
-
    20.      isFunction = comb.isFunction,
      21. 
-
    21.      format = comb.string.format,
      22. 
-
    22.      Promise = comb.Promise,
      23. 
-
    23.      serial = comb.serial,
      24. 
-
    24.      when = comb.when,
      25. 
-
    25.      merge = comb.merge,
      26. 
-
    26.      define = comb.define;
      27. 
-
    27.  
      28. 
-
    28. 1var Validator = define(null, {
      29. 
-
    29.      instance:{
      30. 
+
    30.           * Returns a cloned dataset with a between clause added
      31. 
+
    31.           * to the where clause.
      32. 
+
    32.           *
      33. 
+
    33.           * @example
      34. 
+
    34.           *  ds.notBetween({x:[1, 2]}).sql;
      35. 
+
    35.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      36. 
+
    36.           *
      37. 
+
    37.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      38. 
+
    38.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      39. 
+
    39.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      40. 
+
    40.           *                     is the item to be greater than or equal to than and the second item is less than or equal to than.
      41. 
+
    41.           *
      42. 
+
    42.           * @return {patio.Dataset} a cloned dataset with a between clause added
      43. 
+
    43.           * to the where clause.
      44. 
+
    44.           */
      45. 
+
    45.          between: function (obj) {
      46. 
+
    46. 2            return this.filter(this.__createBetweenExpression(obj));
      47. 
+
    47.          },
      48. 
 
    48.  
      49. 
-
    49.          constructor:function validator(col) {
      50. 
-
    50. 44            this.col = col;
      51. 
-
    51. 44            this.__actions = [];
      52. 
+
    52.          /**
      53. 
+
    53.           * Returns a cloned dataset with a not between clause added
      54. 
+
    54.           * to the where clause.
      55. 
+
    55.           *
      56. 
+
    56.           * @example
      57. 
+
    57.           *  ds.notBetween({x:[1, 2]}).sql;
      58. 
+
    58.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      59. 
+
    59.           *
      60. 
+
    60.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      61. 
+
    61.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      62. 
+
    62.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      63. 
+
    63.           *                     is the item to be less than and the second item is greater than.
      64. 
+
    64.           *
      65. 
+
    65.           * @return {patio.Dataset} a cloned dataset with a not between clause added
      66. 
+
    66.           * to the where clause.
      67. 
+
    67.           */
      68. 
+
    68.          notBetween: function (obj) {
      69. 
+
    69. 2            return this.filter(this.__createBetweenExpression(obj, true));
      70. 
 
    70.          },
      71. 
 
    71.  
      72. 
-
    72.          __addAction:function __addAction(action, opts) {
      73. 
-
    73. 46            this.__actions.push({
      74. 
-
    74.                  action:action,
      75. 
-
    75.                  opts:merge({onlyDefined:true, onlyNotNull:false}, opts)
      76. 
-
    76.              });
      77. 
-
    77. 46            return this;
      78. 
+
    78.          /**
      79. 
+
    79.           * Returns a cloned dataset with the given lock style.  If style is a
      80. 
+
    80.           * string, it will be used directly.Currently "update" is respected
      81. 
+
    81.           * by most databases, and "share" is supported by some.
      82. 
+
    82.           *
      83. 
+
    83.           * @example
      84. 
+
    84.           * DB.from("items").lockStyle('FOR SHARE') # SELECT * FROM items FOR SHARE
      85. 
+
    85.           *
      86. 
+
    86.           * @param {String} style the lock style to use.
      87. 
+
    87.           *
      88. 
+
    88.           * @return {patio.Dataset} a cloned datase with the given lock style.
      89. 
+
    89.           **/
      90. 
+
    90.          lockStyle: function (style) {
      91. 
+
    91. 4            return this.mergeOptions({lock: style});
      92. 
 
    92.          },
      93. 
 
    93.  
      94. 
-
    94.          isAfter:function (date, opts) {
      95. 
-
    95. 1            opts = opts || {};
      96. 
-
    96. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
      97. 
-
    97. 1            return this.__addAction(function (col) {
      98. 
-
    98. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") > 0;
      99. 
-
    99.              }, merge({message:"{col} must be after " + date + " got {val}."}, opts));
      100. 
+
    100.          /**
      101. 
+
    101.           * Returns a copy of the dataset with the order changed. If the dataset has an
      102. 
+
    102.           * existing order, it is ignored and overwritten with this order. If null is given
      103. 
+
    103.           * the returned dataset has no order. This can accept multiple arguments
      104. 
+
    104.           * of varying kinds, such as SQL functions.  This also takes a function similar
      105. 
+
    105.           * to {@link patio.Dataset#filter}
      106. 
+
    106.           *
      107. 
+
    107.           * @example
      108. 
+
    108.           *
      109. 
+
    109.           *  DB.from("items").order("name")
      110. 
+
    110.           *          //=> SELECT * FROM items ORDER BY name
      111. 
+
    111.           *
      112. 
+
    112.           *  DB.from("items").order("a", "b")
      113. 
+
    113.           *          //=> SELECT * FROM items ORDER BY a, b
      114. 
+
    114.           *
      115. 
+
    115.           *  DB.from("items").order(sql.literal('a + b'))
      116. 
+
    116.           *          //=> SELECT * FROM items ORDER BY a + b
      117. 
+
    117.           *
      118. 
+
    118.           *  DB.from("items").order(sql.identifier("a").plus("b"))
      119. 
+
    119.           *          //=> SELECT * FROM items ORDER BY (a + b)
      120. 
+
    120.           *
      121. 
+
    121.           *  DB.from("items").order(sql.identifier("name").desc())
      122. 
+
    122.           *          //=> SELECT * FROM items ORDER BY name DESC
      123. 
+
    123.           *
      124. 
+
    124.           *  DB.from("items").order(sql.identifier("name").asc({nulls : "last"))
      125. 
+
    125.           *          //=> SELECT * FROM items ORDER BY name ASC NULLS LAST
      126. 
+
    126.           *
      127. 
+
    127.           *  DB.from("items").order(function(){
      128. 
+
    128.           *          return this.sum("name").desc();
      129. 
+
    129.           *  }); //=> SELECT * FROM items ORDER BY sum(name) DESC
      130. 
+
    130.           *
      131. 
+
    131.           *  DB.from("items").order(null)
      132. 
+
    132.           *          //=>SELECT * FROM items
      133. 
+
    133.           *  @param arg variable number of arguments similar to {@link patio.Dataset#filter}
      134. 
+
    134.           *
      135. 
+
    135.           *  @return {patio.Dataset} a cloned dataset with the order changed.
      136. 
+
    136.           * */
      137. 
+
    137.          order: function (args) {
      138. 
+
    138. 381            args = argsToArray(arguments);
      139. 
+
    139. 381            var order = [];
      140. 
+
    140. 381            args = compact(args).length ? args : null;
      141. 
+
    141. 381            if (args) {
      142. 
+
    142. 263                args.forEach(function (a) {
      143. 
+
    143. 326                    if (isString(a)) {
      144. 
+
    144. 204                        order.push(this.stringToIdentifier(a));
      145. 
+
    145. 122                    } else if (isFunction(a)) {
      146. 
+
    146. 16                        var res = a.apply(sql, [sql]);
      147. 
+
    147. 16                        order = order.concat(isArray(res) ? res : [res]);
      148. 
+
    148.                      } else {
      149. 
+
    149. 106                        order.push(a);
      150. 
+
    150.                      }
      151. 
+
    151.                  }, this);
      152. 
+
    152.              } else {
      153. 
+
    153. 118                order = null;
      154. 
+
    154.              }
      155. 
+
    155. 381            return this.mergeOptions({order: order});
      156. 
 
    156.          },
      157. 
 
    157.  
      158. 
-
    158.          isBefore:function (date, opts) {
      159. 
-
    159. 1            opts = opts || {};
      160. 
-
    160. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
      161. 
-
    161. 1            return this.__addAction(function (col) {
      162. 
-
    162. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") === -1;
      163. 
-
    163.              }, merge({message:"{col} must be before " + date + " got {val}."}, opts));
      164. 
+
    164.          /**
      165. 
+
    165.           * Alias of {@link patio.Dataset#orderMore};
      166. 
+
    166.           */
      167. 
+
    167.          orderAppend: function () {
      168. 
+
    168. 4            return this.orderMore.apply(this, arguments);
      169. 
 
    169.          },
      170. 
 
    170.  
      171. 
-
    171.          isDefined:function isDefined(opts) {
      172. 
-
    172. 1            return this.__addAction(function (col) {
      173. 
-
    173. 3                return combIsDefined(col);
      174. 
-
    174.              }, merge({message:"{col} must be defined.", onlyDefined:false, onlyNotNull:false}, opts));
      175. 
+
    175.          /**
      176. 
+
    176.           * @see patio.Dataset#order
      177. 
+
    177.           */
      178. 
+
    178.          orderBy: function () {
      179. 
+
    179. 6            return this.order.apply(this, arguments);
      180. 
 
    180.          },
      181. 
 
    181.  
      182. 
-
    182.          isNotDefined:function isNotDefined(opts) {
      183. 
-
    183. 1            return this.__addAction(function (col) {
      184. 
-
    184. 3                return !combIsDefined(col);
      185. 
-
    185.              }, merge({message:"{col} cannot be defined.", onlyDefined:false, onlyNotNull:false}, opts));
      186. 
+
    186.          /**
      187. 
+
    187.           * Returns a copy of the dataset with the order columns added
      188. 
+
    188.           * to the end of the existing order. For more detail
      189. 
+
    189.           * @see patio.Dataset#order
      190. 
+
    190.           *
      191. 
+
    191.           * @example
      192. 
+
    192.           *
      193. 
+
    193.           * DB.from("items").order("a").order("b");
      194. 
+
    194.           *      //=> SELECT * FROM items ORDER BY b
      195. 
+
    195.           *
      196. 
+
    196.           * DB.from("items").order("a").orderMore("b");
      197. 
+
    197.           *      //=>SELECT * FROM items ORDER BY a, b
      198. 
+
    198.           */
      199. 
+
    199.          orderMore: function () {
      200. 
+
    200. 11            var args = argsToArray(arguments);
      201. 
+
    201. 11            if (this.__opts.order) {
      202. 
+
    202. 9                args = this.__opts.order.concat(args);
      203. 
+
    203.              }
      204. 
+
    204. 11            return this.order.apply(this, args);
      205. 
 
    205.          },
      206. 
 
    206.  
      207. 
-
    207.          isNotNull:function isNotNull(opts) {
      208. 
-
    208. 3            return this.__addAction(function (col) {
      209. 
-
    209. 21                return combIsDefined(col) && !combIsNull(col);
      210. 
-
    210.              }, merge({message:"{col} cannot be null.", onlyDefined:false, onlyNotNull:false}, opts));
      211. 
+
    211.          /**
      212. 
+
    212.           * Returns a copy of the dataset with the order columns added
      213. 
+
    213.           * to the beginning of the existing order. For more detail
      214. 
+
    214.           * @see patio.Dataset#order
      215. 
+
    215.           *
      216. 
+
    216.           * @example
      217. 
+
    217.           * DB.from("items").order("a").order("b");
      218. 
+
    218.           *      //=> SELECT * FROM items ORDER BY b
      219. 
+
    219.           *
      220. 
+
    220.           * DB.from("items").order("a").orderPrepend("b");
      221. 
+
    221.           *      //=>SELECT * FROM items ORDER BY b, a
      222. 
+
    222.           *
      223. 
+
    223.           *
      224. 
+
    224.           **/
      225. 
+
    225.          orderPrepend: function () {
      226. 
+
    226. 4            var ds = this.order.apply(this, arguments);
      227. 
+
    227. 4            return this.__opts.order ? ds.orderMore.apply(ds, this.__opts.order) : ds;
      228. 
 
    228.          },
      229. 
 
    229.  
      230. 
-
    230.          isNull:function isNull(opts) {
      231. 
-
    231. 1            return this.__addAction(function (col) {
      232. 
-
    232. 3                return !combIsDefined(col) || combIsNull(col);
      233. 
-
    233.              }, merge({message:"{col} must be null got {val}.", onlyDefined:false, onlyNotNull:false}, opts));
      234. 
+
    234.          /**
      235. 
+
    235.           * Qualify to the given table, or {@link patio.Dataset#firstSourceAlias} if not table is given.
      236. 
+
    236.           *
      237. 
+
    237.           * @example
      238. 
+
    238.           * DB.from("items").filter({id : 1}).qualify();
      239. 
+
    239.           *    //=> SELECT items.* FROM items WHERE (items.id = 1)
      240. 
+
    240.           *
      241. 
+
    241.           * DB.from("items").filter({id : 1}).qualify("i");
      242. 
+
    242.           *   //=> SELECT i.* FROM items WHERE (i.id = 1)
      243. 
+
    243.           *
      244. 
+
    244.           * @param {String|patio.sql.Identifier} [table={@link patio.Dataset#firstSourceAlias}] the table name to qualify to.
      245. 
+
    245.           *
      246. 
+
    246.           * @return {patio.Dataset} a cloned dataset qualified to the table or {@link patio.Dataset#firstSourceAlias}
      247. 
+
    247.           **/
      248. 
+
    248.          qualify: function (table) {
      249. 
+
    249. 19            table = table || this.firstSourceAlias;
      250. 
+
    250. 19            return this.qualifyTo(table);
      251. 
 
    251.          },
      252. 
 
    252.  
      253. 
-
    253.          isEq:function eq(val, opts) {
      254. 
-
    254. 4            return this.__addAction(function (col) {
      255. 
-
    255. 15                return combDeepEqual(col, val);
      256. 
-
    256.              }, merge({message:"{col} must === " + val + " got {val}."}, opts));
      257. 
+
    257.          /**
      258. 
+
    258.           * Qualify the dataset to its current first source(first from clause).  This is useful
      259. 
+
    259.           * if you have unqualified identifiers in the query that all refer to
      260. 
+
    260.           * the first source, and you want to join to another table which
      261. 
+
    261.           * has columns with the same name as columns in the current dataset.
      262. 
+
    262.           * See {@link patio.Dataset#qualifyTo}
      263. 
+
    263.           *
      264. 
+
    264.           * @example
      265. 
+
    265.           *
      266. 
+
    266.           * DB.from("items").filter({id : 1}).qualifyToFirstSource();
      267. 
+
    267.           *      //=> SELECT items.* FROM items WHERE (items.id = 1)
      268. 
+
    268.           *
      269. 
+
    269.           * @return {patio.Dataset} a cloned dataset that is qualified with the first source.
      270. 
+
    270.           * */
      271. 
+
    271.          qualifyToFirstSource: function () {
      272. 
+
    272. 18            return this.qualifyTo(this.firstSourceAlias);
      273. 
 
    273.          },
      274. 
 
    274.  
      275. 
-
    275.          isNeq:function neq(val, opts) {
      276. 
-
    276. 2            return this.__addAction(function (col) {
      277. 
-
    277. 8                return !combDeepEqual(col, val);
      278. 
-
    278.              }, merge({message:"{col} must !== " + val + "."}, opts));
      279. 
+
    279.          /**
      280. 
+
    280.           * Return a copy of the dataset with unqualified identifiers in the
      281. 
+
    281.           * SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
      282. 
+
    282.           * given table. If no columns are currently selected, select all
      283. 
+
    283.           * columns of the given table.
      284. 
+
    284.           *
      285. 
+
    285.           * @example
      286. 
+
    286.           *   DB.from("items").filter({id : 1}).qualifyTo("i");
      287. 
+
    287.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      288. 
+
    288.           *
      289. 
+
    289.           * @param {String} table the name to qualify identifier to.
      290. 
+
    290.           *
      291. 
+
    291.           * @return {patio.Dataset} a cloned dataset with unqualified identifiers qualified.
      292. 
+
    292.           */
      293. 
+
    293.          qualifyTo: function (table) {
      294. 
+
    294. 40            var o = this.__opts;
      295. 
+
    295. 40            if (o.sql) {
      296. 
+
    296. 2                return this.mergeOptions();
      297. 
+
    297.              }
      298. 
+
    298. 38            var h = {};
      299. 
+
    299. 38            array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
      300. 
+
    300. 65                h[k] = this._qualifiedExpression(o[k], table);
      301. 
+
    301.              }, this);
      302. 
+
    302. 38            if (!o.select || isEmpty(o.select)) {
      303. 
+
    303. 14                h.select = [new ColumnAll(table)];
      304. 
+
    304.              }
      305. 
+
    305. 38            return this.mergeOptions(h);
      306. 
 
    306.          },
      307. 
 
    307.  
      308. 
-
    308.          isLike:function like(val, opts) {
      309. 
-
    309. 3            return this.__addAction(function (col) {
      310. 
-
    310. 14                return !!col.match(val);
      311. 
-
    311.              }, merge({message:"{col} must be like " + val + " got {val}."}, opts));
      312. 
+
    312.          /**
      313. 
+
    313.           * Same as {@link patio.Dataset@qualifyTo} except that it forces qualification on methods called
      314. 
+
    314.           * after it has been called.
      315. 
+
    315.           *
      316. 
+
    316.           * @example
      317. 
+
    317.           *
      318. 
+
    318.           * //qualfyTo would generate
      319. 
+
    319.           * DB.from("items").qualifyTo("i").filter({id : 1});
      320. 
+
    320.           *      //=> SELECT i.* FROM items WHERE (id = 1)
      321. 
+
    321.           *
      322. 
+
    322.           * //alwaysQualify qualifies filter also.
      323. 
+
    323.           * DB.from("items").alwaysQualify("i").filter({id : 1});
      324. 
+
    324.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      325. 
+
    325.           *
      326. 
+
    326.           *
      327. 
+
    327.           * @param {String|patio.sql.Identifier} [table=this.firstSourceAlias] the table to qualify to.
      328. 
+
    328.           * @return {patio.Dataset} a cloned dataset that will always qualify.
      329. 
+
    329.           */
      330. 
+
    330.          alwaysQualify: function (table) {
      331. 
+
    331. 3            return this.mergeOptions({alwaysQualify: table || this.firstSourceAlias});
      332. 
 
    332.          },
      333. 
 
    333.  
      334. 
-
    334.          isNotLike:function notLike(val, opts) {
      335. 
-
    335. 2            return this.__addAction(function (col) {
      336. 
-
    336. 6                return !(!!col.match(val));
      337. 
-
    337.              }, merge({message:"{col} must not be like " + val + "."}, opts));
      338. 
-
    338.          },
      339. 
 
    339.  
      340. 
-
    340.          isLt:function lt(num, opts) {
      341. 
-
    341. 1            return this.__addAction(function (col) {
      342. 
-
    342. 3                return col < num;
      343. 
-
    343.              }, merge({message:"{col} must be < " + num + " got {val}."}, opts));
      344. 
+
    344.          /**
      345. 
+
    345.           * Returns a copy of the dataset with the order reversed. If no order is
      346. 
+
    346.           * given, the existing order is inverted.
      347. 
+
    347.           *
      348. 
+
    348.           * @example
      349. 
+
    349.           * DB.from("items").reverse("id");
      350. 
+
    350.           *      //=> SELECT * FROM items ORDER BY id DESC
      351. 
+
    351.           *
      352. 
+
    352.           * DB.from("items").order("id").reverse();
      353. 
+
    353.           *      //=> SELECT * FROM items ORDER BY id DESC
      354. 
+
    354.           *
      355. 
+
    355.           * DB.from("items").order("id").reverse(sql.identifier("name").asc);
      356. 
+
    356.           *      //=> SELECT * FROM items ORDER BY name ASC
      357. 
+
    357.           *
      358. 
+
    358.           * @param {String|patio.sql.Identifier|Function} args variable number of columns add to order before reversing.
      359. 
+
    359.           *
      360. 
+
    360.           * @return {patio.Dataset} a cloned dataset with the order reversed.
      361. 
+
    361.           *
      362. 
+
    362.           **/
      363. 
+
    363.          reverse: function (args) {
      364. 
+
    364. 46            args = argsToArray(arguments);
      365. 
+
    365. 46            return this.order.apply(this, this._invertOrder(args.length ? args : this.__opts.order));
      366. 
 
    366.          },
      367. 
 
    367.  
      368. 
-
    368.          isGt:function gt(num, opts) {
      369. 
-
    369. 1            return this.__addAction(function (col) {
      370. 
-
    370. 3                return col > num;
      371. 
-
    371.              }, merge({message:"{col} must be > " + num + " got {val}."}, opts));
      372. 
+
    372.          /**
      373. 
+
    373.           * @see patio.Dataset#reverse
      374. 
+
    374.           */
      375. 
+
    375.          reverseOrder: function () {
      376. 
+
    376. 16            return this.reverse.apply(this, arguments);
      377. 
 
    377.          },
      378. 
 
    378.  
      379. 
-
    379.          isLte:function lte(num, opts) {
      380. 
-
    380. 1            return this.__addAction(function (col) {
      381. 
-
    381. 3                return col <= num;
      382. 
-
    382.              }, merge({message:"{col} must be <= " + num + " got {val}."}, opts));
      383. 
-
    383.          },
      384. 
+
    384.          /**
      385. 
+
    385.           * Returns a copy of the dataset with the columns selected changed
      386. 
+
    386.           * to the given columns. This also takes a function similar to {@link patio.Dataset#filter}
      387. 
+
    387.           *
      388. 
+
    388.           * @example
      389. 
+
    389.           *   DB.from("items").select("a");
      390. 
+
    390.           *      //=> SELECT a FROM items
      391. 
+
    391.           *
      392. 
+
    392.           *   DB.from("items").select("a", "b");
      393. 
+
    393.           *      //=> SELECT a, b FROM items
      394. 
+
    394.           *
      395. 
+
    395.           *   DB.from("items").select("a", function(){
      396. 
+
    396.           *          return this.sum("b")
      397. 
+
    397.           *   }).sql;  //=> SELECT a, sum(b) FROM items
      398. 
+
    398.           *
      399. 
+
    399.           *  @param {String|patio.sql.Identifier|Function} args variable number of colums to select
      400. 
+
    400.           *  @return {patio.Dataset} a cloned dataset with the columns selected changed.
      401. 
+
    401.           */
      402. 
+
    402.          select: function (args) {
      403. 
+
    403. 663            args = flatten(argsToArray(arguments));
      404. 
+
    404. 663            var columns = [];
      405. 
+
    405. 663            args.forEach(function (c) {
      406. 
+
    406. 1043                if (isFunction(c)) {
      407. 
+
    407. 23                    var res = c.apply(sql, [sql]);
      408. 
+
    408. 23                    columns = columns.concat(isArray(res) ? res : [res]);
      409. 
+
    409.                  } else {
      410. 
+
    410. 1020                    columns.push(c);
      411. 
+
    411.                  }
      412. 
+
    412.              });
      413. 
+
    413. 663            var select = [];
      414. 
+
    414. 663            columns.forEach(function (c) {
      415. 
+
    415. 1046                if (isHash(c)) {
      416. 
+
    416. 3                    for (var i in c) {
      417. 
+
    417. 4                        select.push(new AliasedExpression(new Identifier(i), c[i]));
      418. 
+
    418.                      }
      419. 
+
    419. 1043                } else if (isString(c)) {
      420. 
+
    420. 344                    select.push(this.stringToIdentifier(c));
      421. 
+
    421.                  } else {
      422. 
+
    422. 699                    select.push(c);
      423. 
+
    423.                  }
      424. 
+
    424.              }, this);
      425. 
+
    425. 663            return this.mergeOptions({select: select});
      426. 
 
    426.  
      427. 
-
    427.          isGte:function gte(num, opts) {
      428. 
-
    428. 1            return this.__addAction(function (col) {
      429. 
-
    429. 3                return col >= num;
      430. 
-
    430.              }, merge({message:"{col} must be >= " + num + " got {val}."}, opts));
      431. 
 
    431.          },
      432. 
 
    432.  
      433. 
-
    433.          isIn:function isIn(arr, opts) {
      434. 
-
    434. 2            if (!isArray(arr)) {
      435. 
-
    435. 1                throw new Error("isIn requires an array of values");
      436. 
-
    436.              }
      437. 
-
    437. 1            return this.__addAction(function (col) {
      438. 
-
    438. 3                return arr.indexOf(col) !== -1;
      439. 
-
    439.              }, merge({message:"{col} must be in " + arr.join(",") + " got {val}."}, opts));
      440. 
+
    440.          /**
      441. 
+
    441.           * Returns a cloned dataset that selects *.
      442. 
+
    442.           *
      443. 
+
    443.           * @return {patio.Dataset}  a cloned dataset that selects *.
      444. 
+
    444.           */
      445. 
+
    445.          selectAll: function () {
      446. 
+
    446. 6            return this.mergeOptions({select: null});
      447. 
 
    447.          },
      448. 
 
    448.  
      449. 
-
    449.          isNotIn:function notIn(arr, opts) {
      450. 
-
    450. 2            if (!isArray(arr)) {
      451. 
-
    451. 1                throw new Error("notIn requires an array of values");
      452. 
+
    452.          /**
      453. 
+
    453.           * Selects the columns if only if there is not already select sources.
      454. 
+
    454.           *
      455. 
+
    455.           * @example
      456. 
+
    456.           *
      457. 
+
    457.           * var ds = DB.from("items"); //SELECT * FROM items
      458. 
+
    458.           *
      459. 
+
    459.           * ds.select("a"); //SELECT a FROM items;
      460. 
+
    460.           * ds.select("a").selectIfNoSource("a", "b"). //SELECT a FROM items;
      461. 
+
    461.           * ds.selectIfNoSource("a", "b"). //SELECT a, b FROM items;
      462. 
+
    462.           *
      463. 
+
    463.           * @param cols columns to select if there is not already select sources.
      464. 
+
    464.           * @return {patio.Dataset} a cloned dataset with the appropriate select sources.
      465. 
+
    465.           */
      466. 
+
    466.          selectIfNoSource: function (cols) {
      467. 
+
    467. 0            var ret;
      468. 
+
    468. 0            if (!this.hasSelectSource) {
      469. 
+
    469. 0                ret = this.select.apply(this, arguments);
      470. 
+
    470.              } else {
      471. 
+
    471. 0                ret = this.mergeOptions();
      472. 
 
    472.              }
      473. 
-
    473. 1            return this.__addAction(function (col) {
      474. 
-
    474. 3                return arr.indexOf(col) === -1;
      475. 
-
    475.              }, merge({message:"{col} cannot be in " + arr.join(",") + " got {val}."}, opts));
      476. 
-
    476.          },
      477. 
-
    477.  
      478. 
-
    478.          isMacAddress:function isMaxAddress(opts) {
      479. 
-
    479. 1            return this.__addAction(function (col) {
      480. 
-
    480. 4                return !!col.match(/^([0-9A-F]{2}[:\-]){5}([0-9A-F]{2})$/);
      481. 
-
    481.              }, merge({message:"{col} must be a valid MAC address got {val}."}, opts));
      482. 
-
    482.          },
      483. 
-
    483.  
      484. 
-
    484.          isIPAddress:function isIpAddress(opts) {
      485. 
-
    485. 1            return this.__addAction(function (col) {
      486. 
-
    486. 4                return !!isIP(col);
      487. 
-
    487.              }, merge({message:"{col} must be a valid IPv4 or IPv6 address got {val}."}, opts));
      488. 
-
    488.          },
      489. 
-
    489.  
      490. 
-
    490.          isIPv4Address:function isIpAddress(opts) {
      491. 
-
    491. 1            return this.__addAction(function (col) {
      492. 
-
    492. 3                return isIPv4(col);
      493. 
-
    493.              }, merge({message:"{col} must be a valid IPv4 address got {val}."}, opts));
      494. 
-
    494.          },
      495. 
-
    495.  
      496. 
-
    496.          isIPv6Address:function isIpAddress(opts) {
      497. 
-
    497. 1            return this.__addAction(function (col) {
      498. 
-
    498. 3                return isIPv6(col);
      499. 
-
    499.              }, merge({message:"{col} must be a valid IPv6 address got {val}."}, opts));
      500. 
+
    500. 0            return ret;
      501. 
 
    501.          },
      502. 
 
    502.  
      503. 
-
    503.          isUUID:function isUUID(opts) {
      504. 
-
    504. 1            return this.__addAction(function (col) {
      505. 
-
    505. 3                return !!col.match(/^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$/);
      506. 
-
    506.              }, merge({message:"{col} must be a valid UUID got {val}"}, opts));
      507. 
+
    507.          /**
      508. 
+
    508.           * Returns a copy of the dataset with the given columns added
      509. 
+
    509.           * to the existing selected columns. If no columns are currently selected,
      510. 
+
    510.           * it will select the columns given in addition to *.
      511. 
+
    511.           *
      512. 
+
    512.           * @example
      513. 
+
    513.           *   DB.from("items").select("a").selectAppend("b").sql;
      514. 
+
    514.           *      //=> SELECT b FROM items
      515. 
+
    515.           *
      516. 
+
    516.           *   DB.from("items").select("a").selectAppend("b", "c", "d").sql
      517. 
+
    517.           *      //=> SELECT a, b, c, d FROM items
      518. 
+
    518.           *
      519. 
+
    519.           *   DB.from("items").selectAppend("b").sql
      520. 
+
    520.           *      //=> SELECT *, b FROM items
      521. 
+
    521.           *
      522. 
+
    522.           * @param [...] cols variable number of columns to add to the select statement
      523. 
+
    523.           *
      524. 
+
    524.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      525. 
+
    525.           */
      526. 
+
    526.          selectAppend: function (cols) {
      527. 
+
    527. 7            cols = argsToArray(arguments);
      528. 
+
    528. 7            var currentSelect = this.__opts.select;
      529. 
+
    529. 7            if (!currentSelect || !currentSelect.length) {
      530. 
+
    530. 3                currentSelect = [this._static.WILDCARD];
      531. 
+
    531.              }
      532. 
+
    532. 7            return this.select.apply(this, currentSelect.concat(cols));
      533. 
 
    533.          },
      534. 
 
    534.  
      535. 
-
    535.          isEmail:function isEmail(opts) {
      536. 
-
    536. 1            return this.__addAction(function (col) {
      537. 
-
    537. 3                return validatorCheck(col).isEmail();
      538. 
-
    538.              }, merge({message:"{col} must be a valid Email Address got {val}"}, opts));
      539. 
+
    539.          /**
      540. 
+
    540.           * Returns a copy of the dataset with the given columns added
      541. 
+
    541.           * to the existing selected columns. If no columns are currently selected
      542. 
+
    542.           * it will just select the columns given.
      543. 
+
    543.           *
      544. 
+
    544.           * @example
      545. 
+
    545.           *   DB.from("items").select("a").select("b").sql;
      546. 
+
    546.           *      //=> SELECT b FROM items
      547. 
+
    547.           *
      548. 
+
    548.           *   DB.from("items").select("a").selectMore("b", "c", "d").sql
      549. 
+
    549.           *      //=> SELECT a, b, c, d FROM items
      550. 
+
    550.           *
      551. 
+
    551.           *   DB.from("items").selectMore("b").sql
      552. 
+
    552.           *      //=> SELECT b FROM items
      553. 
+
    553.           *
      554. 
+
    554.           * @param [...] cols variable number of columns to add to the select statement
      555. 
+
    555.           *
      556. 
+
    556.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      557. 
+
    557.           */
      558. 
+
    558.          selectMore: function (cols) {
      559. 
+
    559. 10            cols = argsToArray(arguments);
      560. 
+
    560. 10            var currentSelect = this.__opts.select;
      561. 
+
    561. 10            return this.select.apply(this, (currentSelect || []).concat(cols));
      562. 
 
    562.          },
      563. 
 
    563.  
      564. 
-
    564.          isUrl:function isUrl(opts) {
      565. 
-
    565. 1            return this.__addAction(function (col) {
      566. 
-
    566. 3                return validatorCheck(col).isUrl();
      567. 
-
    567.              }, merge({message:"{col} must be a valid url got {val}"}, opts));
      568. 
+
    568.          /**
      569. 
+
    569.           * Set the default values for insert and update statements.  The values hash passed
      570. 
+
    570.           * to insert or update are merged into this hash, so any values in the hash passed
      571. 
+
    571.           * to insert or update will override values passed to this method.
      572. 
+
    572.           *
      573. 
+
    573.           *  @example
      574. 
+
    574.           *   DB.from("items").setDefaults({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      575. 
+
    575.           *      //=> INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
      576. 
+
    576.           *
      577. 
+
    577.           * @param {Object} hash object with key value pairs to use as override values
      578. 
+
    578.           *
      579. 
+
    579.           * @return {patio.Dataset} a cloned dataset with the defaults added to the current datasets defaults.
      580. 
+
    580.           */
      581. 
+
    581.          setDefaults: function (hash) {
      582. 
+
    582. 5            return this.mergeOptions({defaults: merge({}, this.__opts.defaults || {}, hash)});
      583. 
 
    583.          },
      584. 
 
    584.  
      585. 
-
    585.          isAlpha:function isAlpha(opts) {
      586. 
-
    586. 2            return this.__addAction(function (col) {
      587. 
-
    587. 11                return validatorCheck(col).isAlpha();
      588. 
-
    588.              }, merge({message:"{col} must be a only letters got {val}"}, opts));
      589. 
+
    589.          /**
      590. 
+
    590.           * Set values that override hash arguments given to insert and update statements.
      591. 
+
    591.           * This hash is merged into the hash provided to insert or update, so values
      592. 
+
    592.           * will override any values given in the insert/update hashes.
      593. 
+
    593.           *
      594. 
+
    594.           * @example
      595. 
+
    595.           *   DB.from("items").setOverrides({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      596. 
+
    596.           *      //=> INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
      597. 
+
    597.           *
      598. 
+
    598.           * @param {Object} hash object with key value pairs to use as override values
      599. 
+
    599.           *
      600. 
+
    600.           * @return {patio.Dataset} a cloned dataset with the overrides added to the current datasets overrides.
      601. 
+
    601.           */
      602. 
+
    602.          setOverrides: function (hash) {
      603. 
+
    603. 5            return this.mergeOptions({overrides: merge({}, this.__opts.overrides || {}, hash)});
      604. 
 
    604.          },
      605. 
 
    605.  
      606. 
-
    606.          isAlphaNumeric:function isAlphaNumeric(opts) {
      607. 
-
    607. 1            return this.__addAction(function (col) {
      608. 
-
    608. 3                return validatorCheck(col).isAlphanumeric();
      609. 
-
    609.              }, merge({message:"{col} must be a alphanumeric got {val}"}, opts));
      610. 
+
    610.          /**
      611. 
+
    611.           * Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
      612. 
+
    612.           * @example
      613. 
+
    613.           *  DB.from("items").group("a").having({a : 1}).where("b").unfiltered().sql;
      614. 
+
    614.           *      //=> SELECT * FROM items GROUP BY a
      615. 
+
    615.           *
      616. 
+
    616.           * @return {patio.Dataset} a cloned dataset with no HAVING or WHERE clause.
      617. 
+
    617.           */
      618. 
+
    618.          unfiltered: function () {
      619. 
+
    619. 14            return this.mergeOptions({where: null, having: null});
      620. 
 
    620.          },
      621. 
 
    621.  
      622. 
-
    622.          hasLength:function hasLength(min, max, opts) {
      623. 
-
    623. 2            return this.__addAction(function (col) {
      624. 
-
    624. 6                return validatorCheck(col).len(min, max);
      625. 
-
    625.              }, merge({message:"{col} must have a length between " + min + (max ? " and " + max : "") + "."}, opts));
      626. 
+
    626.          /**
      627. 
+
    627.           * Returns a copy of the dataset with no GROUP or HAVING clause.
      628. 
+
    628.           *
      629. 
+
    629.           * @example
      630. 
+
    630.           *  DB.from("t").group("a").having({a : 1}).where("b").ungrouped().sql;
      631. 
+
    631.           *      //=> SELECT * FROM t WHERE b
      632. 
+
    632.           *
      633. 
+
    633.           * @return {patio.Dataset} a cloned dataset with no GROUP or HAVING clause.
      634. 
+
    634.           */
      635. 
+
    635.          ungrouped: function () {
      636. 
+
    636. 1            return this.mergeOptions({group: null, having: null});
      637. 
 
    637.          },
      638. 
 
    638.  
      639. 
-
    639.          isLowercase:function isLowercase(opts) {
      640. 
-
    640. 1            return this.__addAction(function (col) {
      641. 
-
    641. 3                return validatorCheck(col).isLowercase();
      642. 
-
    642.              }, merge({message:"{col} must be lowercase got {val}."}, opts));
      643. 
+
    643.          /**
      644. 
+
    644.           * Adds a UNION clause using a second dataset object.
      645. 
+
    645.           * A UNION compound dataset returns all rows in either the current dataset
      646. 
+
    646.           * or the given dataset.
      647. 
+
    647.           * Options:
      648. 
+
    648.           * :alias :: Use the given value as the from_self alias
      649. 
+
    649.           * :all :: Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
      650. 
+
    650.           * :from_self :: Set to false to not wrap the returned dataset in a from_self, use with care.
      651. 
+
    651.           *
      652. 
+
    652.           * @example
      653. 
+
    653.           * DB.from("items").union(DB.from("otherItems")).sql;
      654. 
+
    654.           *      //=> SELECT * FROM items UNION SELECT * FROM other_items
      655. 
+
    655.           *
      656. 
+
    656.           * DB.from("items").union(DB.from("otherItems"), {all : true, fromSelf : false}).sql;
      657. 
+
    657.           *      //=> SELECT * FROM items UNION ALL SELECT * FROM other_items
      658. 
+
    658.           *
      659. 
+
    659.           * DB.from("items").union(DB.from("otherItems"), {alias : "i"})
      660. 
+
    660.           *      //=> SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS i
      661. 
+
    661.           *
      662. 
+
    662.           * @param {patio.Dataset} dataset dataset to union with
      663. 
+
    663.           * @param {Object} opts addional options
      664. 
+
    664.           * @param {String|patio.sql.Identifier} [opts.alias] Alias to use as the fromSelf alias.
      665. 
+
    665.           * @param {Boolean} [opt.all=false] Set to true to use UNION ALL instead of UNION so duplicate rows can occur
      666. 
+
    666.           * @param {Boolean} [opts.fromSelf=true] Set to false to not wrap the returned dataset in a fromSelf.
      667. 
+
    667.           *
      668. 
+
    668.           * @return {patio.Dataset} a cloned dataset with the union.
      669. 
+
    669.           *
      670. 
+
    670.           */
      671. 
+
    671.          union: function (dataset, opts) {
      672. 
+
    672. 21            opts = isUndefined(opts) ? {} : opts;
      673. 
+
    673. 21            if (!isHash(opts)) {
      674. 
+
    674. 3                opts = {all: opts};
      675. 
+
    675.              }
      676. 
+
    676. 21            return this.compoundClone("union", dataset, opts);
      677. 
 
    677.          },
      678. 
 
    678.  
      679. 
-
    679.          isUppercase:function isUppercase(opts) {
      680. 
-
    680. 1            return this.__addAction(function (col) {
      681. 
-
    681. 3                return validatorCheck(col).isUppercase();
      682. 
-
    682.              }, merge({message:"{col} must be uppercase got {val}."}, opts));
      683. 
+
    683.          /**
      684. 
+
    684.           * Returns a copy of the dataset with no limit or offset.
      685. 
+
    685.           *
      686. 
+
    686.           * @example
      687. 
+
    687.           *  DB.from("t").limit(10, 20).unlimited().sql;
      688. 
+
    688.           *      //=> SELECT * FROM t
      689. 
+
    689.           *
      690. 
+
    690.           * @return {patio.Dataset} a cloned dataset with no limit or offset.
      691. 
+
    691.           */
      692. 
+
    692.          unlimited: function () {
      693. 
+
    693. 1            return this.mergeOptions({limit: null, offset: null});
      694. 
 
    694.          },
      695. 
 
    695.  
      696. 
-
    696.          isEmpty:function isEmpty(opts) {
      697. 
-
    697. 1            return this.__addAction(function (col) {
      698. 
-
    698. 3                try {
      699. 
-
    699. 3                    validatorCheck(col).notEmpty();
      700. 
-
    700. 2                    return false;
      701. 
-
    701.                  } catch (e) {
      702. 
-
    702. 1                    return true;
      703. 
-
    703.                  }
      704. 
-
    704.              }, merge({message:"{col} must be empty got {val}."}, opts));
      705. 
+
    705.          /**
      706. 
+
    706.           * Returns a copy of the dataset with no order.
      707. 
+
    707.           *
      708. 
+
    708.           * @example
      709. 
+
    709.           *  DB.from("t").order("a", sql.identifier("b").desc()).unordered().sql;
      710. 
+
    710.           *      //=> SELECT * FROM t
      711. 
+
    711.           *
      712. 
+
    712.           * @return {patio.Dataset} a cloned dataset with no order.
      713. 
+
    713.           */
      714. 
+
    714.          unordered: function () {
      715. 
+
    715. 115            return this.order(null);
      716. 
 
    716.          },
      717. 
 
    717.  
      718. 
-
    718.          isNotEmpty:function isNotEmpty(opts) {
      719. 
-
    719. 2            return this.__addAction(function (col) {
      720. 
-
    720. 11                return validatorCheck(col).notEmpty();
      721. 
-
    721.              }, merge({message:"{col} must not be empty."}, opts));
      722. 
+
    722.          /**
      723. 
+
    723.           * Add a condition to the WHERE clause.  See {@link patio.Dataset#filter} for argument types.
      724. 
+
    724.           *
      725. 
+
    725.           * @example
      726. 
+
    726.           *   DB.from("test").where('price < ? AND id in ?', 100, [1, 2, 3]).sql;
      727. 
+
    727.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
      728. 
+
    728.           *   DB.from("test").where('price < {price} AND id in {ids}', {price:100, ids:[1, 2, 3]}).sql;
      729. 
+
    729.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))")
      730. 
+
    730.           *
      731. 
+
    731.           */
      732. 
+
    732.          where: function () {
      733. 
+
    733. 252            return this._filter.apply(this, ["where"].concat(argsToArray(arguments)));
      734. 
 
    734.          },
      735. 
 
    735.  
      736. 
-
    736.          isCreditCard:function isCreditCard(opts) {
      737. 
-
    737. 0            return this.__addAction(function (col) {
      738. 
-
    738. 0                return validatorCheck(col).isCreditCard();
      739. 
-
    739.              }, merge({message:"{col} is an invalid credit card"}, opts));
      740. 
+
    740.          /**
      741. 
+
    741.           * Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
      742. 
+
    742.           * A common table expression acts as an inline view for the query.
      743. 
+
    743.           *
      744. 
+
    744.           * @name with
      745. 
+
    745.           * @example
      746. 
+
    746.           *
      747. 
+
    747.           * DB.from("t")["with"]("t", db.from("x"))["with"]("j", db.from("y")).sql;
      748. 
+
    748.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y) SELECT * FROM t'
      749. 
+
    749.           *
      750. 
+
    750.           * DB.from("t")["with"]("t", db.from("x")).withRecursive("j", db.from("y"), db.from("j")).sql;
      751. 
+
    751.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
      752. 
+
    752.           *
      753. 
+
    753.           * DB.from("t")["with"]("t", db.from("x"), {args:["b"]}).sql;
      754. 
+
    754.           *      //=> 'WITH t(b) AS (SELECT * FROM x) SELECT * FROM t'
      755. 
+
    755.           *
      756. 
+
    756.           * @param {String} name the name of the to assign to the CTE.
      757. 
+
    757.           * @param {patio.Dataset} dataset the dataset to use for the CTE.
      758. 
+
    758.           * @param {Object} opts extra options.
      759. 
+
    759.           * @param {String[]} [opts.args] colums/args for the CTE.
      760. 
+
    760.           * @param {Boolean} [opts.recursive] set to true that the CTE is recursive.
      761. 
+
    761.           *
      762. 
+
    762.           * @return {patio.Dataset} a cloned dataset with the CTE.
      763. 
+
    763.           */
      764. 
+
    764.          "with": function (name, dataset, opts) {
      765. 
+
    765. 6            if (!this.supportsCte) {
      766. 
+
    766. 1                throw new QueryError("this dataset does not support common table expressions");
      767. 
+
    767.              }
      768. 
+
    768. 5            return this.mergeOptions({
      769. 
+
    769.                  "with": (this.__opts["with"] || []).concat([merge(opts || {}, {name: this.stringToIdentifier(name), dataset: dataset})])
      770. 
+
    770.              });
      771. 
 
    771.          },
      772. 
 
    772.  
      773. 
-
    773.          check:function (fun, opts) {
      774. 
-
    774. 4            return this.__addAction(fun, opts);
      775. 
+
    775.          /**
      776. 
+
    776.           * Add a recursive common table expression (CTE) with the given name, a dataset that
      777. 
+
    777.           * defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
      778. 
+
    778.           * of the CTE.
      779. 
+
    779.           *
      780. 
+
    780.           *  @example
      781. 
+
    781.           *
      782. 
+
    782.           * //Sing withRecursive call.
      783. 
+
    783.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t")).sql;
      784. 
+
    784.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      785. 
+
    785.           *
      786. 
+
    786.           * //Multiple withRecursive calls.
      787. 
+
    787.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"))
      788. 
+
    788.           *    .withRecursive("j", db.from("y"), db.from("j")).sql;
      789. 
+
    789.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t),
      790. 
+
    790.           *                     j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t';
      791. 
+
    791.           *
      792. 
+
    792.           * //Adding args
      793. 
+
    793.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {args:["b", "c"]}).sql;
      794. 
+
    794.           *          //=> 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      795. 
+
    795.           *
      796. 
+
    796.           * //Setting union all to false
      797. 
+
    797.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {unionAll:false}).sql;
      798. 
+
    798.           *          //=> 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t');
      799. 
+
    799.           *
      800. 
+
    800.           * @param {String} name the name to assign to the CTE
      801. 
+
    801.           * @param {patio.Dataset} nonRecursive the non-recursive part of the CTE
      802. 
+
    802.           * @param {patio.Dataset} recursive the recursive part of the CTE
      803. 
+
    803.           * @param {Object} [opts={}] extra options
      804. 
+
    804.           * @param {String[]} [opts.args] columns to include with the CTE
      805. 
+
    805.           * @param {Boolena} [opts.unionAll] set to false to use UNION instead of UNION ALL when combining non recursive
      806. 
+
    806.           *                                with recursive.
      807. 
+
    807.           *
      808. 
+
    808.           * @return {patio.Dataset} a cloned dataset with the CTE.
      809. 
+
    809.           */
      810. 
+
    810.          withRecursive: function (name, nonRecursive, recursive, opts) {
      811. 
+
    811. 7            if (!this.supportsCte) {
      812. 
+
    812. 1                throw new QueryError("This dataset does not support common table expressions");
      813. 
+
    813.              }
      814. 
+
    814. 6            opts = opts || {};
      815. 
+
    815. 6            var wit = (this.__opts["with"] || []).concat([merge(opts, {recursive: true, name: this.stringToIdentifier(name), dataset: nonRecursive.union(recursive, {all: opts.unionAll != false, fromSelf: false})})]);
      816. 
+
    816. 6            return this.mergeOptions({"with": wit});
      817. 
 
    817.          },
      818. 
 
    818.  
      819. 
-
    819.          validate:function validate(value) {
      820. 
-
    820. 218            var errOpts = {col:this.col, val:value};
      821. 
-
    821. 218            return compact(this.__actions.map(function (action) {
      822. 
-
    822. 248                var actionOpts = action.opts;
      823. 
-
    823. 248                if (!actionOpts.onlyDefined || (combIsDefined(value) &&
      824. 
-
    824.                      (!actionOpts.onlyNotNull || !combIsNull(value)) )) {
      825. 
-
    825. 186                    var ret = null;
      826. 
-
    826. 186                    try {
      827. 
-
    827. 186                        if (!action.action(value)) {
      828. 
-
    828. 69                            ret = format(actionOpts.message, errOpts);
      829. 
-
    829.                          }
      830. 
-
    830.                      } catch (e) {
      831. 
-
    831. 28                        ret = format(actionOpts.message, errOpts);
      832. 
-
    832.                      }
      833. 
-
    833. 186                    return ret;
      834. 
-
    834.                  }
      835. 
-
    835.              }, this));
      836. 
-
    836.          }
      837. 
-
    837.  
      838. 
-
    838.      }
      839. 
-
    839.  });
      840. 
-
    840.  
      841. 
-
    841. 1function shouldValidate(opts, def) {
      842. 
-
    842. 115    opts = opts || {};
      843. 
-
    843. 115    return combIsBoolean(opts.validate) ? opts.validate : def;
      844. 
-
    844.  }
      845. 
-
    845.  
      846. 
-
    846. 1function validateHook(prop, next, opts) {
      847. 
-
    847. 115    if (shouldValidate(opts, prop) && !this.isValid()) {
      848. 
-
    848. 45        next(flatten(toArray(this.errors).map(function (entry) {
      849. 
-
    849. 64            return entry[1].map(function (err) {
      850. 
-
    850. 48                return new Error(err);
      851. 
-
    851.              });
      852. 
-
    852.          })));
      853. 
-
    853.      } else {
      854. 
-
    854. 70        next();
      855. 
-
    855.      }
      856. 
-
    856.  }
      857. 
-
    857.  
      858. 
-
    858. 1define(null, {
      859. 
+
    859.          /**
      860. 
+
    860.           * Returns a copy of the dataset with the static SQL used.  This is useful if you want
      861. 
+
    861.           * to keep the same {@link patio.Dataset#rowCb}/{@link patio.Dataset#graph},
      862. 
+
    862.           *  but change the SQL used to custom SQL.
      863. 
+
    863.           *
      864. 
+
    864.           * @example
      865. 
+
    865.           *  DB.from("items").withSql('SELECT * FROM foo')
      866. 
+
    866.           *          //=> SELECT * FROM foo
      867. 
+
    867.           *
      868. 
+
    868.           *  @param {String} sql sql for the dataset to use.
      869. 
+
    869.           *
      870. 
+
    870.           *  @return {patio.Dataset} a cloned dataset with the static sql set.
      871. 
+
    871.           */
      872. 
+
    872.          withSql: function (sql) {
      873. 
+
    873. 46            var args = argsToArray(arguments).slice(1);
      874. 
+
    874. 46            if (args.length) {
      875. 
+
    875. 23                sql = new PlaceHolderLiteralString(sql, args)
      876. 
+
    876.              }
      877. 
+
    877. 46            return this.mergeOptions({sql: sql});
      878. 
+
    878.          },
      879. 
 
    879.  
      880. 
-
    880.      instance:{
      881. 
 
    881.  
      882. 
 
    882.          /**
      883. 
-
    883.           * A validation plugin for patio models. This plugin adds a <code>validate</code> method to each {@link patio.Model}
      884. 
-
    884.           * class that adds it as a plugin. This plugin does not include most typecast checks as <code>patio</code> already checks
      885. 
-
    885.           * types upon column assignment.
      886. 
+
    886.           * Add the dataset to the list of compounds
      887. 
 
    887.           *
      888. 
-
    888.           * To do single col validation
      889. 
-
    889.           * {@code
      890. 
+
    890.           * @param {String} type the type of compound (i.e. "union", "intersect")
      891. 
+
    891.           * @param {patio.Dataset} dataset the dataset to add to
      892. 
+
    892.           * @param [Object] [options={}] compound option to use (i.e {all : true})
      893. 
 
    893.           *
      894. 
-
    894.           * var Model = patio.addModel("validator", {
      895. 
-
    895.           *      plugins:[ValidatorPlugin]
      896. 
-
    896.           * });
      897. 
-
    897.           * //this ensures column assignment
      898. 
-
    898.           * Model.validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
      899. 
-
    899.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
      900. 
-
    900.           * Model.validate("col2").like(/hello/ig);
      901. 
-
    901.           * //Ensures that the emailAddress column is a valid email address.
      902. 
-
    902.           * Model.validate("emailAddress").isEmailAddress();
      903. 
-
    903.           * }
      904. 
+
    904.           * @return {patio.Dataset} ds with the dataset added to the compounds.
      905. 
+
    905.           */
      906. 
+
    906.          compoundClone: function (type, dataset, options) {
      907. 
+
    907. 51            var ds = this._compoundFromSelf().mergeOptions({compounds: (array.toArray(this.__opts.compounds || [])).concat([
      908. 
+
    908.                  [type, dataset._compoundFromSelf(), options.all]
      909. 
+
    909.              ])});
      910. 
+
    910. 51            return options.fromSelf === false ? ds : ds.fromSelf(options);
      911. 
+
    911.          },
      912. 
+
    912.  
      913. 
+
    913.          /**
      914. 
+
    914.           * Returns the a cloned dataset with out the {@link patio.Dataset#rowCb}
      915. 
 
    915.           *
      916. 
-
    916.           * Or you can do a mass validation through a callback.
      917. 
-
    917.           * {@code
      918. 
+
    918.           * @example
      919. 
+
    919.           * var ds = DB.from("test");
      920. 
+
    920.           * ds.rowCb = function(r){
      921. 
+
    921.           *     r.a = r.a * 2;
      922. 
+
    922.           * }
      923. 
 
    923.           *
      924. 
-
    924.           * var Model = patio.addModel("validator", {
      925. 
-
    925.           *      plugins:[ValidatorPlugin]
      926. 
+
    926.           * ds.all().then(function(ret){
      927. 
+
    927.           *      //ret === [{a : 4}, {a : 6}]
      928. 
 
    928.           * });
      929. 
-
    929.           * Model.validate(function(validate){
      930. 
-
    930.           *      //this ensures column assignment
      931. 
-
    931.           *      validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
      932. 
-
    932.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
      933. 
-
    933.           *      validate("col2").isLike(/hello/ig);
      934. 
-
    934.           *      //Ensures that the emailAddress column is a valid email address.
      935. 
-
    935.           *      validate("emailAddress").isEmail();
      936. 
+
    936.           * ds.naked().all().then(function(ret){
      937. 
+
    937.           *      //ret ===  [{a : 2}, {a : 3}];
      938. 
 
    938.           * });
      939. 
-
    939.           * }
      940. 
 
    940.           *
      941. 
-
    941.           * To check if a {@link patio.Model} is valid you can run the <code>isValid</code> method.
      942. 
+
    942.           * @return {patio.Dataset} a cloned dataset with out the {@link patio.Dataset#rowCb}
      943. 
+
    943.           */
      944. 
+
    944.          naked: function () {
      945. 
+
    945. 2266            var ds = this.mergeOptions({});
      946. 
+
    946. 2266            ds.rowCb = null;
      947. 
+
    947. 2266            return ds;
      948. 
+
    948.          },
      949. 
+
    949.  
      950. 
+
    950.          /**
      951. 
+
    951.           * @private
      952. 
 
    952.           *
      953. 
-
    953.           * {@code
      954. 
-
    954.           * var model1 = new Model({col2 : 'grape', emailAddress : "test"}),
      955. 
-
    955.           *     model2 = new Model({col1 : "grape", col2 : "hello", emailAddress : "test@test.com"});
      956. 
+
    956.           * Adds a group of conditions joined by the second arg, wrapped in parens, connected to an existing where/having
      957. 
+
    957.           * clause by the first arg.
      958. 
+
    958.           * If the where/having clause doesn't yet exist, a where clause is created with the group.
      959. 
 
    959.           *
      960. 
-
    960.           * model1.isValid() //false
      961. 
-
    961.           * model2.isValid() //true
      962. 
-
    962.           * }
      963. 
+
    963.           * @example
      964. 
 
    964.           *
      965. 
-
    965.           * To get the errors associated with an invalid model you can access the errors property
      966. 
+
    966.           * DB.from("items").filter({id, [1,2,3]})._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
      967. 
+
    967.           *      //=> SELECT
      968. 
+
    968.           *               *
      969. 
+
    969.           *           FROM
      970. 
+
    970.           *               items
      971. 
+
    971.           *           WHERE
      972. 
+
    972.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      973. 
 
    973.           *
      974. 
-
    974.           * {@code
      975. 
-
    975.           * model1.errors; //{ col1: [ 'col1 must be defined.' ],
      976. 
-
    976.           *                //  col2: [ 'col2 must be like /hello/gi got grape.' ],
      977. 
-
    977.           *                //  emailAddress: [ 'emailAddress must be a valid Email Address got test' ] }
      978. 
-
    978.           * }
      979. 
+
    979.           * DB.from("items")._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
      980. 
+
    980.           *      //=> SELECT
      981. 
+
    981.           *               *
      982. 
+
    982.           *           FROM
      983. 
+
    983.           *               items
      984. 
+
    984.           *           WHERE
      985. 
+
    985.           *               ((price < 0) OR (price > 10))
      986. 
 
    986.           *
      987. 
-
    987.           * Validation is also run pre save and pre update. To prevent this you can specify the <code>validate</code> option
      988. 
+
    988.           * @param {String} If there is an existing where/having clause, this arg will join the new condition group to it. "AND" if undef. Should be "AND" or "OR"
      989. 
+
    989.           * @param {String} The conditions will be joined this. Same expectations as the first param.
      990. 
+
    990.           * @param See {@link patio.Dataset#filter}.
      991. 
 
    991.           *
      992. 
-
    992.           * {@code
      993. 
-
    993.           * model1.save(null, {validate : false});
      994. 
-
    994.           * model2.save(null, {validate : false});
      995. 
-
    995.           * }
      996. 
+
    996.           * @return {patio.Dataset} a cloned dataset with the condition group added to the WHERE/HAVING clause.
      997. 
+
    997.           */
      998. 
+
    998.          _addGroupedCondition: function (addedByBool, groupedByBool) {
      999. 
+
    999. 6            groupedByBool = isUndefined(groupedByBool) ? "AND" : groupedByBool;
      1000. 
+
    1000. 6            var tOpts = this.__opts,
      1001. 
+
    1001.                  clause = (tOpts.having ? "having" : "where"),
      1002. 
+
    1002.                  clauseObj = tOpts[clause];
      1003. 
+
    1003. 6            var args = argsToArray(arguments, 2);
      1004. 
+
    1004. 6            args = args.length == 1 ? args[0] : args;
      1005. 
+
    1005. 6            var opts = {};
      1006. 
+
    1006. 6            if (clauseObj) {
      1007. 
+
    1007. 3                addedByBool = isUndefined(addedByBool) ? "AND" : addedByBool;
      1008. 
+
    1008. 3                opts[clause] = new BooleanExpression(addedByBool, clauseObj, this._filterExpr(args, null, groupedByBool));
      1009. 
+
    1009.              } else {
      1010. 
+
    1010. 3                opts[clause] = this._filterExpr(args, null, groupedByBool);
      1011. 
+
    1011.              }
      1012. 
+
    1012. 6            return this.mergeOptions(opts);
      1013. 
+
    1013.          },
      1014. 
+
    1014.  
      1015. 
+
    1015.          /**
      1016. 
+
    1016.           * @private
      1017. 
+
    1017.           * Protected
      1018. 
 
    1018.           *
      1019. 
-
    1019.           * Or you can specify the class level properties <code>validateOnSave</code> and <code>validateOnUpdate</code>
      1020. 
-
    1020.           * to false respectively
      1021. 
-
    1021.           * {@code
      1022. 
-
    1022.           * Model.validateOnSave = false;
      1023. 
-
    1023.           * Model.validateOnUpdate = false;
      1024. 
-
    1024.           * }
      1025. 
+
    1025.           * Internal filter method so it works on either the having or where clauses.
      1026. 
+
    1026.           */
      1027. 
+
    1027.          _filter: function (clause) {
      1028. 
+
    1028. 3765            var cond = argsToArray(arguments).slice(1), cb;
      1029. 
+
    1029. 3765            if (cond.length && isFunction(cond[cond.length - 1])) {
      1030. 
+
    1030. 59                cb = cond.pop();
      1031. 
+
    1031.              }
      1032. 
+
    1032. 3765            cond = cond.length == 1 ? cond[0] : cond
      1033. 
+
    1033. 3765            if ((cond == null || cond == undefined || cond === "") || (isArray(cond) && cond.length == 0 && !cb) || (isObject(cond) && isEmpty(cond) && !cb)) {
      1034. 
+
    1034. 293                return this.mergeOptions();
      1035. 
+
    1035.              } else {
      1036. 
+
    1036. 3472                cond = this._filterExpr(cond, cb);
      1037. 
+
    1037. 3469                var cl = this.__opts[clause];
      1038. 
+
    1038. 3469                cl && (cond = new BooleanExpression("AND", cl, cond));
      1039. 
+
    1039. 3469                var opts = {};
      1040. 
+
    1040. 3469                opts[clause] = cond;
      1041. 
+
    1041. 3469                return this.mergeOptions(opts);
      1042. 
+
    1042.              }
      1043. 
+
    1043.          },
      1044. 
+
    1044.  
      1045. 
+
    1045.          /**
      1046. 
+
    1046.           * Splits a possible implicit alias, handling both {@link patio.sql.AliasedExpression}s
      1047. 
+
    1047.           * and strings.  Returns an array of two elements, with the first being the
      1048. 
+
    1048.           * main expression, and the second being the alias. Alias may be null if it is a
      1049. 
+
    1049.           * string that does not contain an alias {table}___{alias}.
      1050. 
+
    1050.           */
      1051. 
+
    1051.          _splitAlias: function (c) {
      1052. 
+
    1052. 619            var ret;
      1053. 
+
    1053. 619            if (isInstanceOf(c, AliasedExpression)) {
      1054. 
+
    1054. 5                ret = [c.expression, c.alias];
      1055. 
+
    1055. 614            } else if (isString(c)) {
      1056. 
+
    1056. 0                var parts = this._splitString(c), cTable = parts[0], column = parts[1], alias = parts[2];
      1057. 
+
    1057. 0                if (alias) {
      1058. 
+
    1058. 0                    ret = [cTable ? new QualifiedIdentifier(cTable, column) : column, alias];
      1059. 
+
    1059.                  } else {
      1060. 
+
    1060. 0                    ret = [c, null];
      1061. 
+
    1061.                  }
      1062. 
+
    1062.              } else {
      1063. 
+
    1063. 614                ret = [c, null];
      1064. 
+
    1064.              }
      1065. 
+
    1065. 619            return ret;
      1066. 
+
    1066.          },
      1067. 
+
    1067.  
      1068. 
+
    1068.  
      1069. 
+
    1069.          /**
      1070. 
+
    1070.           * @private
      1071. 
+
    1071.           * Inverts the given order by breaking it into a list of column references
      1072. 
+
    1072.           * and inverting them.
      1073. 
 
    1073.           *
      1074. 
-
    1074.           * Avaiable validation methods are.
      1075. 
+
    1075.           *   ds.invertOrder([sql.identifier("id").desc()]]) //=> [id]
      1076. 
+
    1076.           *   ds.invertOrder("category", sql.identifier("price").desc()]) #=> [category.desc(), price]
      1077. 
+
    1077.           */
      1078. 
+
    1078.  
      1079. 
+
    1079.          _invertOrder: function (order) {
      1080. 
+
    1080. 46            var ret = order;
      1081. 
+
    1081. 46            if (order) {
      1082. 
+
    1082. 45                ret = order.map(function (o) {
      1083. 
+
    1083. 57                    if (isInstanceOf(o, OrderedExpression)) {
      1084. 
+
    1084. 17                        return o.invert();
      1085. 
+
    1085.                      } else {
      1086. 
+
    1086. 40                        return new OrderedExpression(isString(o) ? new Identifier(o) : o);
      1087. 
+
    1087.                      }
      1088. 
+
    1088.                  }, this);
      1089. 
+
    1089.              }
      1090. 
+
    1090. 46            return ret;
      1091. 
+
    1091.          },
      1092. 
+
    1092.  
      1093. 
+
    1093.          /**
      1094. 
+
    1094.           * Creates a boolean expression that each key is compared to its value using the provided operator.
      1095. 
 
    1095.           *
      1096. 
-
    1096.           * <ul>
      1097. 
-
    1097.           *  <li><code>isAfter</code> : check that a date is after a specified date</li>
      1098. 
-
    1098.           *  <li><code>isBefore</code> : check that a date is after before a specified date </li>
      1099. 
-
    1099.           *  <li><code>isDefined</code> : ensure that a column is defined</li>
      1100. 
-
    1100.           *  <li><code>isNotDefined</code> : ensure that a column is not defined</li>
      1101. 
-
    1101.           *  <li><code>isNotNull</code> : ensure that a column is defined and not null</li>
      1102. 
-
    1102.           *  <li><code>isNull</code> : ensure that a column is not defined or null</li>
      1103. 
-
    1103.           *  <li><code>isEq</code> : ensure that a column equals a value <b>this uses deep equal</b></li>
      1104. 
-
    1104.           *  <li><code>isNeq</code> : ensure that a column does not equal a value <b>this uses deep equal</b></li>
      1105. 
-
    1105.           *  <li><code>isLike</code> : ensure that a column is like a value, can be a regexp or string</li>
      1106. 
-
    1106.           *  <li><code>isNotLike</code> : ensure that a column is not like a value, can be a regexp or string</li>
      1107. 
-
    1107.           *  <li><code>isLt</code> : ensure that a column is less than a value</li>
      1108. 
-
    1108.           *  <li><code>isGt</code> : ensure that a column is greater than a value</li>
      1109. 
-
    1109.           *  <li><code>isLte</code> : ensure that a column is less than or equal to a value</li>
      1110. 
-
    1110.           *  <li><code>isGte</code> : ensure that a column is greater than or equal to a value</li>
      1111. 
-
    1111.           *  <li><code>isIn</code> : ensure that a column is contained in an array of values</li>
      1112. 
-
    1112.           *  <li><code>isNotIn</code> : ensure that a column is not contained in an array of values</li>
      1113. 
-
    1113.           *  <li><code>isMacAddress</code> : ensure that a column is a valid MAC address</li>
      1114. 
-
    1114.           *  <li><code>isIPAddress</code> : ensure that a column is a valid IPv4 or IPv6 address</li>
      1115. 
-
    1115.           *  <li><code>isIPv4Address</code> : ensure that a column is a valid IPv4 address</li>
      1116. 
-
    1116.           *  <li><code>isIPv6Address</code> : ensure that a column is a valid IPv6 address</li>
      1117. 
-
    1117.           *  <li><code>isUUID</code> : ensure that a column is a valid UUID</li>
      1118. 
-
    1118.           *  <li><code>isEmail</code> : ensure that a column is a valid email address</li>
      1119. 
-
    1119.           *  <li><code>isUrl</code> : ensure than a column is a valid URL</li>
      1120. 
-
    1120.           *  <li><code>isAlpha</code> : ensure than a column is all letters</li>
      1121. 
-
    1121.           *  <li><code>isAlphaNumeric</code> : ensure than a column is all letters or numbers</li>
      1122. 
-
    1122.           *  <li><code>hasLength</code> : ensure than a column is fits within the specified length accepts a min and optional max value</li>
      1123. 
-
    1123.           *  <li><code>isLowercase</code> : ensure than a column is lowercase</li>
      1124. 
-
    1124.           *  <li><code>isUppercase</code> : ensure than a column is uppercase</li>
      1125. 
-
    1125.           *  <li><code>isEmpty</code> : ensure than a column empty (i.e. a blank string)</li>
      1126. 
-
    1126.           *  <li><code>isNotEmpty</code> : ensure than a column not empty (i.e. not a blank string)</li>
      1127. 
-
    1127.           *  <li><code>isCreditCard</code> : ensure than a is a valid credit card number</li>
      1128. 
-
    1128.           *  <li><code>check</code> : accepts a function to perform validation</li>
      1129. 
-
    1129.           * </ul>
      1130. 
+
    1130.           * @example
      1131. 
+
    1131.           *
      1132. 
+
    1132.           * ds.__createBoolExpression("gt", {x : 1, y:2, z : 5}) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1133. 
+
    1133.           * ds.__createBoolExpression("gt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1134. 
+
    1134.           * ds.__createBoolExpression("lt", {x : 1, y:2, z : 5}) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1135. 
+
    1135.           * ds.__createBoolExpression("lt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1136. 
+
    1136.           *
      1137. 
+
    1137.           * @param {String} op valid boolean expression operator to capare each K,V pair with
      1138. 
+
    1138.           * @param {Object| Array } obj object or two dimensional array containing key value pairs
      1139. 
+
    1139.           *
      1140. 
+
    1140.           * @return {patio.sql.BooleanExpression} boolean expression joined by a AND of each key value pair compared by the op
      1141. 
+
    1141.           */
      1142. 
+
    1142.          __createBoolExpression: function (op, obj) {
      1143. 
+
    1143. 32            var pairs = [];
      1144. 
+
    1144. 32            if (Expression.isConditionSpecifier(obj)) {
      1145. 
+
    1145. 32                if (isHash(obj)) {
      1146. 
+
    1146. 18                    obj = array.toArray(obj);
      1147. 
+
    1147.                  }
      1148. 
+
    1148. 32                obj.forEach(function (pair) {
      1149. 
+
    1149. 42                    pairs.push(new BooleanExpression(op, new Identifier(pair[0]), pair[1]));
      1150. 
+
    1150.                  });
      1151. 
+
    1151.              }
      1152. 
+
    1152. 32            return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
      1153. 
+
    1153.          },
      1154. 
+
    1154.  
      1155. 
+
    1155.          /**
      1156. 
+
    1156.           * @private
      1157. 
 
    1157.           *
      1158. 
-
    1158.           * All of the validation methods are chainable, and accept an options argument.
      1159. 
+
    1159.           * Creates a boolean expression where the key is '>=' value 1 and '<=' value two.
      1160. 
 
    1160.           *
      1161. 
-
    1161.           * The options include
      1162. 
-
    1162.           * <ul>
      1163. 
-
    1163.           *     <li><code>message</code> : a message to return if a column fails validation. The message can include <code>{val}</code> and <code>{col}</code>
      1164. 
-
    1164.           *     replacements which will insert the invalid value and the column name.
      1165. 
-
    1165.           *     </li>
      1166. 
-
    1166.           *     <li><code>[onlyDefined=true]</code> : set to false to run the method even if the column value is not defined.</li>
      1167. 
-
    1167.           *     <li><code>[onlyNotNull=true]</code> : set to false to run the method even if the column value is null.</li>
      1168. 
-
    1168.           * </ul>
      1169. 
+
    1169.           * @example
      1170. 
 
    1170.           *
      1171. 
+
    1171.           * ds.__createBetweenExpression({x : [1,2]}) => //=> WHERE ((x >= 1) AND (x <= 10))
      1172. 
+
    1172.           * ds.__createBetweenExpression({x : [1,2]}, true) => //=> WHERE ((x < 1) OR (x > 10))
      1173. 
 
    1173.           *
      1174. 
-
    1174.           * @constructs
      1175. 
-
    1175.           * @name ValidatorPlugin
      1176. 
-
    1176.           * @memberOf patio.plugins
      1177. 
-
    1177.           * @property {Object} [errors={}] the validation errors for this model.
      1178. 
+
    1178.           * @param {Object} obj object where the keys are columns and the values are two element arrays.
      1179. 
+
    1179.           * @param {Boolean} [invert] if set to true it inverts the between to make it not between the two values
      1180. 
 
    1180.           *
      1181. 
+
    1181.           * @return {patio.sql.BooleanExpression} a boolean expression containing the between expression.
      1182. 
 
    1182.           */
      1183. 
-
    1183.          constructor:function () {
      1184. 
-
    1184. 114            this._super(arguments);
      1185. 
-
    1185. 114            this.errors = {};
      1186. 
+
    1186.          __createBetweenExpression: function (obj, invert) {
      1187. 
+
    1187. 4            var pairs = [];
      1188. 
+
    1188. 4            for (var i in obj) {
      1189. 
+
    1189. 4                var v = obj[i];
      1190. 
+
    1190. 4                if (isArray(v) && v.length) {
      1191. 
+
    1191. 2                    var ident = this.stringToIdentifier(i);
      1192. 
+
    1192. 2                    pairs.push(new BooleanExpression("AND", new BooleanExpression("gte", ident, v[0]), new BooleanExpression("lte", ident, v[1])));
      1193. 
+
    1193.                  } else {
      1194. 
+
    1194. 2                    throw new QueryError("Between requires an array for the value");
      1195. 
+
    1195.                  }
      1196. 
+
    1196.              }
      1197. 
+
    1197. 2            var ret = pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs))
      1198. 
+
    1198. 2            return invert ? BooleanExpression.invert(ret) : ret;
      1199. 
 
    1199.          },
      1200. 
 
    1200.  
      1201. 
+
    1201.  
      1202. 
 
    1202.          /**
      1203. 
-
    1203.           * Validates a model, returning an array of error messages for each invalid property.
      1204. 
-
    1204.           * @return {String[]} an array of error messages for each invalid property.
      1205. 
+
    1205.           * @private
      1206. 
+
    1206.           * Converts an array to a two dimensional array where the first element
      1207. 
+
    1207.           * is the identifier and the second argument is the value that the value should equal
      1208. 
+
    1208.           * used by is{Null|NotNull|True|NotTrue|False|notFalse} functions to join all the values passed in.
      1209. 
+
    1209.           * @param {String[]|patio.sql.Identifier} arr array of elements to make a condition specifier out of
      1210. 
+
    1210.           * @param defaultOp the value to assign a value if one is not provided.
      1211. 
+
    1211.           *
      1212. 
+
    1212.           * @return { [[]] } an array of two element arrays.
      1213. 
 
    1213.           */
      1214. 
-
    1214.          validate:function () {
      1215. 
-
    1215. 159            this.errors = {};
      1216. 
-
    1216. 159            return flatten(this._static.validators.map(function runValidator(validator) {
      1217. 
-
    1217. 218                var col = validator.col, val = this.__values[validator.col], ret = validator.validate(val);
      1218. 
-
    1218. 218                this.errors[col] = ret;
      1219. 
-
    1219. 218                return ret;
      1220. 
-
    1220.              }, this));
      1221. 
+
    1221.          __arrayToConditionSpecifier: function (arr, defaultOp) {
      1222. 
+
    1222. 22            var ret = [];
      1223. 
+
    1223. 22            arr.forEach(function (a) {
      1224. 
+
    1224. 28                if (isString(a)) {
      1225. 
+
    1225. 18                    a = this.stringToIdentifier(a);
      1226. 
+
    1226.                  }
      1227. 
+
    1227. 28                if (isInstanceOf(a, Identifier)) {
      1228. 
+
    1228. 18                    ret.push([a, defaultOp]);
      1229. 
+
    1229. 10                } else if (isHash(a)) {
      1230. 
+
    1230. 4                    ret = ret.concat(array.toArray(a));
      1231. 
+
    1231.                  } else {
      1232. 
+
    1232. 6                    throw new QueryError("Invalid condition specifier " + a);
      1233. 
+
    1233.                  }
      1234. 
+
    1234.              }, this);
      1235. 
+
    1235. 16            return ret;
      1236. 
 
    1236.          },
      1237. 
 
    1237.  
      1238. 
 
    1238.          /**
      1239. 
-
    1239.           * Returns if this model passes validation.
      1240. 
+
    1240.           * @private
      1241. 
 
    1241.           *
      1242. 
-
    1242.           * @return {Boolean}
      1243. 
+
    1243.           * SQL expression object based on the expr type.  See {@link patio.Dataset#filter}
      1244. 
 
    1244.           */
      1245. 
-
    1245.          isValid:function () {
      1246. 
-
    1246. 159            return this.validate().length === 0;
      1247. 
+
    1247.          _filterExpr: function (expr, cb, joinCond) {
      1248. 
+
    1248. 4295            expr = (isUndefined(expr) || isNull(expr) || (isArray(expr) && !expr.length)) ? null : expr;
      1249. 
+
    1249. 4295            if (expr && cb) {
      1250. 
+
    1250. 1                return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond))
      1251. 
+
    1251. 4294            } else if (cb) {
      1252. 
+
    1252. 58                expr = cb
      1253. 
+
    1253.              }
      1254. 
+
    1254. 4294            if (isInstanceOf(expr, Expression)) {
      1255. 
+
    1255. 459                if (isInstanceOf(expr, NumericExpression, StringExpression)) {
      1256. 
+
    1256. 2                    throw new QueryError("Invalid SQL Expression type : " + expr);
      1257. 
+
    1257.                  }
      1258. 
+
    1258. 457                return expr;
      1259. 
+
    1259. 3835            } else if (isArray(expr)) {
      1260. 
+
    1260. 744                if (expr.length) {
      1261. 
+
    1261. 744                    var first = expr[0];
      1262. 
+
    1262. 744                    if (isString(first)) {
      1263. 
+
    1263. 25                        return new PlaceHolderLiteralString(first, expr.slice(1), true);
      1264. 
+
    1264. 719                    } else if (Expression.isConditionSpecifier(expr)) {
      1265. 
+
    1265. 708                        return BooleanExpression.fromValuePairs(expr, joinCond)
      1266. 
+
    1266.                      } else {
      1267. 
+
    1267. 11                        return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
      1268. 
+
    1268. 23                            return this._filterExpr(e, null, joinCond);
      1269. 
+
    1269.                          }, this)));
      1270. 
+
    1270.                      }
      1271. 
+
    1271.                  }
      1272. 
+
    1272. 3091            } else if (isFunction(expr)) {
      1273. 
+
    1273. 59                return this._filterExpr(expr.call(sql, sql), null, joinCond);
      1274. 
+
    1274. 3032            } else if (isBoolean(expr)) {
      1275. 
+
    1275. 7                return new BooleanExpression("NOOP", expr);
      1276. 
+
    1276. 3025            } else if (isString(expr)) {
      1277. 
+
    1277. 1                return this.stringToIdentifier(expr);
      1278. 
+
    1278. 3024            } else if (isInstanceOf(expr, LiteralString)) {
      1279. 
+
    1279. 16                return new LiteralString("(" + expr + ")");
      1280. 
+
    1280. 3008            } else if (isHash(expr)) {
      1281. 
+
    1281. 3007                return BooleanExpression.fromValuePairs(expr, joinCond);
      1282. 
+
    1282.              } else {
      1283. 
+
    1283. 1                throw new QueryError("Invalid filter argument");
      1284. 
+
    1284.              }
      1285. 
+
    1285.          },
      1286. 
+
    1286.  
      1287. 
+
    1287.  
      1288. 
+
    1288.          /**@ignore*/
      1289. 
+
    1289.          getters: {
      1290. 
+
    1290.  
      1291. 
+
    1291.              /**
      1292. 
+
    1292.               * @ignore
      1293. 
+
    1293.               * Returns true if this dataset is a simple SELECT * FROM {table}, otherwise false.
      1294. 
+
    1294.               */
      1295. 
+
    1295.              isSimpleSelectAll: function () {
      1296. 
+
    1296. 33                var o = {}, opts = this.__opts, count = 0;
      1297. 
+
    1297. 33                for (var i in opts) {
      1298. 
+
    1298. 70                    if (opts[i] != null && this._static.NON_SQL_OPTIONS.indexOf(i) == -1) {
      1299. 
+
    1299. 37                        o[i] = opts[i];
      1300. 
+
    1300. 37                        count++;
      1301. 
+
    1301.                      }
      1302. 
+
    1302.                  }
      1303. 
+
    1303. 33                var f = o.from
      1304. 
+
    1304. 33                return count == 1 && f.length == 1 && (isString(f[0]) || isInstanceOf(f[0], AliasedExpression, Identifier));
      1305. 
+
    1305.              }
      1306. 
 
    1306.          }
      1307. 
 
    1307.      },
      1308. 
 
    1308.  
      1309. 
-
    1309.      "static":{
      1310. 
-
    1310.          /**@lends patio.plugins.ValidatorPlugin*/
      1311. 
+
    1311.      static: {
      1312. 
+
    1312.          /**@lends patio.Dataset*/
      1313. 
 
    1313.  
      1314. 
 
    1314.          /**
      1315. 
-
    1315.           * Set to false to prevent model validation when saving.
      1316. 
-
    1316.           * @default true
      1317. 
-
    1317.           */
      1318. 
-
    1318.          validateOnSave:true,
      1319. 
+
    1319.           * These strings have {name}Join methods created (e.g. {@link patio.Dataset#innerJoin}) that
      1320. 
+
    1320.           * call {@link patio.Dataset#joinTable} with the string, passing along the arguments and
      1321. 
+
    1321.           * block from the method call.
      1322. 
+
    1322.           **/
      1323. 
+
    1323.          CONDITIONED_JOIN_TYPES: ["inner", "fullOuter", "rightOuter", "leftOuter", "full", "right", "left"],
      1324. 
 
    1324.  
      1325. 
 
    1325.          /**
      1326. 
-
    1326.           * Set to false to prevent model validation when updating.
      1327. 
-
    1327.           * @default true
      1328. 
+
    1328.           *
      1329. 
+
    1329.           * These strings have {name}Join methods created (e.g. naturalJoin) that
      1330. 
+
    1330.           * call {@link patio.Dataset#joinTable}.  They only accept a single table
      1331. 
+
    1331.           * argument which is passed to {@link patio.Dataset#joinTable}, and they throw an error
      1332. 
+
    1332.           * if called with a block.
      1333. 
+
    1333.           **/
      1334. 
+
    1334.          UNCONDITIONED_JOIN_TYPES: ["natural", "naturalLeft", "naturalRight", "naturalFull", "cross"],
      1335. 
+
    1335.  
      1336. 
+
    1336.          /**
      1337. 
+
    1337.           *  The dataset options that require the removal of cached columns
      1338. 
+
    1338.           *  if changed.
      1339. 
 
    1339.           */
      1340. 
-
    1340.          validateOnUpdate:true,
      1341. 
+
    1341.          COLUMN_CHANGE_OPTS: ["select", "sql", "from", "join"],
      1342. 
 
    1342.  
      1343. 
-
    1343.          init:function () {
      1344. 
-
    1344. 35            this._super(arguments);
      1345. 
-
    1345.          },
      1346. 
+
    1346.          /**
      1347. 
+
    1347.           * Which options don't affect the SQL generation.  Used by {@link patio.Dataset#simpleSelectAll}
      1348. 
+
    1348.           * to determine if this is a simple SELECT * FROM table.
      1349. 
+
    1349.           */
      1350. 
+
    1350.          NON_SQL_OPTIONS: ["server", "defaults", "overrides", "graph", "eagerGraph", "graphAliases"],
      1351. 
 
    1351.  
      1352. 
-
    1352.          __initValidation:function () {
      1353. 
-
    1353. 43            if (!this.__isValidationInited) {
      1354. 
-
    1354. 34                this.validators = [];
      1355. 
-
    1355. 34                this.pre("save", function preSaveValidate(next, opts) {
      1356. 
-
    1356. 114                    validateHook.call(this, this._static.validateOnSave, next, opts);
      1357. 
-
    1357.                  });
      1358. 
-
    1358. 34                this.pre("update", function preUpdateValidate(next, opts) {
      1359. 
-
    1359. 1                    validateHook.call(this, this._static.validateOnSave, next, opts);
      1360. 
-
    1360.                  });
      1361. 
-
    1361. 34                this.__isValidationInited = true;
      1362. 
-
    1362.              }
      1363. 
-
    1363.          },
      1364. 
 
    1364.  
      1365. 
-
    1365.          __getValidator:function validator(name) {
      1366. 
-
    1366. 44            var ret = new Validator(name);
      1367. 
-
    1367. 44            this.validators.push(ret);
      1368. 
-
    1368. 44            return ret;
      1369. 
-
    1369.          },
      1370. 
+
    1370.          /**
      1371. 
+
    1371.           *  All methods that return modified datasets with a joined table added.
      1372. 
+
    1372.           */
      1373. 
+
    1373.          JOIN_METHODS: ["join", "joinTable"],
      1374. 
 
    1374.  
      1375. 
 
    1375.          /**
      1376. 
-
    1376.           * Sets up validation for a model.
      1377. 
-
    1377.           *
      1378. 
-
    1378.           * To do single col validation
      1379. 
-
    1379.           * {@code
      1380. 
-
    1380.           *
      1381. 
-
    1381.           * var Model = patio.addModel("validator", {
      1382. 
-
    1382.           *      plugins:[ValidatorPlugin]
      1383. 
-
    1383.           * });
      1384. 
-
    1384.           * //this ensures column assignment
      1385. 
-
    1385.           * Model.validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
      1386. 
-
    1386.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
      1387. 
-
    1387.           * Model.validate("col2").like(/hello/ig);
      1388. 
-
    1388.           * //Ensures that the emailAddress column is a valid email address.
      1389. 
-
    1389.           * Model.validate("emailAddress").isEmailAddress();
      1390. 
-
    1390.           * }
      1391. 
-
    1391.           *
      1392. 
-
    1392.           * Or you can do a mass validation through a callback.
      1393. 
-
    1393.           * {@code
      1394. 
-
    1394.           *
      1395. 
-
    1395.           * var Model = patio.addModel("validator", {
      1396. 
-
    1396.           *      plugins:[ValidatorPlugin]
      1397. 
-
    1397.           * });
      1398. 
-
    1398.           * Model.validate(function(validate){
      1399. 
-
    1399.           *      //this ensures column assignment
      1400. 
-
    1400.           *      validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
      1401. 
-
    1401.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
      1402. 
-
    1402.           *      validate("col2").isLike(/hello/ig);
      1403. 
-
    1403.           *      //Ensures that the emailAddress column is a valid email address.
      1404. 
-
    1404.           *      validate("emailAddress").isEmail();
      1405. 
-
    1405.           * });
      1406. 
-
    1406.           * }
      1407. 
-
    1407.           *
      1408. 
-
    1408.           *
      1409. 
-
    1409.           * @param {String|Function} name the name of the column, or a callback that accepts a function to create validators.
      1410. 
-
    1410.           *
      1411. 
-
    1411.           * @throws {patio.ModelError} if name is not a function or string.
      1412. 
-
    1412.           * @return {patio.Model|Validator} returns a validator if name is a string, other wise returns this for chaining.
      1413. 
+
    1413.           * Methods that return modified datasets
      1414. 
 
    1414.           */
      1415. 
-
    1415.          validate:function (name) {
      1416. 
-
    1416. 43            this.__initValidation();
      1417. 
-
    1417. 43            var ret;
      1418. 
-
    1418. 43            if (isFunction(name)) {
      1419. 
-
    1419. 1                name.apply(this, [this.__getValidator.bind(this)]);
      1420. 
-
    1420. 1                ret = this;
      1421. 
-
    1421. 42            } else if (isString(name)) {
      1422. 
-
    1422. 42                ret = this.__getValidator(name);
      1423. 
-
    1423.              } else {
      1424. 
-
    1424. 0                throw new ModelError("name is must be a string or function when validating");
      1425. 
-
    1425.              }
      1426. 
-
    1426. 43            return ret;
      1427. 
+
    1427.          QUERY_METHODS: ['addGraphAliases', "and", "distinct", "except", "exclude", "filter", "find", "is", "isNot",
      1428. 
+
    1428.              "eq", "neq", "lt", "lte", "gt", "gte", "forUpdate", "from", "fromSelf", "graph", "grep", "group",
      1429. 
+
    1429.              "groupAndCount", "groupBy", "having", "intersect", "invert", "limit", "lockStyle", "naked", "or", "order",
      1430. 
+
    1430.              "orderAppend", "orderBy", "orderMore", "orderPrepend", "qualify", "reverse",
      1431. 
+
    1431.              "reverseOrder", "select", "selectAll", "selectAppend", "selectMore", "setDefaults",
      1432. 
+
    1432.              "setGraphAliases", "setOverrides", "unfiltered", "ungraphed", "ungrouped", "union", "unlimited",
      1433. 
+
    1433.              "unordered", "where", "with", "withRecursive", "withSql"],
      1434. 
+
    1434.  
      1435. 
+
    1435.          init: function () {
      1436. 
+
    1436. 35            this._super(arguments);
      1437. 
+
    1437.              //initialize our join methods array
      1438. 
+
    1438. 35            var joinMethods = this.JOIN_METHODS;
      1439. 
+
    1439. 35            var queryMethods = this.QUERY_METHODS;
      1440. 
+
    1440. 35            this.UNCONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      1441. 
+
    1441. 175                var m = joinType + "Join";
      1442. 
+
    1442. 175                joinMethods.push(m);
      1443. 
+
    1443. 175                queryMethods.push(m);
      1444. 
+
    1444.              });
      1445. 
+
    1445. 35            this.CONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      1446. 
+
    1446. 245                var m = joinType + "Join";
      1447. 
+
    1447. 245                joinMethods.push(m);
      1448. 
+
    1448. 245                queryMethods.push(m);
      1449. 
+
    1449.              });
      1450. 
+
    1450. 35            this.QUERY_METHODS = queryMethods.concat(joinMethods);
      1451. 
 
    1451.          }
      1452. 
 
    1452.      }
      1453. 
-
    1453.  
      1454. 
-
    1454.  }).as(module);
      1455. 
-
    1455.
    +
  • }).
    • +
  • as(module);
    • @@ -21056,8 +21113,8 @@
  • * @ignore
  • */
  • constructor:function () {
    • -
  • 25725 !Dataset && (Dataset = require("../index").Dataset);
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 !Dataset && (Dataset = require("../index").Dataset);
    • +
  • 25745 this._super(arguments);
  • },
  • /**
    • @@ -21736,7 +21793,7 @@
  • // Whether this dataset quotes identifiers.
  • /**@ignore*/
  • quoteIdentifiers:function(){
    • -
  • 42250 return this.__quoteIdentifiers;
    • +
  • 42266 return this.__quoteIdentifiers;
  • },
  • // Whether this dataset will provide accurate number of rows matched for
    • @@ -21744,80 +21801,80 @@
  • // rows matched by the dataset's filter.
  • /**@ignore*/
  • providesAccurateRowsMatched:function(){
    • -
  • 13414 return this.__providesAccurateRowsMatched;
    • +
  • 13418 return this.__providesAccurateRowsMatched;
  • },
  • //Whether the dataset requires SQL standard datetimes (false by default,
  • // as most allow strings with ISO 8601 format).
  • /**@ignore*/
  • requiresSqlStandardDateTimes:function(){
    • -
  • 13421 return this.__requiresSqlStandardDateTimes;
    • +
  • 13425 return this.__requiresSqlStandardDateTimes;
  • },
  • // Whether the dataset supports common table expressions (the WITH clause).
  • /**@ignore*/
  • supportsCte:function(){
    • -
  • 13427 return this.__supportsCte;
    • +
  • 13431 return this.__supportsCte;
  • },
  • // Whether the dataset supports the DISTINCT ON clause, false by default.
  • /**@ignore*/
  • supportsDistinctOn:function(){
    • -
  • 2291 return this.__supportsDistinctOn;
    • +
  • 2295 return this.__supportsDistinctOn;
  • },
  • //Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExcept:function(){
    • -
  • 13450 return this.__supportsIntersectExcept;
    • +
  • 13454 return this.__supportsIntersectExcept;
  • },
  • //Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExceptAll:function(){
    • -
  • 13426 return this.__supportsIntersectExceptAll;
    • +
  • 13430 return this.__supportsIntersectExceptAll;
  • },
  • //Whether the dataset supports the IS TRUE syntax.
  • /**@ignore*/
  • supportsIsTrue:function(){
    • -
  • 13623 return this.__supportsIsTrue;
    • +
  • 13627 return this.__supportsIsTrue;
  • },
  • //Whether the dataset supports the JOIN table USING (column1, ...) syntax.
  • /**@ignore*/
  • supportsJoinUsing:function(){
    • -
  • 13425 return this.__supportsJoinUsing;
    • +
  • 13429 return this.__supportsJoinUsing;
  • },
  • //Whether modifying joined datasets is supported.
  • /**@ignore*/
  • supportsModifyingJoins:function(){
    • -
  • 2531 return this.__supportsModifyingJoins;
    • +
  • 2535 return this.__supportsModifyingJoins;
  • },
  • //Whether the IN/NOT IN operators support multiple columns when an
  • /**@ignore*/
  • supportsMultipleColumnIn:function(){
    • -
  • 13418 return this.__supportsMultipleColumnIn;
    • +
  • 13422 return this.__supportsMultipleColumnIn;
  • },
  • //Whether the dataset supports timezones in literal timestamps
  • /**@ignore*/
  • supportsTimestampTimezones:function(){
    • -
  • 2288 return this.__supportsTimestampTimezones;
    • +
  • 2292 return this.__supportsTimestampTimezones;
  • },
  • //Whether the dataset supports fractional seconds in literal timestamps
  • /**@ignore*/
  • supportsTimestampUsecs:function(){
    • -
  • 13414 return this.__supportsTimestampUsecs;
    • +
  • 13418 return this.__supportsTimestampUsecs;
  • },
  • //Whether the dataset supports window functions.
  • /**@ignore*/
  • supportsWindowFunctions:function(){
    • -
  • 13414 return this.__supportsWindowFunctions;
    • +
  • 13418 return this.__supportsWindowFunctions;
  • }
  • },
    • @@ -21828,7 +21885,7 @@
  • // Whether this dataset quotes identifiers.
  • /**@ignore*/
  • quoteIdentifiers:function(val){
    • -
  • 13426 this.__quoteIdentifiers = val;
    • +
  • 13430 this.__quoteIdentifiers = val;
  • },
  • // Whether this dataset will provide accurate number of rows matched for
    • @@ -21836,80 +21893,80 @@
  • // rows matched by the dataset's filter.
  • /**@ignore*/
  • providesAccurateRowsMatched:function(val){
    • -
  • 13414 this.__providesAccurateRowsMatched = val;
    • +
  • 13418 this.__providesAccurateRowsMatched = val;
  • },
  • //Whether the dataset requires SQL standard datetimes (false by default,
  • // as most allow strings with ISO 8601 format).
  • /**@ignore*/
  • requiresSqlStandardDateTimes:function(val){
    • -
  • 13414 this.__requiresSqlStandardDateTimes = val;
    • +
  • 13418 this.__requiresSqlStandardDateTimes = val;
  • },
  • // Whether the dataset supports common table expressions (the WITH clause).
  • /**@ignore*/
  • supportsCte:function(val){
    • -
  • 13415 this.__supportsCte = val;
    • +
  • 13419 this.__supportsCte = val;
  • },
  • // Whether the dataset supports the DISTINCT ON clause, false by default.
  • /**@ignore*/
  • supportsDistinctOn:function(val){
    • -
  • 2289 this.__supportsDistinctOn = val;
    • +
  • 2293 this.__supportsDistinctOn = val;
  • },
  • //Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExcept:function(val){
    • -
  • 13416 this.__supportsIntersectExcept = val;
    • +
  • 13420 this.__supportsIntersectExcept = val;
  • },
  • //Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExceptAll:function(val){
    • -
  • 13416 this.__supportsIntersectExceptAll = val;
    • +
  • 13420 this.__supportsIntersectExceptAll = val;
  • },
  • //Whether the dataset supports the IS TRUE syntax.
  • /**@ignore*/
  • supportsIsTrue:function(val){
    • -
  • 13414 this.__supportsIsTrue = val;
    • +
  • 13418 this.__supportsIsTrue = val;
  • },
  • //Whether the dataset supports the JOIN table USING (column1, ...) syntax.
  • /**@ignore*/
  • supportsJoinUsing:function(val){
    • -
  • 13416 this.__supportsJoinUsing = val;
    • +
  • 13420 this.__supportsJoinUsing = val;
  • },
  • //Whether modifying joined datasets is supported.
  • /**@ignore*/
  • supportsModifyingJoins:function(val){
    • -
  • 2289 this.__supportsModifyingJoins = val;
    • +
  • 2293 this.__supportsModifyingJoins = val;
  • },
  • //Whether the IN/NOT IN operators support multiple columns when an
  • /**@ignore*/
  • supportsMultipleColumnIn:function(val){
    • -
  • 13414 this.__supportsMultipleColumnIn = val;
    • +
  • 13418 this.__supportsMultipleColumnIn = val;
  • },
  • //Whether the dataset supports timezones in literal timestamps
  • /**@ignore*/
  • supportsTimestampTimezones:function(val){
    • -
  • 2288 this.__supportsTimestampTimezones = val;
    • +
  • 2292 this.__supportsTimestampTimezones = val;
  • },
  • //Whether the dataset supports fractional seconds in literal timestamps
  • /**@ignore*/
  • supportsTimestampUsecs:function(val){
    • -
  • 13414 this.__supportsTimestampUsecs = val;
    • +
  • 13418 this.__supportsTimestampUsecs = val;
  • },
  • //Whether the dataset supports window functions.
  • /**@ignore*/
  • supportsWindowFunctions:function(val){
    • -
  • 13414 this.__supportsWindowFunctions = val;
    • +
  • 13418 this.__supportsWindowFunctions = val;
  • }
  • }
    • diff --git a/docs/coverage.html b/docs/coverage.html index f4295537..fd8d971d 100644 --- a/docs/coverage.html +++ b/docs/coverage.html @@ -256,10 +256,10 @@
    - Coverage88.47 - SLOC22140 - LOC5315 - Missed613 + Coverage88.48 + SLOC22197 + LOC5311 + Missed612
    @@ -6921,11 +6921,11 @@
  • * @property {Boolean} hasSelectSource true if this dataset already has a select sources.
  • */
  • constructor:function (db, opts) {
    • -
  • 25725 this._super(arguments);
    • -
  • 25725 this.db = db;
    • -
  • 25725 this.__opts = {};
    • -
  • 25725 this.__rowCb = null;
    • -
  • 25725 if (db) {
    • +
  • 25745 this._super(arguments);
    • +
  • 25745 this.db = db;
    • +
  • 25745 this.__opts = {};
    • +
  • 25745 this.__rowCb = null;
    • +
  • 25745 if (db) {
  • 13274 this.__quoteIdentifiers = db.quoteIdentifiers;
  • 13274 this.__identifierInputMethod = db.identifierInputMethod;
  • 13274 this.__identifierOutputMethod = db.identifierOutputMethod;
    • @@ -6943,22 +6943,22 @@
  • * @return [patio.Dataset] a cloned dataset with the merged options
  • **/
  • mergeOptions:function (opts) {
    • -
  • 13414 opts = isUndefined(opts) ? {} : opts;
    • -
  • 13414 var ds = new this._static(this.db, {});
    • -
  • 13414 ds.rowCb = this.rowCb;
    • -
  • 13414 this._static.FEATURES.forEach(function (f) {
    • -
  • 187796 ds[f] = this[f];
    • +
  • 13418 opts = isUndefined(opts) ? {} : opts;
    • +
  • 13418 var ds = new this._static(this.db, {});
    • +
  • 13418 ds.rowCb = this.rowCb;
    • +
  • 13418 this._static.FEATURES.forEach(function (f) {
    • +
  • 187852 ds[f] = this[f];
  • }, this);
    • -
  • 13414 var dsOpts = ds.__opts = merge({}, this.__opts, opts);
    • -
  • 13414 ds.identifierInputMethod = this.identifierInputMethod;
    • -
  • 13414 ds.identifierOutputMethod = this.identifierOutputMethod;
    • -
  • 13414 var columnChangeOpts = this._static.COLUMN_CHANGE_OPTS;
    • -
  • 13414 if (Object.keys(opts).some(function (o) {
    • -
  • 12145 return columnChangeOpts.indexOf(o) !== -1;
    • +
  • 13418 var dsOpts = ds.__opts = merge({}, this.__opts, opts);
    • +
  • 13418 ds.identifierInputMethod = this.identifierInputMethod;
    • +
  • 13418 ds.identifierOutputMethod = this.identifierOutputMethod;
    • +
  • 13418 var columnChangeOpts = this._static.COLUMN_CHANGE_OPTS;
    • +
  • 13418 if (Object.keys(opts).some(function (o) {
    • +
  • 12149 return columnChangeOpts.indexOf(o) !== -1;
  • })) {
  • 2289 dsOpts.columns = null;
  • }
    • -
  • 13414 return ds;
    • +
  • 13418 return ds;
  • },
    • @@ -6985,17 +6985,17 @@
  • * @return {patio.sql.Identifier|patio.sql.QualifiedIdentifier|patio.sql.AliasedExpression} an identifier generated based on the name string.
  • */
  • stringToIdentifier:function (name) {
    • -
  • 12879 if (isString(name)) {
    • -
  • 8755 var parts = this._splitString(name);
    • -
  • 8755 var schema = parts[0], table = parts[1], alias = parts[2];
    • -
  • 8755 return (schema && table && alias
    • +
  • 12895 if (isString(name)) {
    • +
  • 8763 var parts = this._splitString(name);
    • +
  • 8763 var schema = parts[0], table = parts[1], alias = parts[2];
    • +
  • 8763 return (schema && table && alias
  • ? new AliasedExpression(new QualifiedIdentifier(schema, table), alias)
  • : (schema && table
  • ? new QualifiedIdentifier(schema, table)
  • : (table && alias
  • ? new AliasedExpression(new Identifier(table), alias) : new Identifier(table))));
  • } else {
    • -
  • 4124 return name;
    • +
  • 4132 return name;
  • }
  • },
    • @@ -7023,20 +7023,20 @@
  • * </ul>
  • */
  • _splitString:function (s) {
    • -
  • 16920 var ret, m;
    • -
  • 16920 if ((m = s.match(this._static.COLUMN_REF_RE1)) !== null) {
    • +
  • 16928 var ret, m;
    • +
  • 16928 if ((m = s.match(this._static.COLUMN_REF_RE1)) !== null) {
  • 137 ret = m.slice(1);
  • }
    • -
  • 16783 else if ((m = s.match(this._static.COLUMN_REF_RE2)) !== null) {
    • +
  • 16791 else if ((m = s.match(this._static.COLUMN_REF_RE2)) !== null) {
  • 24 ret = [null, m[1], m[2]];
  • }
    • -
  • 16759 else if ((m = s.match(this._static.COLUMN_REF_RE3)) !== null) {
    • +
  • 16767 else if ((m = s.match(this._static.COLUMN_REF_RE3)) !== null) {
  • 1547 ret = [m[1], m[2], null];
  • }
  • else {
    • -
  • 15212 ret = [null, s, null];
    • +
  • 15220 ret = [null, s, null];
  • }
    • -
  • 16920 return ret;
    • +
  • 16928 return ret;
  • },
  • /**
    • @@ -7045,15 +7045,15 @@
  • getters:{
  • rowCb:function () {
    • -
  • 19292 return this.__rowCb;
    • +
  • 19296 return this.__rowCb;
  • },
  • identifierInputMethod:function () {
    • -
  • 13414 return this.__identifierInputMethod;
    • +
  • 13418 return this.__identifierInputMethod;
  • },
  • identifierOutputMethod:function () {
    • -
  • 13414 return this.__identifierOutputMethod;
    • +
  • 13418 return this.__identifierOutputMethod;
  • },
  • firstSourceAlias:function () {
    • @@ -7112,16 +7112,16 @@
  • /**@lends patio.Dataset.prototype*/
  • identifierInputMethod:function (meth) {
    • -
  • 13484 this.__identifierInputMethod = meth;
    • +
  • 13488 this.__identifierInputMethod = meth;
  • },
  • identifierOutputMethod:function (meth) {
    • -
  • 13484 this.__identifierOutputMethod = meth;
    • +
  • 13488 this.__identifierOutputMethod = meth;
  • },
  • rowCb:function (cb) {
    • -
  • 16639 if (isFunction(cb) || isNull(cb)) {
    • -
  • 16634 this.__rowCb = cb;
    • +
  • 16643 if (isFunction(cb) || isNull(cb)) {
    • +
  • 16638 this.__rowCb = cb;
  • } else {
  • 5 throw new DatasetError("rowCb mus be a function");
  • }
    • @@ -7347,14 +7347,14 @@
  • * @borrows patio.Dataset#leftJoin as leftJoin
  • * */
  • constructor:function (options, fromDb) {
    • -
  • 2717 if (this.synced) {
    • -
  • 2717 this.__emitter = new EventEmitter();
    • -
  • 2717 this._super(arguments);
    • -
  • 2717 this.patio = patio || require("./index");
    • -
  • 2717 fromDb = isBoolean(fromDb) ? fromDb : false;
    • -
  • 2717 this.__changed = {};
    • -
  • 2717 this.__values = {};
    • -
  • 2717 if (fromDb) {
    • +
  • 2715 if (this.synced) {
    • +
  • 2715 this.__emitter = new EventEmitter();
    • +
  • 2715 this._super(arguments);
    • +
  • 2715 this.patio = patio || require("./index");
    • +
  • 2715 fromDb = isBoolean(fromDb) ? fromDb : false;
    • +
  • 2715 this.__changed = {};
    • +
  • 2715 this.__values = {};
    • +
  • 2715 if (fromDb) {
  • 1519 this._hook("pre", "load");
  • 1519 this.__isNew = false;
  • 1519 this.__setFromDb(options, true);
    • @@ -7363,8 +7363,8 @@
  • 1519 this._static.emit("load", this);
  • }
  • } else {
    • -
  • 1198 this.__isNew = true;
    • -
  • 1198 this.__set(options);
    • +
  • 1196 this.__isNew = true;
    • +
  • 1196 this.__set(options);
  • }
  • } else {
  • 0 throw new ModelError("Model " + this.tableName + " has not been synced");
    • @@ -7372,15 +7372,15 @@
  • },
  • __set:function (values, ignore) {
    • -
  • 1322 values = values || {};
    • -
  • 1322 this.__ignore = ignore === true;
    • -
  • 1322 Object.keys(values).forEach(function (attribute) {
    • +
  • 1320 values = values || {};
    • +
  • 1320 this.__ignore = ignore === true;
    • +
  • 1320 Object.keys(values).forEach(function (attribute) {
  • 5863 var value = values[attribute];
  • //check if the column is a constrained value and is allowed to be set
  • 5863 !ignore && this._checkIfColumnIsConstrained(attribute);
  • 5863 this[attribute] = value;
  • }, this);
    • -
  • 1322 this.__ignore = false;
    • +
  • 1320 this.__ignore = false;
  • },
  • __setFromDb:function (values, ignore) {
    • @@ -7635,7 +7635,7 @@
  • },
  • synced:function () {
    • -
  • 11255 return this._static.synced;
    • +
  • 11253 return this._static.synced;
  • }
  • }
    • @@ -9564,7 +9564,7 @@
  • * @param {String} message the message to show.
  • */
  • 1patio.QueryError = function(message) {
    • -
  • 122 return new Error("QueryError : " + message);
    • +
  • 118 return new Error("QueryError : " + message);
  • };
  • /**
    • @@ -9662,21 +9662,21 @@
  • 1var virtualRow = function (name) {
    • -
  • 882 var WILDCARD = new LiteralString('*');
    • -
  • 882 var QUESTION_MARK = new LiteralString('?');
    • -
  • 882 var COMMA_SEPARATOR = new LiteralString(', ');
    • -
  • 882 var DOUBLE_UNDERSCORE = '__';
    • -
    • -
  • 882 var parts = name.split(DOUBLE_UNDERSCORE);
    • -
  • 882 var table = parts[0], column = parts[1];
    • -
  • 882 var ident = column ? QualifiedIdentifier.fromArgs([table, column]) : Identifier.fromArgs([name]);
    • -
  • 882 var prox = methodMissing(ident, function (m) {
    • +
  • 876 var WILDCARD = new LiteralString('*');
    • +
  • 876 var QUESTION_MARK = new LiteralString('?');
    • +
  • 876 var COMMA_SEPARATOR = new LiteralString(', ');
    • +
  • 876 var DOUBLE_UNDERSCORE = '__';
    • +
    • +
  • 876 var parts = name.split(DOUBLE_UNDERSCORE);
    • +
  • 876 var table = parts[0], column = parts[1];
    • +
  • 876 var ident = column ? QualifiedIdentifier.fromArgs([table, column]) : Identifier.fromArgs([name]);
    • +
  • 876 var prox = methodMissing(ident, function (m) {
  • 3 return function () {
  • 3 var args = argsToArray(arguments);
  • 3 return SQLFunction.fromArgs([m, name].concat(args));
  • }
  • }, column ? QualifiedIdentifier : Identifier);
    • -
  • 882 var ret = createFunctionWrapper(prox, function (m) {
    • +
  • 876 var ret = createFunctionWrapper(prox, function (m) {
  • 484 var args = argsToArray(arguments);
  • 484 if (args.length) {
  • 478 return SQLFunction.fromArgs([name].concat(args));
    • @@ -9686,8 +9686,8 @@
  • }, function () {
  • 0 return SQLFunction.fromArgs(arguments);
  • });
    • -
  • 882 ret.__proto__ = ident;
    • -
  • 882 return ret;
    • +
  • 876 ret.__proto__ = ident;
    • +
  • 876 return ret;
  • };
  • 1var DATE_METHODS = ["getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds",
    • @@ -10042,8 +10042,8 @@
  • * @see patio.sql.identifier
  • */
  • stringToIdentifier:function (name) {
    • -
  • 10491 !Dataset && (Dataset = require("./dataset"));
    • -
  • 10491 return new Dataset().stringToIdentifier(name);
    • +
  • 10507 !Dataset && (Dataset = require("./dataset"));
    • +
  • 10507 return new Dataset().stringToIdentifier(name);
  • },
  • /**
    • @@ -10139,7 +10139,7 @@
  • });
  • 1exports.sql = methodMissing(sql, function (name) {
    • -
  • 882 return virtualRow(name);
    • +
  • 876 return virtualRow(name);
  • });
  • 1var OPERTATOR_INVERSIONS = {
    • @@ -10949,13 +10949,13 @@
  • * @return {patio.sql.Expression} an expression.
  • */
  • fromArgs:function (args) {
    • -
  • 1960 var ret;
    • -
  • 1960 try {
    • -
  • 1960 ret = new this();
    • +
  • 1958 var ret;
    • +
  • 1958 try {
    • +
  • 1958 ret = new this();
  • } catch (ignore) {
  • }
    • -
  • 1960 this.apply(ret, args);
    • -
  • 1960 return ret;
    • +
  • 1958 this.apply(ret, args);
    • +
  • 1958 return ret;
  • },
  • /**
    • @@ -10972,8 +10972,8 @@
  • * @return {Boolean} true if the object is a Hash or is an array of two element arrays.
  • */
  • isConditionSpecifier:function (obj) {
    • -
  • 19142 return isHash(obj) || (isArray(obj) && obj.length && obj.every(function (i) {
    • -
  • 7932 return isArray(i) && i.length === 2;
    • +
  • 19178 return isHash(obj) || (isArray(obj) && obj.length && obj.every(function (i) {
    • +
  • 7944 return isArray(i) && i.length === 2;
  • }));
  • }
  • }
    • @@ -11197,35 +11197,35 @@
  • * </p>
  • */
  • constructor:function (op) {
    • -
  • 6642 if (op) {
    • -
  • 6054 var args = argsToArray(arguments,1 );
    • +
  • 6658 if (op) {
    • +
  • 6066 var args = argsToArray(arguments,1 );
  • //make a copy of the args
    • -
  • 6054 var origArgs = args.slice(0);
    • -
  • 6054 args.forEach(function (a, i) {
    • -
  • 12280 if (Expression.isConditionSpecifier(a)) {
    • +
  • 6066 var origArgs = args.slice(0);
    • +
  • 6066 args.forEach(function (a, i) {
    • +
  • 12304 if (Expression.isConditionSpecifier(a)) {
  • 6 args[i] = BooleanExpression.fromValuePairs(a);
  • }
  • });
    • -
  • 6054 op = op.toUpperCase();
    • +
  • 6066 op = op.toUpperCase();
    • -
  • 6054 if (N_ARITY_OPERATORS.hasOwnProperty(op)) {
    • -
  • 953 if (args.length < 1) {
    • +
  • 6066 if (N_ARITY_OPERATORS.hasOwnProperty(op)) {
    • +
  • 957 if (args.length < 1) {
  • 0 throw new ExpressionError("The " + op + " operator requires at least 1 argument")
  • }
    • -
  • 953 var oldArgs = args.slice(0);
    • -
  • 953 args = [];
    • -
  • 953 oldArgs.forEach(function (a) {
    • -
  • 2141 a instanceof ComplexExpression && a.op == op ? args = args.concat(a.args) : args.push(a);
    • +
  • 957 var oldArgs = args.slice(0);
    • +
  • 957 args = [];
    • +
  • 957 oldArgs.forEach(function (a) {
    • +
  • 2149 a instanceof ComplexExpression && a.op == op ? args = args.concat(a.args) : args.push(a);
  • });
    • -
  • 5101 } else if (TWO_ARITY_OPERATORS.hasOwnProperty(op)) {
    • -
  • 5038 if (args.length != 2) {
    • +
  • 5109 } else if (TWO_ARITY_OPERATORS.hasOwnProperty(op)) {
    • +
  • 5046 if (args.length != 2) {
  • 0 throw new ExpressionError("The " + op + " operator requires precisely 2 arguments");
  • }
  • //With IN/NOT IN, even if the second argument is an array of two element arrays,
  • //don't convert it into a boolean expression, since it's definitely being used
  • //as a value list.
    • -
  • 5038 if (IN_OPERATORS[op]) {
    • +
  • 5046 if (IN_OPERATORS[op]) {
  • 23 args[1] = origArgs[1]
  • }
  • 63 } else if (ONE_ARITY_OPERATORS.hasOwnProperty(op)) {
    • @@ -11235,8 +11235,8 @@
  • } else {
  • 0 throw new ExpressionError("Invalid operator " + op);
  • }
    • -
  • 6054 this.op = op;
    • -
  • 6054 this.args = args;
    • +
  • 6066 this.op = op;
    • +
  • 6066 this.args = args;
  • }
  • },
    • @@ -11249,9 +11249,9 @@
  • * @return String the SQL version of the {@link patio.sql.ComplexExpression}.
  • */
  • toString:function (ds) {
    • -
  • 5673 !Dataset && (Dataset = require("./dataset"));
    • -
  • 5673 ds = ds || new Dataset();
    • -
  • 5673 return ds.complexExpressionSql(this.op, this.args);
    • +
  • 5685 !Dataset && (Dataset = require("./dataset"));
    • +
  • 5685 ds = ds || new Dataset();
    • +
  • 5685 return ds.complexExpressionSql(this.op, this.args);
  • }
  • },
    • @@ -11468,40 +11468,40 @@
  • * @return {patio.sql.BooleanExpression} expression composed of sub expressions built from the hash.
  • */
  • fromValuePairs:function (a, op, negate) {
    • -
  • 6758 !Dataset && (Dataset = require("./dataset"));
    • -
  • 6758 op = op || "AND", negate = negate || false;
    • -
  • 6758 var pairArr = [];
    • -
  • 6758 var isArr = isArray(a) && Expression.isConditionSpecifier(a);
    • -
  • 6758 if (isHash(a)) {
    • -
  • 3063 pairArr.push(this.__filterObject(a));
    • +
  • 6774 !Dataset && (Dataset = require("./dataset"));
    • +
  • 6774 op = op || "AND", negate = negate || false;
    • +
  • 6774 var pairArr = [];
    • +
  • 6774 var isArr = isArray(a) && Expression.isConditionSpecifier(a);
    • +
  • 6774 if (isHash(a)) {
    • +
  • 3071 pairArr.push(this.__filterObject(a));
  • } else {
    • -
  • 3695 for (var k in a) {
    • -
  • 4320 var v = isArr ? a[k][1] : a[k], ret;
    • -
  • 4320 k = isArr ? a[k][0] : k;
    • -
  • 4320 if (isArray(v) || isInstanceOf(v, Dataset)) {
    • +
  • 3703 for (var k in a) {
    • +
  • 4328 var v = isArr ? a[k][1] : a[k], ret;
    • +
  • 4328 k = isArr ? a[k][0] : k;
    • +
  • 4328 if (isArray(v) || isInstanceOf(v, Dataset)) {
  • 17 k = isArray(k) ? k.map(function (i) {
  • 12 return isString(i) ? sql.stringToIdentifier(i) : i
  • }) : isString(k) ? sql.stringToIdentifier(k) : k;
  • 17 ret = new BooleanExpression("IN", k, v);
    • -
  • 4303 } else if (isInstanceOf(v, NegativeBooleanConstant)) {
    • +
  • 4311 } else if (isInstanceOf(v, NegativeBooleanConstant)) {
  • 0 ret = new BooleanExpression("ISNOT", k, v.constant);
    • -
  • 4303 } else if (isInstanceOf(v, BooleanConstant)) {
    • +
  • 4311 } else if (isInstanceOf(v, BooleanConstant)) {
  • 0 ret = new BooleanExpression("IS", k, v.constant);
    • -
  • 4303 } else if (isNull(v) || isBoolean(v)) {
    • +
  • 4311 } else if (isNull(v) || isBoolean(v)) {
  • 180 ret = new BooleanExpression("IS", k, v);
    • -
  • 4123 } else if (isHash(v)) {
    • +
  • 4131 } else if (isHash(v)) {
  • 0 ret = BooleanExpression.__filterObject(v, k);
    • -
  • 4123 } else if (isRegExp(v)) {
    • +
  • 4131 } else if (isRegExp(v)) {
  • 61 ret = StringExpression.like(sql.stringToIdentifier(k), v);
  • } else {
    • -
  • 4062 ret = new BooleanExpression("EQ", sql.stringToIdentifier(k), v);
    • +
  • 4070 ret = new BooleanExpression("EQ", sql.stringToIdentifier(k), v);
  • }
    • -
  • 4320 negate && (ret = BooleanExpression.invert(ret));
    • -
  • 4320 pairArr.push(ret);
    • +
  • 4328 negate && (ret = BooleanExpression.invert(ret));
    • +
  • 4328 pairArr.push(ret);
  • }
  • }
  • //if We just have one then return the first otherwise create a new Boolean expression
    • -
  • 6758 return pairArr.length == 1 ? pairArr[0] : BooleanExpression.fromArgs([op].concat(pairArr));
    • +
  • 6774 return pairArr.length == 1 ? pairArr[0] : BooleanExpression.fromArgs([op].concat(pairArr));
  • },
  • /**
    • @@ -11526,13 +11526,13 @@
  • * @return {patio.sql.Expression} an expression to use in the filter
  • */
  • __filterObject:function (expr, key) {
    • -
  • 3172 var pairs = [], opts, newKey;
    • -
  • 3172 var twoArityOperators = this.TWO_ARITY_OPERATORS;
    • -
  • 3172 for (var k in expr) {
    • -
  • 3196 var v = expr[k];
    • -
  • 3196 if (isHash(v)) { //its a hash too filter it too!
    • +
  • 3180 var pairs = [], opts, newKey;
    • +
  • 3180 var twoArityOperators = this.TWO_ARITY_OPERATORS;
    • +
  • 3180 for (var k in expr) {
    • +
  • 3204 var v = expr[k];
    • +
  • 3204 if (isHash(v)) { //its a hash too filter it too!
  • 107 pairs.push(this.__filterObject(v, k));
    • -
  • 3089 } else if (key && (twoArityOperators[k.toUpperCase()] || k.match(/between/i))) {
    • +
  • 3097 } else if (key && (twoArityOperators[k.toUpperCase()] || k.match(/between/i))) {
  • //its a two arrity operator (e.g. '=', '>')
  • 110 newKey = isString(key) ? key.split(",") : [key];
  • 110 if (newKey.length > 1) {
    • @@ -11566,19 +11566,19 @@
  • } else {
  • //we're not a twoarity operator
  • //so we create a boolean expression out of it
    • -
  • 2979 newKey = k.split(",");
    • -
  • 2979 if (newKey.length == 1) {
    • -
  • 2973 newKey = sql.stringToIdentifier(newKey[0]);
    • +
  • 2987 newKey = k.split(",");
    • +
  • 2987 if (newKey.length == 1) {
    • +
  • 2981 newKey = sql.stringToIdentifier(newKey[0]);
  • }
    • -
  • 2979 opts = [
    • +
  • 2987 opts = [
  • [newKey, v]
  • ];
    • -
  • 2979 pairs.push(BooleanExpression.fromValuePairs(opts));
    • +
  • 2987 pairs.push(BooleanExpression.fromValuePairs(opts));
  • }
  • }
  • //if the total of pairs is one then we just return the first element
  • //otherwise we join them all with an AND
    • -
  • 3172 return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
    • +
  • 3180 return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
  • }
  • }
  • }).as(sql, "BooleanExpression");
    • @@ -11758,7 +11758,7 @@
  • * @property {String} value <b>READ ONLY</b> the column or table this identifier represents.
  • */
  • constructor:function (value) {
    • -
  • 14766 this.__value = value;
    • +
  • 14762 this.__value = value;
  • },
  • /**
    • @@ -11770,15 +11770,15 @@
  • * @return String the SQL version of the {@link patio.sql.Identifier}.
  • */
  • toString:function (ds) {
    • -
  • 19196 !Dataset && (Dataset = require("./dataset"));
    • -
  • 19196 ds = ds || new Dataset();
    • -
  • 19196 return ds.quoteIdentifier(this);
    • +
  • 19208 !Dataset && (Dataset = require("./dataset"));
    • +
  • 19208 ds = ds || new Dataset();
    • +
  • 19208 return ds.quoteIdentifier(this);
  • },
  • /**@ignore*/
  • getters:{
  • value:function () {
    • -
  • 22095 return this.__value;
    • +
  • 22107 return this.__value;
  • }
  • }
  • }
    • @@ -12335,7 +12335,7 @@
  • 1var addStringMethod = function (op) {
  • 24 return function () {
    • -
  • 3622 return this.__str[op].apply(this.__str, arguments);
    • +
  • 3626 return this.__str[op].apply(this.__str, arguments);
  • }
  • };
    • @@ -12358,7 +12358,7 @@
  • * @param {String} str the literal string.
  • */
  • constructor:function (str) {
    • -
  • 3075 this.__str = str;
    • +
  • 3057 this.__str = str;
  • }
  • }
  • }).as(sql, "LiteralString");
    • @@ -14086,9 +14086,9 @@
  • constructor:function () {
  • //We initialize these here because otherwise
  • //the will be blank because of recursive dependencies.
    • -
  • 25725 !patio && (patio = require("../index"));
    • -
  • 25725 !Dataset && (Dataset = patio.Dataset);
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 !patio && (patio = require("../index"));
    • +
  • 25745 !Dataset && (Dataset = patio.Dataset);
    • +
  • 25745 this._super(arguments);
  • },
  • /**
    • @@ -14373,15 +14373,15 @@
  • * @return {String} a literal representation of the value.
  • */
  • literal:function (v) {
    • -
  • 38459 if (isInstanceOf(v, LiteralString)) {
    • +
  • 38491 if (isInstanceOf(v, LiteralString)) {
  • 194 return "" + v;
    • -
  • 38265 } else if (isString(v)) {
    • +
  • 38297 } else if (isString(v)) {
  • 5397 return this._literalString(v);
    • -
  • 32868 } else if (isNumber(v)) {
    • -
  • 6152 return this._literalNumber(v);
    • +
  • 32900 } else if (isNumber(v)) {
    • +
  • 6160 return this._literalNumber(v);
  • }
    • -
  • 26716 else if (isInstanceOf(v, Expression)) {
    • -
  • 24443 return this._literalExpression(v);
    • +
  • 26740 else if (isInstanceOf(v, Expression)) {
    • +
  • 24467 return this._literalExpression(v);
  • }
  • 2273 else if (isInstanceOf(v, Dataset)) {
  • 104 return this._literalDataset(v);
    • @@ -14572,22 +14572,22 @@
  • //Prepares an SQL statement by calling all clause methods for the given statement type.
  • _clauseSql:function (type) {
    • -
  • 5793 var sql = [("" + type).toUpperCase()];
    • -
  • 5793 try {
    • -
  • 5793 this._static[sql + "_CLAUSE_METHODS"].forEach(function (m) {
    • -
  • 58246 if (m.match("With")) {
    • -
  • 5516 this[m](sql);
    • +
  • 5797 var sql = [("" + type).toUpperCase()];
    • +
  • 5797 try {
    • +
  • 5797 this._static[sql + "_CLAUSE_METHODS"].forEach(function (m) {
    • +
  • 58298 if (m.match("With")) {
    • +
  • 5520 this[m](sql);
  • } else {
    • -
  • 52730 var sqlRet = this[m]();
    • -
  • 52728 if (sqlRet) {
    • -
  • 18662 sql.push(sqlRet);
    • +
  • 52778 var sqlRet = this[m]();
    • +
  • 52776 if (sqlRet) {
    • +
  • 18674 sql.push(sqlRet);
  • }
  • }
  • }, this);
  • } catch (e) {
  • 2 throw e;
  • }
    • -
  • 5791 return sql.join("");
    • +
  • 5795 return sql.join("");
  • },
    • @@ -14701,9 +14701,9 @@
  • * SQL fragment for complex expressions
  • **/
  • complexExpressionSql:function (op, args) {
    • -
  • 5658 var newOp;
    • -
  • 5658 var isOperators = this._static.IS_OPERATORS, isLiterals = this._static.IS_LITERALS;
    • -
  • 5658 if ((newOp = isOperators[op]) != null) {
    • +
  • 5670 var newOp;
    • +
  • 5670 var isOperators = this._static.IS_OPERATORS, isLiterals = this._static.IS_LITERALS;
    • +
  • 5670 if ((newOp = isOperators[op]) != null) {
  • 232 var r = args[1], v = isNull(r) ? isLiterals.NULL : isLiterals[r];
  • 232 if (r == null || this.supportsIsTrue) {
  • 232 if (isUndefined(v)) {
    • @@ -14719,7 +14719,7 @@
  • null)]);
  • }
    • -
  • 5426 } else if (["IN", "NOTIN"].indexOf(op) != -1) {
    • +
  • 5438 } else if (["IN", "NOTIN"].indexOf(op) != -1) {
  • 17 var cols = args[0], vals = args[1], colArray = isArray(cols), valArray = false, emptyValArray = false;
  • 17 if (isArray(vals)) {
    • @@ -14765,12 +14765,12 @@
  • ComplexExpression.IN_OPERATORS[op], this.literal(vals));
  • }
  • }
    • -
  • 5409 } else if ((newOp = this._static.TWO_ARITY_OPERATORS[op]) != null) {
    • -
  • 4596 var l = args[0];
    • -
  • 4596 return format("(%s %s %s)", isString(l) ? l : this.literal(l), newOp,
    • +
  • 5421 } else if ((newOp = this._static.TWO_ARITY_OPERATORS[op]) != null) {
    • +
  • 4604 var l = args[0];
    • +
  • 4604 return format("(%s %s %s)", isString(l) ? l : this.literal(l), newOp,
  • this.literal(args[1]));
    • -
  • 813 } else if ((newOp = this._static.N_ARITY_OPERATORS[op]) != null) {
    • -
  • 779 return string.format("(%s)", args.map(this.literal, this).join(" " + newOp + " "));
    • +
  • 817 } else if ((newOp = this._static.N_ARITY_OPERATORS[op]) != null) {
    • +
  • 783 return string.format("(%s)", args.map(this.literal, this).join(" " + newOp + " "));
  • 34 } else if (op == "NOT") {
  • 5 return string.format("NOT %s", this.literal(args[0]));
  • 29 } else if (op == "NOOP") {
    • @@ -14899,18 +14899,18 @@
  • * quote the name with {@link patio.dataset._Sql#_quotedIdentifier}.
  • */
  • quoteIdentifier:function (name) {
    • -
  • 29064 if (isInstanceOf(name, LiteralString)) {
    • +
  • 29076 if (isInstanceOf(name, LiteralString)) {
  • 228 return name;
  • } else {
    • -
  • 28836 if (isInstanceOf(name, Identifier)) {
    • -
  • 19530 name = name.value;
    • +
  • 28848 if (isInstanceOf(name, Identifier)) {
    • +
  • 19542 name = name.value;
  • }
    • -
  • 28836 name = this.inputIdentifier(name);
    • -
  • 28836 if (this.quoteIdentifiers) {
    • +
  • 28848 name = this.inputIdentifier(name);
    • +
  • 28848 if (this.quoteIdentifiers) {
  • 21729 name = this._quotedIdentifier(name)
  • }
  • }
    • -
  • 28836 return name;
    • +
  • 28848 return name;
  • },
  • /**
    • @@ -14920,9 +14920,9 @@
  • * identifierOutputMethod.
  • */
  • inputIdentifier:function (v) {
    • -
  • 28970 var i = this.__identifierInputMethod;
    • -
  • 28970 v = v.toString(this);
    • -
  • 28970 return !isUndefinedOrNull(i) ?
    • +
  • 28982 var i = this.__identifierInputMethod;
    • +
  • 28982 v = v.toString(this);
    • +
  • 28982 return !isUndefinedOrNull(i) ?
  • isFunction(v[i]) ?
  • v[i]() :
  • isFunction(comb[i]) ?
    • @@ -15010,7 +15010,7 @@
  • * column names. If the array is empty, a wildcard (*) is returned.
  • */
  • __columnList:function (columns) {
    • -
  • 4776 return (!columns || columns.length == 0) ? this._static.WILDCARD : this.__expressionList(columns);
    • +
  • 4780 return (!columns || columns.length == 0) ? this._static.WILDCARD : this.__expressionList(columns);
  • },
  • /**
    • @@ -15094,11 +15094,11 @@
  • * @return SQL fragment for a number.
  • */
  • _literalNumber:function (num) {
    • -
  • 6152 var ret = "" + num;
    • -
  • 6152 if (isNaN(num) || num == Infinity) {
    • +
  • 6160 var ret = "" + num;
    • +
  • 6160 if (isNaN(num) || num == Infinity) {
  • 0 ret = string.format("'%s'", ret);
  • }
    • -
  • 6152 return ret;
    • +
  • 6160 return ret;
  • },
  • /**
    • @@ -15147,7 +15147,7 @@
  • * @return SQL fragment for SQL::Expression, result depends on the specific type of expression.
  • * */
  • _literalExpression:function (v) {
    • -
  • 24453 return v.toString(this);
    • +
  • 24477 return v.toString(this);
  • },
  • /**
    • @@ -15180,9 +15180,9 @@
  • /*SQL STATEMENT CREATION METHODS*/
  • _selectQualifySql:function () {
    • -
  • 4323 var o = this.__opts;
    • -
  • 4323 var table = this.__opts.alwaysQualify;
    • -
  • 4323 if (table && !o.sql) {
    • +
  • 4327 var o = this.__opts;
    • +
  • 4327 var table = this.__opts.alwaysQualify;
    • +
  • 4327 if (table && !o.sql) {
  • 2 array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
  • 2 o[k] = this._qualifiedExpression(o[k], table);
  • }, this);
    • @@ -15200,19 +15200,19 @@
  • * @return the columns selected
  • * */
  • _selectColumnsSql:function () {
    • -
  • 3588 return " " + this.__columnList(this.__opts.select);
    • +
  • 3592 return " " + this.__columnList(this.__opts.select);
  • },
  • /**@return the DISTINCT clause.*/
  • _selectDistinctSql:function () {
    • -
  • 3588 var distinct = this.__opts.distinct, ret = [];
    • -
  • 3588 if (distinct) {
    • +
  • 3592 var distinct = this.__opts.distinct, ret = [];
    • +
  • 3592 if (distinct) {
  • 10 ret.push(" DISTINCT");
  • 10 if (distinct.length) {
  • 4 ret.push(format(" ON (%s)", this.__expressionList(distinct)));
  • }
  • }
    • -
  • 3588 return ret.join("");
    • +
  • 3592 return ret.join("");
  • },
  • /**
    • @@ -15221,30 +15221,30 @@
  • * work on all databases.
  • **/
  • _selectCompoundsSql:function () {
    • -
  • 3588 var opts = this.__opts, compounds = opts.compounds, ret = [];
    • -
  • 3588 if (compounds) {
    • +
  • 3592 var opts = this.__opts, compounds = opts.compounds, ret = [];
    • +
  • 3592 if (compounds) {
  • 49 compounds.forEach(function (c) {
  • 49 var type = c[0], dataset = c[1], all = c[2];
  • 49 ret.push(string.format(" %s%s %s", type.toUpperCase(), all ? " ALL" : "", this._subselectSql(dataset)));
  • }, this);
  • }
    • -
  • 3588 return ret.join("");
    • +
  • 3592 return ret.join("");
  • },
  • /**
  • * @return the sql to add the list of tables to select FROM
  • **/
  • _selectFromSql:function () {
    • -
  • 3606 var from = this.__opts.from;
    • -
  • 3606 return from ? string.format(" %s%s", this._static.FROM, this._sourceList(from)) : "";
    • +
  • 3610 var from = this.__opts.from;
    • +
  • 3610 return from ? string.format(" %s%s", this._static.FROM, this._sourceList(from)) : "";
  • },
  • /**
  • * @return the GROUP BY clause
  • **/
  • _selectGroupSql:function () {
    • -
  • 3588 var group = this.__opts.group;
    • -
  • 3588 return group ? string.format(" GROUP BY %s", this.__expressionList(group)) : "";
    • +
  • 3592 var group = this.__opts.group;
    • +
  • 3592 return group ? string.format(" GROUP BY %s", this.__expressionList(group)) : "";
  • },
    • @@ -15252,62 +15252,62 @@
  • *@return the sql to add the filter criteria in the HAVING clause
  • **/
  • _selectHavingSql:function () {
    • -
  • 3588 var having = this.__opts.having;
    • -
  • 3588 return having ? string.format(" HAVING %s", this.literal(having)) : "";
    • +
  • 3592 var having = this.__opts.having;
    • +
  • 3592 return having ? string.format(" HAVING %s", this.literal(having)) : "";
  • },
  • /**
  • * @return the JOIN clause.
  • **/
  • _selectJoinSql:function () {
    • -
  • 3591 var join = this.__opts.join, ret = [];
    • -
  • 3591 if (join) {
    • +
  • 3595 var join = this.__opts.join, ret = [];
    • +
  • 3595 if (join) {
  • 467 join.forEach(function (j) {
  • 771 ret.push(this.literal(j));
  • }, this);
  • }
    • -
  • 3591 return ret.join("");
    • +
  • 3595 return ret.join("");
  • },
  • /**
  • * @return the LIMIT and OFFSET clauses.
  • * */
  • _selectLimitSql:function () {
    • -
  • 3588 var ret = [], limit = this.__opts.limit, offset = this.__opts.offset;
    • -
  • 3588 !isUndefined(limit) && !isNull(limit) && (ret.push(format(" LIMIT %s", this.literal(limit))));
    • -
  • 3588 !isUndefined(offset) && !isNull(offset) && (ret.push(format(" OFFSET %s", this.literal(offset))));
    • -
  • 3588 return ret.join("");
    • +
  • 3592 var ret = [], limit = this.__opts.limit, offset = this.__opts.offset;
    • +
  • 3592 !isUndefined(limit) && !isNull(limit) && (ret.push(format(" LIMIT %s", this.literal(limit))));
    • +
  • 3592 !isUndefined(offset) && !isNull(offset) && (ret.push(format(" OFFSET %s", this.literal(offset))));
    • +
  • 3592 return ret.join("");
  • },
  • /**
  • * @return SQL for different locking modes.
  • **/
  • _selectLockSql:function () {
    • -
  • 3587 var lock = this.__opts.lock, ret = [];
    • -
  • 3587 if (lock) {
    • +
  • 3591 var lock = this.__opts.lock, ret = [];
    • +
  • 3591 if (lock) {
  • 3 if (lock == "update") {
  • 2 ret.push(this._static.FOR_UPDATE);
  • } else {
  • 1 ret.push(" ", lock);
  • }
  • }
    • -
  • 3587 return ret.join("");
    • +
  • 3591 return ret.join("");
  • },
  • /**
  • * @return the SQL ORDER BY clause fragment.
  • */
  • _selectOrderSql:function () {
    • -
  • 3600 var order = this.__opts.order;
    • -
  • 3600 return order ? string.format(" ORDER BY %s", this.__expressionList(order)) : "";
    • +
  • 3604 var order = this.__opts.order;
    • +
  • 3604 return order ? string.format(" ORDER BY %s", this.__expressionList(order)) : "";
  • },
  • /**
  • * @return the SQL WHERE clause fragment.
  • */
  • _selectWhereSql:function () {
    • -
  • 4554 var where = this.__opts.where;
    • -
  • 4554 return where ? string.format(" WHERE %s", this.literal(where)) : "";
    • +
  • 4558 var where = this.__opts.where;
    • +
  • 4558 return where ? string.format(" WHERE %s", this.literal(where)) : "";
  • },
  • /**
    • @@ -15315,8 +15315,8 @@
  • * @param sql
  • */
  • _selectWithSql:function (sql) {
    • -
  • 5516 var wit = this.__opts["with"];
    • -
  • 5516 if (wit && wit.length) {
    • +
  • 5520 var wit = this.__opts["with"];
    • +
  • 5520 if (wit && wit.length) {
  • //sql.length = 0;
  • 8 var base = sql.join("");
  • 8 sql.length = 0;
    • @@ -15459,15 +15459,15 @@
  • * Converts an array of source names into into a comma separated list.
  • **/
  • _sourceList:function (source) {
    • -
  • 5814 if (!Array.isArray(source)) {
    • +
  • 5818 if (!Array.isArray(source)) {
  • 718 source = [source];
  • }
    • -
  • 5814 if (!source || !source.length) {
    • +
  • 5818 if (!source || !source.length) {
  • 0 throw new QueryError("No source specified for the query");
  • }
    • -
  • 5814 return " " + source.map(
    • +
  • 5818 return " " + source.map(
  • function (s) {
    • -
  • 5996 return this.__tableRef(s);
    • +
  • 6000 return this.__tableRef(s);
  • }, this).join(this._static.COMMA_SEPARATOR);
  • },
    • @@ -15492,7 +15492,7 @@
  • * @returns SQL fragment specifying a table name.
  • **/
  • __tableRef:function (t) {
    • -
  • 6767 return isString(t) ? this._quotedIdentifier(t) : this.literal(t);
    • +
  • 6771 return isString(t) ? this._quotedIdentifier(t) : this.literal(t);
  • },
    • @@ -15522,12 +15522,12 @@
  • getters:{
  • //Same as selectS, not aliased directly to make subclassing simpler.
  • sql:function () {
    • -
  • 648 return this.selectSql;
    • +
  • 652 return this.selectSql;
  • },
  • selectSql:function () {
    • -
  • 3690 if (this.__opts.sql) return this._staticSql(this.__opts.sql);
    • -
  • 3588 else return this._clauseSql("select");
    • +
  • 3694 if (this.__opts.sql) return this._staticSql(this.__opts.sql);
    • +
  • 3592 else return this._clauseSql("select");
  • },
  • deleteSql:function () {
    • @@ -15982,10 +15982,10 @@
  • /**@ignore*/
  • constructor:function () {
    • -
  • 25725 if (!Dataset) {
    • +
  • 25745 if (!Dataset) {
  • 1 Dataset = require("../index").Dataset;
  • }
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 this._super(arguments);
  • },
    • @@ -17202,10 +17202,10 @@
  • *
  • */
  • constructor:function () {
    • -
  • 2717 if (comb.isUndefinedOrNull(this.__associations)) {
    • -
  • 2629 this.__associations = {};
    • +
  • 2715 if (comb.isUndefinedOrNull(this.__associations)) {
    • +
  • 2628 this.__associations = {};
  • }
    • -
  • 2717 this._super(arguments);
    • +
  • 2715 this._super(arguments);
  • },
  • reload:function () {
    • @@ -17597,2865 +17597,2922 @@
  • }});
    • -
    +
    -
    dataset/query.js
    +
    plugins/validation.js
    - Coverage97.62 - SLOC2290 - LOC462 - Missed11 + Coverage97.66 + SLOC535 + LOC128 + Missed3
    - 
    1. 1var comb = require("comb"),
      2. 
+    
      1. 1var comb = require("comb"),
        2. 
 
      2.      array = comb.array,
        3. 
-
      3.      flatten = array.flatten,
        4. 
 
      4.      compact = array.compact,
        5. 
-
      5.      define = comb.define,
        6. 
-
      6.      argsToArray = comb.argsToArray,
        7. 
-
      7.      isString = comb.isString,
        8. 
-
      8.      isEmpty = comb.isEmpty,
        9. 
-
      9.      isNull = comb.isNull,
        10. 
-
      10.      isBoolean = comb.isBoolean,
        11. 
-
      11.      isNumber = comb.isNumber,
        12. 
-
      12.      merge = comb.merge,
        13. 
+
      13.      flatten = array.flatten,
        14. 
+
      14.      toArray = array.toArray,
        15. 
+
      15.      net = require("net"),
        16. 
+
      16.      isIP = net.isIP,
        17. 
+
      17.      isIPv4 = net.isIPv4,
        18. 
+
      18.      isIPv6 = net.isIPv6,
        19. 
+
      19.      validator = require("validator"),
        20. 
+
      20.      validatorCheck = validator.check,
        21. 
+
      21.      dateCmp = comb.date.compare,
        22. 
 
      22.      isArray = comb.isArray,
        23. 
-
      23.      isObject = comb.isObject,
        24. 
+
      24.      combDeepEqual = comb.deepEqual,
        25. 
+
      25.      combIsBoolean = comb.isBoolean,
        26. 
+
      26.      isString = comb.isString,
        27. 
+
      27.      combIsDefined = comb.isDefined,
        28. 
+
      28.      combIsNull = comb.isNull,
        29. 
+
      29.      ModelError = require("../errors.js").ModelError,
        30. 
 
      30.      isFunction = comb.isFunction,
        31. 
-
      31.      isUndefined = comb.isUndefined,
        32. 
-
      32.      isHash = comb.isHash,
        33. 
-
      33.      isInstanceOf = comb.isInstanceOf,
        34. 
-
      34.      sql = require("../sql").sql,
        35. 
-
      35.      LiteralString = sql.LiteralString,
        36. 
-
      36.      Expression = sql.Expression,
        37. 
-
      37.      ComplexExpression = sql.ComplexExpression,
        38. 
-
      38.      BooleanExpression = sql.BooleanExpression,
        39. 
-
      39.      PlaceHolderLiteralString = sql.PlaceHolderLiteralString,
        40. 
-
      40.      Identifier = sql.Identifier,
        41. 
-
      41.      QualifiedIdentifier = sql.QualifiedIdentifier,
        42. 
-
      42.      AliasedExpression = sql.AliasedExpression,
        43. 
-
      43.      StringExpression = sql.StringExpression,
        44. 
-
      44.      NumericExpression = sql.NumericExpression,
        45. 
-
      45.      OrderedExpression = sql.OrderedExpression,
        46. 
-
      46.      JoinClause = sql.JoinClause,
        47. 
-
      47.      JoinOnClause = sql.JoinOnClause,
        48. 
-
      48.      JoinUsingClause = sql.JoinUsingClause,
        49. 
-
      49.      ColumnAll = sql.ColumnAll,
        50. 
-
      50.      QueryError = require("../errors").QueryError;
        51. 
+
      51.      format = comb.string.format,
        52. 
+
      52.      Promise = comb.Promise,
        53. 
+
      53.      serial = comb.serial,
        54. 
+
      54.      when = comb.when,
        55. 
+
      55.      merge = comb.merge,
        56. 
+
      56.      define = comb.define;
        57. 
 
      57.  
        58. 
+
      58. 1var Validator = define(null, {
        59. 
+
      59.      instance:{
        60. 
 
      60.  
        61. 
-
      61. 1var Dataset;
        62. 
+
      62.          constructor:function validator(col) {
        63. 
+
      63. 44            this.col = col;
        64. 
+
      64. 44            this.__actions = [];
        65. 
+
      65.          },
        66. 
 
      66.  
        67. 
-
      67. 1function conditionedJoin(type) {
        68. 
-
      68. 539    var args = argsToArray(arguments, 1);
        69. 
-
      69. 539    return this.joinTable.apply(this, [type].concat(args));
        70. 
-
      70.  }
        71. 
+
      71.          __addAction:function __addAction(action, opts) {
        72. 
+
      72. 46            this.__actions.push({
        73. 
+
      73.                  action:action,
        74. 
+
      74.                  opts:merge({onlyDefined:true, onlyNotNull:false}, opts)
        75. 
+
      75.              });
        76. 
+
      76. 46            return this;
        77. 
+
      77.          },
        78. 
 
      78.  
        79. 
-
      79. 1function unConditionJoin(type, table) {
        80. 
-
      80. 6    var args = argsToArray(arguments, 1);
        81. 
-
      81. 6    return this.joinTable.apply(this, [type, table]);
        82. 
-
      82.  }
        83. 
+
      83.          isAfter:function (date, opts) {
        84. 
+
      84. 1            opts = opts || {};
        85. 
+
      85. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
        86. 
+
      86. 1            return this.__addAction(function (col) {
        87. 
+
      87. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") > 0;
        88. 
+
      88.              }, merge({message:"{col} must be after " + date + " got {val}."}, opts));
        89. 
+
      89.          },
        90. 
 
      90.  
        91. 
+
      91.          isBefore:function (date, opts) {
        92. 
+
      92. 1            opts = opts || {};
        93. 
+
      93. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
        94. 
+
      94. 1            return this.__addAction(function (col) {
        95. 
+
      95. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") === -1;
        96. 
+
      96.              }, merge({message:"{col} must be before " + date + " got {val}."}, opts));
        97. 
+
      97.          },
        98. 
 
      98.  
        99. 
-
      99. 1define(null, {
        100. 
-
      100.      /**@ignore*/
        101. 
-
      101.      instance: {
        102. 
+
      102.          isDefined:function isDefined(opts) {
        103. 
+
      103. 1            return this.__addAction(function (col) {
        104. 
+
      104. 3                return combIsDefined(col);
        105. 
+
      105.              }, merge({message:"{col} must be defined.", onlyDefined:false, onlyNotNull:false}, opts));
        106. 
+
      106.          },
        107. 
 
      107.  
        108. 
-
      108.          /**@lends patio.Dataset.prototype*/
        109. 
+
      109.          isNotDefined:function isNotDefined(opts) {
        110. 
+
      110. 1            return this.__addAction(function (col) {
        111. 
+
      111. 3                return !combIsDefined(col);
        112. 
+
      112.              }, merge({message:"{col} cannot be defined.", onlyDefined:false, onlyNotNull:false}, opts));
        113. 
+
      113.          },
        114. 
 
      114.  
        115. 
-
      115.          /**
        116. 
-
      116.           * @ignore
        117. 
-
      117.           */
        118. 
-
      118.          constructor: function () {
        119. 
-
      119. 25725            !Dataset && (Dataset = require("../index").Dataset);
        120. 
-
      120. 25725            this._super(arguments);
        121. 
-
      121. 25725            this._static.CONDITIONED_JOIN_TYPES.forEach(function (type) {
        122. 
-
      122. 180075                if (!this[type + "Join"]) {
        123. 
-
      123. 180075                    this[type + "Join"] = conditionedJoin.bind(this, type);
        124. 
-
      124.                  }
        125. 
+
      125.          isNotNull:function isNotNull(opts) {
        126. 
+
      126. 3            return this.__addAction(function (col) {
        127. 
+
      127. 21                return combIsDefined(col) && !combIsNull(col);
        128. 
+
      128.              }, merge({message:"{col} cannot be null.", onlyDefined:false, onlyNotNull:false}, opts));
        129. 
+
      129.          },
        130. 
 
      130.  
        131. 
-
      131.              }, this);
        132. 
-
      132. 25725            this._static.UNCONDITIONED_JOIN_TYPES.forEach(function (type) {
        133. 
-
      133. 128625                if (!this[type + "Join"]) {
        134. 
-
      134. 128625                    this[type + "Join"] = unConditionJoin.bind(this, type);
        135. 
-
      135.                  }
        136. 
+
      136.          isNull:function isNull(opts) {
        137. 
+
      137. 1            return this.__addAction(function (col) {
        138. 
+
      138. 3                return !combIsDefined(col) || combIsNull(col);
        139. 
+
      139.              }, merge({message:"{col} must be null got {val}.", onlyDefined:false, onlyNotNull:false}, opts));
        140. 
+
      140.          },
        141. 
 
      141.  
        142. 
-
      142.              }, this);
        143. 
+
      143.          isEq:function eq(val, opts) {
        144. 
+
      144. 4            return this.__addAction(function (col) {
        145. 
+
      145. 15                return combDeepEqual(col, val);
        146. 
+
      146.              }, merge({message:"{col} must === " + val + " got {val}."}, opts));
        147. 
 
      147.          },
        148. 
 
      148.  
        149. 
-
      149.          /**
        150. 
-
      150.           * Adds a RETURNING clause, which is not supported by all databases. If returning is
        151. 
-
      151.           * used instead of returning the autogenerated primary key or update/delete returning the number of rows modified.
        152. 
-
      152.           *
        153. 
-
      153.           * @example
        154. 
-
      154.           *
        155. 
-
      155.           * ds.from("items").returning() //"RETURNING *"
        156. 
-
      156.           * ds.from("items").returning(null) //"RETURNING NULL"
        157. 
-
      157.           * ds.from("items").returning("id", "name") //"RETURNING id, name"
        158. 
-
      158.           * ds.from("items").returning(["id", "name"]) //"RETURNING id, name"
        159. 
-
      159.           *
        160. 
-
      160.           * @param values columns to return. If values is an array then the array is assumed to contain the columns to
        161. 
-
      161.           * return. Otherwise the arguments will be used.
        162. 
-
      162.           * @return {patio.Dataset} a new dataset with the retuning option added.
        163. 
-
      163.           */
        164. 
-
      164.          returning: function (values) {
        165. 
-
      165. 1087            var args;
        166. 
-
      166. 1087            if (Array.isArray(values)) {
        167. 
-
      167. 0                args = values;
        168. 
-
      168.              } else {
        169. 
-
      169. 1087                args = argsToArray(arguments);
        170. 
-
      170.              }
        171. 
-
      171. 1087            return this.mergeOptions({returning: args.map(function (v) {
        172. 
-
      172. 1005                return isString(v) ? sql.stringToIdentifier(v) : v;
        173. 
-
      173.              })});
        174. 
+
      174.          isNeq:function neq(val, opts) {
        175. 
+
      175. 2            return this.__addAction(function (col) {
        176. 
+
      176. 8                return !combDeepEqual(col, val);
        177. 
+
      177.              }, merge({message:"{col} must !== " + val + "."}, opts));
        178. 
 
      178.          },
        179. 
 
      179.  
        180. 
+
      180.          isLike:function like(val, opts) {
        181. 
+
      181. 3            return this.__addAction(function (col) {
        182. 
+
      182. 14                return !!col.match(val);
        183. 
+
      183.              }, merge({message:"{col} must be like " + val + " got {val}."}, opts));
        184. 
+
      184.          },
        185. 
 
      185.  
        186. 
-
      186.          /**
        187. 
-
      187.           * Adds a futher filter to an existing filter using AND. This method is identical to {@link patio.Dataset#filter}
        188. 
-
      188.           * except it expects an existing filter.
        189. 
-
      189.           *
        190. 
-
      190.           * <p>
        191. 
-
      191.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        192. 
-
      192.           * </p>
        193. 
-
      193.           *
        194. 
-
      194.           * @example
        195. 
-
      195.           * DB.from("table").filter("a").and("b").sql;
        196. 
-
      196.           *      //=>SELECT * FROM table WHERE a AND b
        197. 
-
      197.           *
        198. 
-
      198.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        199. 
-
      199.           *
        200. 
-
      200.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
        201. 
-
      201.           */
        202. 
-
      202.          and: function () {
        203. 
-
      203. 7            var tOpts = this.__opts, clauseObj = tOpts[tOpts.having ? "having" : "where"];
        204. 
-
      204. 7            if (clauseObj) {
        205. 
-
      205. 6                return this.filter.apply(this, arguments);
        206. 
-
      206.              } else {
        207. 
-
      207. 1                throw new QueryError("No existing filter found");
        208. 
-
      208.              }
        209. 
+
      209.          isNotLike:function notLike(val, opts) {
        210. 
+
      210. 2            return this.__addAction(function (col) {
        211. 
+
      211. 6                return !(!!col.match(val));
        212. 
+
      212.              }, merge({message:"{col} must not be like " + val + "."}, opts));
        213. 
 
      213.          },
        214. 
 
      214.  
        215. 
-
      215.          as: function (alias) {
        216. 
-
      216. 8            return new AliasedExpression(this, alias);
        217. 
+
      217.          isLt:function lt(num, opts) {
        218. 
+
      218. 1            return this.__addAction(function (col) {
        219. 
+
      219. 3                return col < num;
        220. 
+
      220.              }, merge({message:"{col} must be < " + num + " got {val}."}, opts));
        221. 
 
      221.          },
        222. 
 
      222.  
        223. 
-
      223.          /**
        224. 
-
      224.           * Adds an alternate filter to an existing WHERE/HAVING using OR.
        225. 
-
      225.           *
        226. 
-
      226.           * <p>
        227. 
-
      227.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        228. 
-
      228.           * </p>
        229. 
-
      229.           *
        230. 
-
      230.           * @example
        231. 
-
      231.           *
        232. 
-
      232.           * DB.from("items").filter("a").or("b")
        233. 
-
      233.           *      //=> SELECT * FROM items WHERE a OR b
        234. 
-
      234.           *
        235. 
-
      235.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        236. 
-
      236.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
        237. 
-
      237.           */
        238. 
-
      238.          or: function () {
        239. 
-
      239. 12            var tOpts = this.__opts;
        240. 
-
      240. 12            var clause = (tOpts.having ? "having" : "where"), clauseObj = tOpts[clause];
        241. 
-
      241. 12            if (clauseObj) {
        242. 
-
      242. 9                var args = argsToArray(arguments);
        243. 
-
      243. 9                args = args.length == 1 ? args[0] : args;
        244. 
-
      244. 9                var opts = {};
        245. 
-
      245. 9                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args));
        246. 
-
      246. 9                return this.mergeOptions(opts);
        247. 
-
      247.              } else {
        248. 
-
      248. 3                throw new QueryError("No existing filter found");
        249. 
+
      249.          isGt:function gt(num, opts) {
        250. 
+
      250. 1            return this.__addAction(function (col) {
        251. 
+
      251. 3                return col > num;
        252. 
+
      252.              }, merge({message:"{col} must be > " + num + " got {val}."}, opts));
        253. 
+
      253.          },
        254. 
+
      254.  
        255. 
+
      255.          isLte:function lte(num, opts) {
        256. 
+
      256. 1            return this.__addAction(function (col) {
        257. 
+
      257. 3                return col <= num;
        258. 
+
      258.              }, merge({message:"{col} must be <= " + num + " got {val}."}, opts));
        259. 
+
      259.          },
        260. 
+
      260.  
        261. 
+
      261.          isGte:function gte(num, opts) {
        262. 
+
      262. 1            return this.__addAction(function (col) {
        263. 
+
      263. 3                return col >= num;
        264. 
+
      264.              }, merge({message:"{col} must be >= " + num + " got {val}."}, opts));
        265. 
+
      265.          },
        266. 
+
      266.  
        267. 
+
      267.          isIn:function isIn(arr, opts) {
        268. 
+
      268. 2            if (!isArray(arr)) {
        269. 
+
      269. 1                throw new Error("isIn requires an array of values");
        270. 
 
      270.              }
        271. 
+
      271. 1            return this.__addAction(function (col) {
        272. 
+
      272. 3                return arr.indexOf(col) !== -1;
        273. 
+
      273.              }, merge({message:"{col} must be in " + arr.join(",") + " got {val}."}, opts));
        274. 
 
      274.          },
        275. 
 
      275.  
        276. 
-
      276.          /**
        277. 
-
      277.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        278. 
-
      278.           *
        279. 
-
      279.           * <p>
        280. 
-
      280.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        281. 
-
      281.           * </p>
        282. 
-
      282.           *
        283. 
-
      283.           * @example
        284. 
-
      284.           *
        285. 
-
      285.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        286. 
-
      286.           *      //=> SELECT
        287. 
-
      287.           *               *
        288. 
-
      288.           *           FROM
        289. 
-
      289.           *               items
        290. 
-
      290.           *           WHERE
        291. 
-
      291.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        292. 
-
      292.           *
        293. 
-
      293.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        294. 
-
      294.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        295. 
-
      295.           */
        296. 
-
      296.          andGroupedOr: function () {
        297. 
-
      297. 2            var tOpts = this.__opts,
        298. 
-
      298.                  clause = (tOpts.having ? "having" : "where"),
        299. 
-
      299.                  clauseObj = tOpts[clause];
        300. 
-
      300. 2            if (clauseObj) {
        301. 
-
      301. 1                var args = argsToArray(arguments);
        302. 
-
      302. 1                args = args.length == 1 ? args[0] : args;
        303. 
-
      303. 1                var opts = {};
        304. 
-
      304. 1                opts[clause] = new BooleanExpression("AND", clauseObj, this._filterExpr(args, null, "OR"));
        305. 
-
      305. 1                return this.mergeOptions(opts);
        306. 
-
      306.              } else {
        307. 
-
      307. 1                throw new QueryError("No existing filter found");
        308. 
-
      308.              }
        309. 
-
      309.          },
        310. 
-
      310.  
        311. 
-
      311.          /**
        312. 
-
      312.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        313. 
-
      313.           *
        314. 
-
      314.           * <p>
        315. 
-
      315.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        316. 
-
      316.           * </p>
        317. 
-
      317.           *
        318. 
-
      318.           * @example
        319. 
-
      319.           *
        320. 
-
      320.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        321. 
-
      321.           *      //=> SELECT
        322. 
-
      322.           *               *
        323. 
-
      323.           *           FROM
        324. 
-
      324.           *               items
        325. 
-
      325.           *           WHERE
        326. 
-
      326.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        327. 
-
      327.           *
        328. 
-
      328.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        329. 
-
      329.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        330. 
-
      330.           */
        331. 
-
      331.          andGroupedAnd: function () {
        332. 
-
      332. 2            var tOpts = this.__opts,
        333. 
-
      333.                  clause = (tOpts.having ? "having" : "where"),
        334. 
-
      334.                  clauseObj = tOpts[clause];
        335. 
-
      335. 2            if (clauseObj) {
        336. 
-
      336. 1                var args = argsToArray(arguments);
        337. 
-
      337. 1                args = args.length == 1 ? args[0] : args;
        338. 
-
      338. 1                var opts = {};
        339. 
-
      339. 1                opts[clause] = new BooleanExpression("AND", clauseObj, this._filterExpr(args, null, "AND"));
        340. 
-
      340. 1                return this.mergeOptions(opts);
        341. 
-
      341.              } else {
        342. 
-
      342. 1                throw new QueryError("No existing filter found");
        343. 
-
      343.              }
        344. 
-
      344.          },
        345. 
-
      345.  
        346. 
-
      346.          /**
        347. 
-
      347.           * Adds to the where/having clause with an OR a group of ANDed conditions wrapped in parens
        348. 
-
      348.           *
        349. 
-
      349.           * <p>
        350. 
-
      350.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        351. 
-
      351.           * </p>
        352. 
-
      352.           *
        353. 
-
      353.           * @example
        354. 
-
      354.           *
        355. 
-
      355.           * DB.from("items").filter({id, [1,2,3]}).orGroupedAnd([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        356. 
-
      356.           *      //=> SELECT
        357. 
-
      357.           *               *
        358. 
-
      358.           *           FROM
        359. 
-
      359.           *               items
        360. 
-
      360.           *           WHERE
        361. 
-
      361.           *               ((id IN (1, 2, 3)) OR ((price > 0) AND (price < 10)))
        362. 
-
      362.           *
        363. 
-
      363.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        364. 
-
      364.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
        365. 
-
      365.           */
        366. 
-
      366.          orGroupedAnd: function () {
        367. 
-
      367. 3            return this.or.apply(this, arguments);
        368. 
-
      368.          },
        369. 
-
      369.  
        370. 
-
      370.          /**
        371. 
-
      371.           * Adds to the where/having clause with an AND a group of ORed conditions wrapped in parens
        372. 
-
      372.           *
        373. 
-
      373.           * <p>
        374. 
-
      374.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
        375. 
-
      375.           * </p>
        376. 
-
      376.           *
        377. 
-
      377.           * @example
        378. 
-
      378.           *
        379. 
-
      379.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
        380. 
-
      380.           *      //=> SELECT
        381. 
-
      381.           *               *
        382. 
-
      382.           *           FROM
        383. 
-
      383.           *               items
        384. 
-
      384.           *           WHERE
        385. 
-
      385.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
        386. 
-
      386.           *
        387. 
-
      387.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
        388. 
-
      388.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
        389. 
-
      389.           */
        390. 
-
      390.          orGroupedOr: function () {
        391. 
-
      391. 1            var tOpts = this.__opts,
        392. 
-
      392.                  clause = (tOpts.having ? "having" : "where"),
        393. 
-
      393.                  clauseObj = tOpts[clause];
        394. 
-
      394. 1            if (clauseObj) {
        395. 
-
      395. 1                var args = argsToArray(arguments);
        396. 
-
      396. 1                args = args.length == 1 ? args[0] : args;
        397. 
-
      397. 1                var opts = {};
        398. 
-
      398. 1                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args, null, "OR"));
        399. 
-
      399. 1                return this.mergeOptions(opts);
        400. 
-
      400.              } else {
        401. 
-
      401. 0                throw new QueryError("No existing filter found");
        402. 
-
      402.              }
        403. 
-
      403.          },
        404. 
-
      404.  
        405. 
-
      405.          /**
        406. 
-
      406.           * Returns a copy of the dataset with the SQL DISTINCT clause.
        407. 
-
      407.           * The DISTINCT clause is used to remove duplicate rows from the
        408. 
-
      408.           * output.  If arguments are provided, uses a DISTINCT ON clause,
        409. 
-
      409.           * in which case it will only be distinct on those columns, instead
        410. 
-
      410.           * of all returned columns.
        411. 
-
      411.           *
        412. 
-
      412.           * @example
        413. 
-
      413.           *
        414. 
-
      414.           * DB.from("items").distinct().sqll
        415. 
-
      415.           *      //=> SELECT DISTINCT * FROM items
        416. 
-
      416.           * DB.from("items").order("id").distinct("id").sql;
        417. 
-
      417.           *      //=> SELECT DISTINCT ON (id) * FROM items ORDER BY id
        418. 
-
      418.           *
        419. 
-
      419.           * @throws {patio.QueryError}  If arguments are given and DISTINCT ON is not supported.
        420. 
-
      420.           * @param {...String|...patio.sql.Identifier} args variable number of arguments used to create
        421. 
-
      421.           *                                                 the DISTINCT ON clause.
        422. 
-
      422.           * @return {patio.Dataset} a cloned dataset with the DISTINCT/DISTINCT ON clause added.
        423. 
-
      423.           */
        424. 
-
      424.          distinct: function (args) {
        425. 
-
      425. 13            args = argsToArray(arguments);
        426. 
-
      426. 13            if (args.length && !this.supportsDistinctOn) {
        427. 
-
      427. 1                throw new QueryError("DISTICT ON is not supported");
        428. 
-
      428.              }
        429. 
-
      429. 12            args = args.map(function (a) {
        430. 
-
      430. 6                return isString(a) ? new Identifier(a) : a;
        431. 
-
      431.              });
        432. 
-
      432. 12            return this.mergeOptions({distinct: args});
        433. 
-
      433.          },
        434. 
-
      434.  
        435. 
-
      435.          /**
        436. 
-
      436.           * Adds an EXCEPT clause using a second dataset object.
        437. 
-
      437.           * An EXCEPT compound dataset returns all rows in the current dataset
        438. 
-
      438.           * that are not in the given dataset.
        439. 
-
      439.           *
        440. 
-
      440.           * @example
        441. 
-
      441.           *
        442. 
-
      442.           * DB.from("items").except(DB.from("other_items")).sql;
        443. 
-
      443.           *      //=> SELECT * FROM items EXCEPT SELECT * FROM other_items
        444. 
-
      444.           *
        445. 
-
      445.           * DB.from("items").except(DB.from("other_items"),
        446. 
-
      446.           *                        {all : true, fromSelf : false}).sql;
        447. 
-
      447.           *      //=> SELECT * FROM items EXCEPT ALL SELECT * FROM other_items
        448. 
-
      448.           *
        449. 
-
      449.           * DB.from("items").except(DB.from("other_items"),
        450. 
-
      450.           *                        {alias : "i"}).sql;
        451. 
-
      451.           *      //=>SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS i
        452. 
-
      452.           *
        453. 
-
      453.           * @throws {patio.QueryError} if the operation is not supported.
        454. 
-
      454.           * @param {patio.Dataset} dataset the dataset to use to create the EXCEPT clause.
        455. 
-
      455.           * @param {Object} [opts] options to use when creating the EXCEPT clause
        456. 
-
      456.           * @param {String|patio.sql.Identifier} [opt.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias.
        457. 
-
      457.           * @param {Boolean} [opts.all] Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
        458. 
-
      458.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}, use with care.
        459. 
-
      459.           *
        460. 
-
      460.           * @return {patio.Dataset} a cloned dataset with the EXCEPT clause added.
        461. 
-
      461.           */
        462. 
-
      462.          except: function (dataset, opts) {
        463. 
-
      463. 18            opts = isUndefined(opts) ? {} : opts;
        464. 
-
      464. 18            if (!isHash(opts)) {
        465. 
-
      465. 5                opts = {all: true};
        466. 
-
      466.              }
        467. 
-
      467. 18            if (!this.supportsIntersectExcept) {
        468. 
-
      468. 2                throw new QueryError("EXCEPT not supoorted");
        469. 
-
      469. 16            } else if (opts.hasOwnProperty("all") && !this.supportsIntersectExceptAll) {
        470. 
-
      470. 1                throw new QueryError("EXCEPT ALL not supported");
        471. 
+
      471.          isNotIn:function notIn(arr, opts) {
        472. 
+
      472. 2            if (!isArray(arr)) {
        473. 
+
      473. 1                throw new Error("notIn requires an array of values");
        474. 
 
      474.              }
        475. 
-
      475. 15            return this.compoundClone("except", dataset, opts);
        476. 
+
      476. 1            return this.__addAction(function (col) {
        477. 
+
      477. 3                return arr.indexOf(col) === -1;
        478. 
+
      478.              }, merge({message:"{col} cannot be in " + arr.join(",") + " got {val}."}, opts));
        479. 
 
      479.          },
        480. 
 
      480.  
        481. 
-
      481.          /**
        482. 
-
      482.           * Performs the inverse of {@link patio.Dataset#filter}.  Note that if you have multiple filter
        483. 
-
      483.           * conditions, this is not the same as a negation of all conditions. For argument types see
        484. 
-
      484.           * {@link patio.Dataset#filter}
        485. 
-
      485.           *
        486. 
-
      486.           * @example
        487. 
-
      487.           *
        488. 
-
      488.           * DB.from("items").exclude({category : "software").sql;
        489. 
-
      489.           *      //=> SELECT * FROM items WHERE (category != 'software')
        490. 
-
      490.           *
        491. 
-
      491.           * DB.from("items").exclude({category : 'software', id : 3}).sql;
        492. 
-
      492.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
        493. 
-
      493.           * @return {patio.Dataset} a cloned dataset with the excluded conditions applied to the HAVING/WHERE clause.
        494. 
-
      494.           */
        495. 
-
      495.          exclude: function () {
        496. 
-
      496. 69            var cond = argsToArray(arguments), tOpts = this.__opts;
        497. 
-
      497. 69            var clause = (tOpts["having"] ? "having" : "where"), clauseObj = tOpts[clause];
        498. 
-
      498. 69            cond = cond.length > 1 ? cond : cond[0];
        499. 
-
      499. 69            cond = this._filterExpr.call(this, cond);
        500. 
-
      500. 69            cond = BooleanExpression.invert(cond);
        501. 
-
      501. 69            if (clauseObj) {
        502. 
-
      502. 58                cond = new BooleanExpression("AND", clauseObj, cond)
        503. 
-
      503.              }
        504. 
-
      504. 69            var opts = {};
        505. 
-
      505. 69            opts[clause] = cond;
        506. 
-
      506. 69            return this.mergeOptions(opts);
        507. 
+
      507.          isMacAddress:function isMaxAddress(opts) {
        508. 
+
      508. 1            return this.__addAction(function (col) {
        509. 
+
      509. 4                return !!col.match(/^([0-9A-F]{2}[:\-]){5}([0-9A-F]{2})$/);
        510. 
+
      510.              }, merge({message:"{col} must be a valid MAC address got {val}."}, opts));
        511. 
 
      511.          },
        512. 
 
      512.  
        513. 
-
      513.          /**
        514. 
-
      514.           * Returns a copy of the dataset with the given conditions applied to it.
        515. 
-
      515.           * If the query already has a HAVING clause, then the conditions are applied to the
        516. 
-
      516.           * HAVING clause otherwise they are applied to the WHERE clause.
        517. 
-
      517.           *
        518. 
-
      518.           * @example
        519. 
-
      519.           *
        520. 
-
      520.           * DB.from("items").filter({id : 3}).sql;
        521. 
-
      521.           *      //=> SELECT * FROM items WHERE (id = 3)
        522. 
-
      522.           *
        523. 
-
      523.           * DB.from("items").filter('price < ?', 100)
        524. 
-
      524.           *      //=> SELECT * FROM items WHERE price < 100
        525. 
-
      525.           *
        526. 
-
      526.           * DB.from("items").filter({id, [1,2,3]}).filter({id : {between : [0, 10]}}).sql;
        527. 
-
      527.           *      //=> SELECT
        528. 
-
      528.           *               *
        529. 
-
      529.           *           FROM
        530. 
-
      530.           *               items
        531. 
-
      531.           *           WHERE
        532. 
-
      532.           *               ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))
        533. 
-
      533.           *
        534. 
-
      534.           * DB.from("items").filter('price < 100');
        535. 
-
      535.           *      //=> SELECT * FROM items WHERE price < 100
        536. 
-
      536.           *
        537. 
-
      537.           * DB.from("items").filter("active").sql;
        538. 
-
      538.           *      //=> SELECT * FROM items WHERE active
        539. 
-
      539.           *
        540. 
-
      540.           * DB.from("items").filter(function(){
        541. 
-
      541.           *      return this.price.lt(100);
        542. 
-
      542.           * });
        543. 
-
      543.           *      //=> SELECT * FROM items WHERE (price < 100)
        544. 
-
      544.           *
        545. 
-
      545.           * //Multiple filter calls can be chained for scoping:
        546. 
-
      546.           * DB.from("items").filter(:category => 'software').filter{price < 100}
        547. 
-
      547.           *      //=> SELECT * FROM items WHERE ((category = 'software') AND (price < 100))
        548. 
-
      548.           *
        549. 
-
      549.           *
        550. 
-
      550.           * @param {Object|Array|String|patio.sql.Identifier|patio.sql.BooleanExpression} args filters to apply to the
        551. 
-
      551.           *  WHERE/HAVING clause. Description of each:
        552. 
-
      552.           *  <ul>
        553. 
-
      553.           *      <li>Hash - list of equality/inclusion expressions</li>
        554. 
-
      554.           *      <li>Array - depends:
        555. 
-
      555.           *          <ul>
        556. 
-
      556.           *              <li>If first member is a string, assumes the rest of the arguments
        557. 
-
      557.           *                  are parameters and interpolates them into the string.</li>
        558. 
-
      558.           *              <li>If all members are arrays of length two, treats the same way
        559. 
-
      559.           *                  as a hash, except it allows for duplicate keys to be
        560. 
-
      560.           *                  specified.</li>
        561. 
-
      561.           *              <li>Otherwise, treats each argument as a separate condition.</li>
        562. 
-
      562.           *           </ul>
        563. 
-
      563.           *       </li>
        564. 
-
      564.           *      <li>String - taken literally</li>
        565. 
-
      565.           *      <li>{@link patio.sql.Identifier} - taken as a boolean column argument (e.g. WHERE active)</li>
        566. 
-
      566.           *      <li>{@link patio.sql.BooleanExpression} - an existing condition expression,
        567. 
-
      567.           *          probably created using the patio.sql methods.
        568. 
-
      568.           *       </li>
        569. 
-
      569.           *
        570. 
-
      570.           * @param {Function} [cb] filter also takes a cb, which should return one of the above argument
        571. 
-
      571.           * types, and is treated the same way.  This block is called with an {@link patio.sql} object which can be used to dynaically create expression.  For more details
        572. 
-
      572.           * on the sql object see {@link patio.sql}
        573. 
-
      573.           *
        574. 
-
      574.           * <p>
        575. 
-
      575.           *     <b>NOTE:</b>If both a cb and regular arguments are provided, they get ANDed together.
        576. 
-
      576.           * </p>
        577. 
-
      577.           *
        578. 
-
      578.           * @return {patio.Dataset} a cloned dataset with the filter arumgents applied to the WHERE/HAVING clause.
        579. 
-
      579.           **/
        580. 
-
      580.          filter: function (args, cb) {
        581. 
-
      581. 3468            args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
        582. 
-
      582. 3468            return this._filter.apply(this, args);
        583. 
+
      583.          isIPAddress:function isIpAddress(opts) {
        584. 
+
      584. 1            return this.__addAction(function (col) {
        585. 
+
      585. 4                return !!isIP(col);
        586. 
+
      586.              }, merge({message:"{col} must be a valid IPv4 or IPv6 address got {val}."}, opts));
        587. 
 
      587.          },
        588. 
 
      588.  
        589. 
-
      589.          /**
        590. 
-
      590.           * @see patio.Dataset#filter
        591. 
-
      591.           */
        592. 
-
      592.          find: function () {
        593. 
-
      593. 30            var args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
        594. 
-
      594. 30            return this._filter.apply(this, args);
        595. 
+
      595.          isIPv4Address:function isIpAddress(opts) {
        596. 
+
      596. 1            return this.__addAction(function (col) {
        597. 
+
      597. 3                return isIPv4(col);
        598. 
+
      598.              }, merge({message:"{col} must be a valid IPv4 address got {val}."}, opts));
        599. 
 
      599.          },
        600. 
 
      600.  
        601. 
-
      601.          /**
        602. 
-
      602.           * @example
        603. 
-
      603.           * DB.from("table").forUpdate()
        604. 
-
      604.           *          //=> SELECT * FROM table FOR UPDATE
        605. 
-
      605.           * @return {patio.Dataset} a cloned dataset with a "update" lock style.
        606. 
-
      606.           */
        607. 
-
      607.          forUpdate: function () {
        608. 
-
      608. 1            return this.lockStyle("update");
        609. 
+
      609.          isIPv6Address:function isIpAddress(opts) {
        610. 
+
      610. 1            return this.__addAction(function (col) {
        611. 
+
      611. 3                return isIPv6(col);
        612. 
+
      612.              }, merge({message:"{col} must be a valid IPv6 address got {val}."}, opts));
        613. 
 
      613.          },
        614. 
 
      614.  
        615. 
-
      615.          /**
        616. 
-
      616.           * Returns a copy of the dataset with the source changed. If no
        617. 
-
      617.           * source is given, removes all tables.  If multiple sources
        618. 
-
      618.           * are given, it is the same as using a CROSS JOIN (cartesian product) between all tables.
        619. 
-
      619.           *
        620. 
-
      620.           * @example
        621. 
-
      621.           * var dataset = DB.from("items");
        622. 
-
      622.           *
        623. 
-
      623.           * dataset.from().sql;
        624. 
-
      624.           *      //=> SELECT *
        625. 
-
      625.           *
        626. 
-
      626.           * dataset.from("blah").sql
        627. 
-
      627.           *      //=> SELECT * FROM blah
        628. 
-
      628.           *
        629. 
-
      629.           * dataset.from("blah", "foo")
        630. 
-
      630.           *      //=> SELECT * FROM blah, foo
        631. 
-
      631.           *
        632. 
-
      632.           * dataset.from({a:"b"}).sql;
        633. 
-
      633.           *      //=> SELECT * FROM a AS b
        634. 
-
      634.           *
        635. 
-
      635.           * dataset.from(dataset.from("a").group("b").as("c")).sql;
        636. 
-
      636.           *          //=> "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
        637. 
-
      637.           *
        638. 
-
      638.           * @param {...String|...patio.sql.Identifier|...patio.Dataset|...Object} [source] tables to select from
        639. 
-
      639.           *
        640. 
-
      640.           * @return {patio.Dataset} a cloned dataset with the FROM clause overridden.
        641. 
-
      641.           */
        642. 
-
      642.          from: function (source) {
        643. 
-
      643. 821            source = argsToArray(arguments);
        644. 
-
      644. 821            var tableAliasNum = 0, sources = [];
        645. 
-
      645. 821            source.forEach(function (s) {
        646. 
-
      646. 1003                if (isInstanceOf(s, Dataset)) {
        647. 
-
      647. 86                    sources.push(new AliasedExpression(s, this._datasetAlias(++tableAliasNum)));
        648. 
-
      648. 917                } else if (isHash(s)) {
        649. 
-
      649. 3                    for (var i in s) {
        650. 
-
      650. 3                        sources.push(new AliasedExpression(new Identifier(i), s[i]));
        651. 
-
      651.                      }
        652. 
-
      652. 914                } else if (isString(s)) {
        653. 
-
      653. 889                    sources.push(this.stringToIdentifier(s))
        654. 
-
      654.                  } else {
        655. 
-
      655. 25                    sources.push(s);
        656. 
-
      656.                  }
        657. 
-
      657.              }, this);
        658. 
-
      658.  
        659. 
-
      659. 821            var o = {from: sources.length ? sources : null}
        660. 
-
      660. 821            if (tableAliasNum) {
        661. 
-
      661. 84                o.numDatasetSources = tableAliasNum;
        662. 
-
      662.              }
        663. 
-
      663. 821            return this.mergeOptions(o)
        664. 
+
      664.          isUUID:function isUUID(opts) {
        665. 
+
      665. 1            return this.__addAction(function (col) {
        666. 
+
      666. 3                return !!col.match(/^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$/);
        667. 
+
      667.              }, merge({message:"{col} must be a valid UUID got {val}"}, opts));
        668. 
 
      668.          },
        669. 
 
      669.  
        670. 
-
      670.          /**
        671. 
-
      671.           * Returns a dataset selecting from the current dataset.
        672. 
-
      672.           * Supplying the alias option controls the alias of the result.
        673. 
-
      673.           *
        674. 
-
      674.           * @example
        675. 
-
      675.           *
        676. 
-
      676.           * ds = DB.from("items").order("name").select("id", "name")
        677. 
-
      677.           *      //=> SELECT id,name FROM items ORDER BY name
        678. 
-
      678.           *
        679. 
-
      679.           * ds.fromSelf().sql;
        680. 
-
      680.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1
        681. 
-
      681.           *
        682. 
-
      682.           * ds.fromSelf({alias : "foo"}).sql;
        683. 
-
      683.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo
        684. 
-
      684.           *
        685. 
-
      685.           * @param {Object} [opts] options
        686. 
-
      686.           * @param {String|patio.sql.Identifier} [opts.alias] alias to use
        687. 
-
      687.           *
        688. 
-
      688.           * @return {patio.Dataset} a cloned dataset with the FROM clause set as the current dataset.
        689. 
-
      689.           */
        690. 
-
      690.          fromSelf: function (opts) {
        691. 
-
      691. 84            opts = isUndefined(opts) ? {} : opts;
        692. 
-
      692. 84            var fs = {};
        693. 
-
      693. 84            var nonSqlOptions = this._static.NON_SQL_OPTIONS;
        694. 
-
      694. 84            Object.keys(this.__opts).forEach(function (k) {
        695. 
-
      695. 302                if (nonSqlOptions.indexOf(k) == -1) {
        696. 
-
      696. 302                    fs[k] = null;
        697. 
-
      697.                  }
        698. 
-
      698.              });
        699. 
-
      699. 84            return this.mergeOptions(fs).from(opts["alias"] ? this.as(opts["alias"]) : this);
        700. 
+
      700.          isEmail:function isEmail(opts) {
        701. 
+
      701. 1            return this.__addAction(function (col) {
        702. 
+
      702. 3                return validatorCheck(col).isEmail();
        703. 
+
      703.              }, merge({message:"{col} must be a valid Email Address got {val}"}, opts));
        704. 
 
      704.          },
        705. 
 
      705.  
        706. 
-
      706.          /**
        707. 
-
      707.           * Match any of the columns to any of the patterns. The terms can be
        708. 
-
      708.           * strings (which use LIKE) or regular expressions (which are only
        709. 
-
      709.           * supported on MySQL and PostgreSQL).  Note that the total number of
        710. 
-
      710.           * pattern matches will be columns[].length * terms[].length,
        711. 
-
      711.           * which could cause performance issues.
        712. 
-
      712.           *
        713. 
-
      713.           * @example
        714. 
-
      714.           *
        715. 
-
      715.           * DB.from("items").grep("a", "%test%").sql;
        716. 
-
      716.           *      //=> SELECT * FROM items WHERE (a LIKE '%test%');
        717. 
-
      717.           *
        718. 
-
      718.           * DB.from("items").grep(["a", "b"], ["%test%" "foo"]).sql;
        719. 
-
      719.           *      //=> SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))
        720. 
-
      720.           *
        721. 
-
      721.           * DB.from("items").grep(['a', 'b'], ["%foo%", "%bar%"], {allPatterns : true}).sql;
        722. 
-
      722.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
        723. 
-
      723.           *
        724. 
-
      724.           * DB.from("items").grep(["a", "b"], ['%foo%", "%bar%", {allColumns : true})sql;
        725. 
-
      725.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
        726. 
-
      726.           *
        727. 
-
      727.           * DB.from("items").grep(["a", "b"], ["%foo%", "%bar%"], {allPatterns : true, allColumns : true}).sql;
        728. 
-
      728.           *      //=> SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
        729. 
-
      729.           *
        730. 
-
      730.           * @param {String[]|patio.sql.Identifier[]} columns columns to search
        731. 
-
      731.           * @param {String|RegExp} patterns patters to search with
        732. 
-
      732.           * @param {Object} [opts] options to use when searching. NOTE If both allColumns and allPatterns are true, all columns must match all patterns
        733. 
-
      733.           * @param {Boolean} [opts.allColumns] All columns must be matched to any of the given patterns.
        734. 
-
      734.           * @param {Boolean} [opts.allPatterns] All patterns must match at least one of the columns.
        735. 
-
      735.           * @param {Boolean} [opts.caseInsensitive] Use a case insensitive pattern match (the default is
        736. 
-
      736.           *                      case sensitive if the database supports it).
        737. 
-
      737.           * @return {patio.Dataset} a dataset with the LIKE clauses added
        738. 
-
      738.           */
        739. 
-
      739.  
        740. 
-
      740.          grep: function (columns, patterns, opts) {
        741. 
-
      741. 15            opts = isUndefined(opts) ? {} : opts;
        742. 
-
      742. 15            var conds;
        743. 
-
      743. 15            if (opts.hasOwnProperty("allPatterns")) {
        744. 
-
      744. 4                conds = array.toArray(patterns).map(function (pat) {
        745. 
-
      745. 8                    return BooleanExpression.fromArgs(
        746. 
-
      746.                          [(opts.allColumns ? "AND" : "OR")]
        747. 
-
      747.                              .concat(array.toArray(columns)
        748. 
-
      748.                                  .map(function (c) {
        749. 
-
      749. 16                                    return StringExpression.like(c, pat, opts);
        750. 
-
      750.                                  })));
        751. 
-
      751.                  });
        752. 
-
      752. 4                return this.filter(BooleanExpression.fromArgs([opts.allPatterns ? "AND" : "OR"].concat(conds)));
        753. 
-
      753.              } else {
        754. 
-
      754. 11                conds = array.toArray(columns)
        755. 
-
      755.                      .map(function (c) {
        756. 
-
      756. 16                        return BooleanExpression.fromArgs(["OR"].concat(array.toArray(patterns).map(function (pat) {
        757. 
-
      757. 26                            return StringExpression.like(c, pat, opts);
        758. 
-
      758.                          })));
        759. 
-
      759.                      });
        760. 
-
      760. 11                return this.filter(BooleanExpression.fromArgs([opts.allColumns ? "AND" : "OR"].concat(conds)));
        761. 
-
      761.              }
        762. 
+
      762.          isUrl:function isUrl(opts) {
        763. 
+
      763. 1            return this.__addAction(function (col) {
        764. 
+
      764. 3                return validatorCheck(col).isUrl();
        765. 
+
      765.              }, merge({message:"{col} must be a valid url got {val}"}, opts));
        766. 
 
      766.          },
        767. 
 
      767.  
        768. 
-
      768.          /**
        769. 
-
      769.           * @see patio.Dataset#grep
        770. 
-
      770.           */
        771. 
-
      771.          like: function () {
        772. 
-
      772. 1            return this.grep.apply(this, arguments);
        773. 
+
      773.          isAlpha:function isAlpha(opts) {
        774. 
+
      774. 2            return this.__addAction(function (col) {
        775. 
+
      775. 11                return validatorCheck(col).isAlpha();
        776. 
+
      776.              }, merge({message:"{col} must be a only letters got {val}"}, opts));
        777. 
 
      777.          },
        778. 
 
      778.  
        779. 
-
      779.  
        780. 
-
      780.          /**
        781. 
-
      781.           * Returns a copy of the dataset with the results grouped by the value of
        782. 
-
      782.           * the given columns.
        783. 
-
      783.           * @example
        784. 
-
      784.           *   DB.from("items").group("id")
        785. 
-
      785.           *          //=>SELECT * FROM items GROUP BY id
        786. 
-
      786.           *   DB.from("items").group("id", "name")
        787. 
-
      787.           *          //=> SELECT * FROM items GROUP BY id, name
        788. 
-
      788.           * @param {String...|patio.sql.Identifier...} columns columns to group by.
        789. 
-
      789.           *
        790. 
-
      790.           * @return {patio.Dataset} a cloned dataset with the GROUP BY clause added.
        791. 
-
      791.           **/
        792. 
-
      792.          group: function (columns) {
        793. 
-
      793. 32            columns = argsToArray(arguments);
        794. 
-
      794. 32            var stringToIdentifier = this.stringToIdentifier.bind(this)
        795. 
-
      795. 32            return this.mergeOptions({group: (array.compact(columns).length == 0 ? null : columns.map(function (c) {
        796. 
-
      796. 32                return isString(c) ? stringToIdentifier(c) : c;
        797. 
-
      797.              }))});
        798. 
+
      798.          isAlphaNumeric:function isAlphaNumeric(opts) {
        799. 
+
      799. 1            return this.__addAction(function (col) {
        800. 
+
      800. 3                return validatorCheck(col).isAlphanumeric();
        801. 
+
      801.              }, merge({message:"{col} must be a alphanumeric got {val}"}, opts));
        802. 
 
      802.          },
        803. 
 
      803.  
        804. 
-
      804.          /**
        805. 
-
      805.           * @see patio.Dataset#group
        806. 
-
      806.           */
        807. 
-
      807.          groupBy: function () {
        808. 
-
      808. 10            return this.group.apply(this, arguments);
        809. 
+
      809.          hasLength:function hasLength(min, max, opts) {
        810. 
+
      810. 2            return this.__addAction(function (col) {
        811. 
+
      811. 6                return validatorCheck(col).len(min, max);
        812. 
+
      812.              }, merge({message:"{col} must have a length between " + min + (max ? " and " + max : "") + "."}, opts));
        813. 
 
      813.          },
        814. 
 
      814.  
        815. 
+
      815.          isLowercase:function isLowercase(opts) {
        816. 
+
      816. 1            return this.__addAction(function (col) {
        817. 
+
      817. 3                return validatorCheck(col).isLowercase();
        818. 
+
      818.              }, merge({message:"{col} must be lowercase got {val}."}, opts));
        819. 
+
      819.          },
        820. 
 
      820.  
        821. 
-
      821.          /**
        822. 
-
      822.           * Returns a dataset grouped by the given column with count by group.
        823. 
-
      823.           * Column aliases may be supplied, and will be included in the select clause.
        824. 
-
      824.           *
        825. 
-
      825.           * @example
        826. 
-
      826.           *
        827. 
-
      827.           * DB.from("items").groupAndCount("name").all()
        828. 
-
      828.           *      //=> SELECT name, count(*) AS count FROM items GROUP BY name
        829. 
-
      829.           *      //=> [{name : 'a', count : 1}, ...]
        830. 
-
      830.           *
        831. 
-
      831.           * DB.from("items").groupAndCount("first_name", "last_name").all()
        832. 
-
      832.           *      //SELECT first_name, last_name, count(*) AS count FROM items GROUP BY first_name, last_name
        833. 
-
      833.           *      //=> [{first_name : 'a', last_name : 'b', count : 1}, ...]
        834. 
-
      834.           *
        835. 
-
      835.           * DB.from("items").groupAndCount("first_name___name").all()
        836. 
-
      836.           *      //=> SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
        837. 
-
      837.           *      //=> [{name : 'a', count:1}, ...]
        838. 
-
      838.           * @param {String...|patio.sql.Identifier...} columns columns to croup and count on.
        839. 
-
      839.           *
        840. 
-
      840.           * @return {patio.Dataset} a cloned dataset with the GROUP clause and count added.
        841. 
-
      841.           */
        842. 
-
      842.          groupAndCount: function (columns) {
        843. 
-
      843. 8            columns = argsToArray(arguments);
        844. 
-
      844. 8            var group = this.group.apply(this, columns.map(function (c) {
        845. 
-
      845. 9                return this._unaliasedIdentifier(c);
        846. 
-
      846.              }, this));
        847. 
-
      847. 8            return group.select.apply(group, columns.concat([this._static.COUNT_OF_ALL_AS_COUNT]));
        848. 
-
      848.  
        849. 
+
      849.          isUppercase:function isUppercase(opts) {
        850. 
+
      850. 1            return this.__addAction(function (col) {
        851. 
+
      851. 3                return validatorCheck(col).isUppercase();
        852. 
+
      852.              }, merge({message:"{col} must be uppercase got {val}."}, opts));
        853. 
 
      853.          },
        854. 
 
      854.  
        855. 
-
      855.          /**
        856. 
-
      856.           * Returns a copy of the dataset with the HAVING conditions changed. See {@link patio.Dataset#filter} for argument types.
        857. 
-
      857.           *
        858. 
-
      858.           * @example
        859. 
-
      859.           * DB.from("items").group("sum").having({sum : 10}).sql;
        860. 
-
      860.           *      //=> SELECT * FROM items GROUP BY sum HAVING (sum = 10)
        861. 
-
      861.           *
        862. 
-
      862.           * @return {patio.Dataset} a cloned dataset with HAVING clause changed or added.
        863. 
-
      863.           **/
        864. 
-
      864.          having: function () {
        865. 
-
      865. 12            var cond = argsToArray(arguments).map(function (s) {
        866. 
-
      866. 12                return isString(s) && s !== '' ? this.stringToIdentifier(s) : s
        867. 
-
      867.              }, this);
        868. 
-
      868. 12            return this._filter.apply(this, ["having"].concat(cond));
        869. 
+
      869.          isEmpty:function isEmpty(opts) {
        870. 
+
      870. 1            return this.__addAction(function (col) {
        871. 
+
      871. 3                try {
        872. 
+
      872. 3                    validatorCheck(col).notEmpty();
        873. 
+
      873. 2                    return false;
        874. 
+
      874.                  } catch (e) {
        875. 
+
      875. 1                    return true;
        876. 
+
      876.                  }
        877. 
+
      877.              }, merge({message:"{col} must be empty got {val}."}, opts));
        878. 
 
      878.          },
        879. 
 
      879.  
        880. 
-
      880.          /**
        881. 
-
      881.           * Adds an INTERSECT clause using a second dataset object.
        882. 
-
      882.           * An INTERSECT compound dataset returns all rows in both the current dataset
        883. 
-
      883.           * and the given dataset.
        884. 
-
      884.           *
        885. 
-
      885.           * @example
        886. 
-
      886.           *
        887. 
-
      887.           * DB.from("items").intersect(DB.from("other_items")).sql;
        888. 
-
      888.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS t1
        889. 
-
      889.           *
        890. 
-
      890.           * DB.from("items").intersect(DB.from("other_items"), {all : true, fromSelf : false}).sql;
        891. 
-
      891.           *   //=> SELECT * FROM items INTERSECT ALL SELECT * FROM other_items
        892. 
-
      892.           *
        893. 
-
      893.           * DB.from("items").intersect(DB.from("other_items"), {alias : "i"}).sql;
        894. 
-
      894.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS i
        895. 
-
      895.           *
        896. 
-
      896.           * @throws {patio.QueryError} if the operation is not supported.
        897. 
-
      897.           * @param  {patio.Dataset} dataset the dataset to intersect
        898. 
-
      898.           * @param  {Object} [opts] options
        899. 
-
      899.           * @param {String|patio.sql.Identifier} [opts.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias
        900. 
-
      900.           * @param {Boolean} [opts.all] Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
        901. 
-
      901.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}.
        902. 
-
      902.           *
        903. 
-
      903.           * @return {patio.Dataset} a cloned dataset with the INTERSECT clause.
        904. 
-
      904.           **/
        905. 
-
      905.          intersect: function (dataset, opts) {
        906. 
-
      906. 18            opts = isUndefined(opts) ? {} : opts;
        907. 
-
      907. 18            if (!isHash(opts)) {
        908. 
-
      908. 5                opts = {all: opts};
        909. 
-
      909.              }
        910. 
-
      910. 18            if (!this.supportsIntersectExcept) {
        911. 
-
      911. 2                throw new QueryError("INTERSECT not supported");
        912. 
-
      912. 16            } else if (opts.all && !this.supportsIntersectExceptAll) {
        913. 
-
      913. 1                throw new QueryError("INTERSECT ALL not supported");
        914. 
-
      914.              }
        915. 
-
      915. 15            return this.compoundClone("intersect", dataset, opts);
        916. 
+
      916.          isNotEmpty:function isNotEmpty(opts) {
        917. 
+
      917. 2            return this.__addAction(function (col) {
        918. 
+
      918. 11                return validatorCheck(col).notEmpty();
        919. 
+
      919.              }, merge({message:"{col} must not be empty."}, opts));
        920. 
 
      920.          },
        921. 
 
      921.  
        922. 
-
      922.          /**
        923. 
-
      923.           * Inverts the current filter.
        924. 
-
      924.           *
        925. 
-
      925.           * @example
        926. 
-
      926.           * DB.from("items").filter({category : 'software'}).invert()
        927. 
-
      927.           *      //=> SELECT * FROM items WHERE (category != 'software')
        928. 
-
      928.           *
        929. 
-
      929.           * @example
        930. 
-
      930.           * DB.from("items").filter({category : 'software', id : 3}).invert()
        931. 
-
      931.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
        932. 
-
      932.           *
        933. 
-
      933.           * @return {patio.Dataset} a cloned dataset with the filter inverted.
        934. 
-
      934.           **/
        935. 
-
      935.          invert: function () {
        936. 
-
      936. 3            var having = this.__opts.having, where = this.__opts.where;
        937. 
-
      937. 3            if (!(having || where)) {
        938. 
-
      938. 1                throw new QueryError("No current filter");
        939. 
-
      939.              }
        940. 
-
      940. 2            var o = {}
        941. 
-
      941. 2            if (having) {
        942. 
-
      942. 1                o.having = BooleanExpression.invert(having);
        943. 
-
      943.              }
        944. 
-
      944. 2            if (where) {
        945. 
-
      945. 2                o.where = BooleanExpression.invert(where);
        946. 
-
      946.              }
        947. 
-
      947. 2            return this.mergeOptions(o);
        948. 
+
      948.          isCreditCard:function isCreditCard(opts) {
        949. 
+
      949. 0            return this.__addAction(function (col) {
        950. 
+
      950. 0                return validatorCheck(col).isCreditCard();
        951. 
+
      951.              }, merge({message:"{col} is an invalid credit card"}, opts));
        952. 
 
      952.          },
        953. 
 
      953.  
        954. 
-
      954.          /**
        955. 
-
      955.           * Returns a cloned dataset with an inner join applied.
        956. 
-
      956.           *
        957. 
-
      957.           * @see patio.Dataset#joinTable
        958. 
-
      958.           */
        959. 
-
      959.          join: function () {
        960. 
-
      960. 212            return this.innerJoin.apply(this, arguments);
        961. 
+
      961.          check:function (fun, opts) {
        962. 
+
      962. 4            return this.__addAction(fun, opts);
        963. 
 
      963.          },
        964. 
 
      964.  
        965. 
+
      965.          validate:function validate(value) {
        966. 
+
      966. 218            var errOpts = {col:this.col, val:value};
        967. 
+
      967. 218            return compact(this.__actions.map(function (action) {
        968. 
+
      968. 248                var actionOpts = action.opts;
        969. 
+
      969. 248                if (!actionOpts.onlyDefined || (combIsDefined(value) &&
        970. 
+
      970.                      (!actionOpts.onlyNotNull || !combIsNull(value)) )) {
        971. 
+
      971. 186                    var ret = null;
        972. 
+
      972. 186                    try {
        973. 
+
      973. 186                        if (!action.action(value)) {
        974. 
+
      974. 69                            ret = format(actionOpts.message, errOpts);
        975. 
+
      975.                          }
        976. 
+
      976.                      } catch (e) {
        977. 
+
      977. 28                        ret = format(actionOpts.message, errOpts);
        978. 
+
      978.                      }
        979. 
+
      979. 186                    return ret;
        980. 
+
      980.                  }
        981. 
+
      981.              }, this));
        982. 
+
      982.          }
        983. 
+
      983.  
        984. 
+
      984.      }
        985. 
+
      985.  });
        986. 
+
      986.  
        987. 
+
      987. 1function shouldValidate(opts, def) {
        988. 
+
      988. 115    opts = opts || {};
        989. 
+
      989. 115    return combIsBoolean(opts.validate) ? opts.validate : def;
        990. 
+
      990.  }
        991. 
+
      991.  
        992. 
+
      992. 1function validateHook(prop, next, opts) {
        993. 
+
      993. 115    if (shouldValidate(opts, prop) && !this.isValid()) {
        994. 
+
      994. 45        next(flatten(toArray(this.errors).map(function (entry) {
        995. 
+
      995. 64            return entry[1].map(function (err) {
        996. 
+
      996. 48                return new Error(err);
        997. 
+
      997.              });
        998. 
+
      998.          })));
        999. 
+
      999.      } else {
        1000. 
+
      1000. 70        next();
        1001. 
+
      1001.      }
        1002. 
+
      1002.  }
        1003. 
+
      1003.  
        1004. 
+
      1004. 1define(null, {
        1005. 
+
      1005.  
        1006. 
+
      1006.      instance:{
        1007. 
+
      1007.  
        1008. 
 
      1008.          /**
        1009. 
-
      1009.           * Returns a joined dataset.  Uses the following arguments:
        1010. 
+
      1010.           * A validation plugin for patio models. This plugin adds a <code>validate</code> method to each {@link patio.Model}
        1011. 
+
      1011.           * class that adds it as a plugin. This plugin does not include most typecast checks as <code>patio</code> already checks
        1012. 
+
      1012.           * types upon column assignment.
        1013. 
 
      1013.           *
        1014. 
-
      1014.           * @example
        1015. 
+
      1015.           * To do single col validation
        1016. 
+
      1016.           * {@code
        1017. 
 
      1017.           *
        1018. 
-
      1018.           * DB.from("items").joinTable("leftOuter", "categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
        1019. 
-
      1019.           *      //=>'SELECT
        1020. 
-
      1020.           *             *
        1021. 
-
      1021.           *            FROM
        1022. 
-
      1022.           *              `items`
        1023. 
-
      1023.           *                  LEFT OUTER JOIN
        1024. 
-
      1024.           *              `categories` ON (
        1025. 
-
      1025.           *                          (`categories`.`categoryId` = `items`.`id`)
        1026. 
-
      1026.           *                              AND
        1027. 
-
      1027.           *                          (`categories`.`categoryId` IN (1,2, 3))
        1028. 
-
      1028.           *                          )
        1029. 
-
      1029.           * DB.from("items").leftOuter("categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
        1030. 
-
      1030.           *      //=>'SELECT
        1031. 
-
      1031.           *             *
        1032. 
-
      1032.           *            FROM
        1033. 
-
      1033.           *              `items`
        1034. 
-
      1034.           *                  LEFT OUTER JOIN
        1035. 
-
      1035.           *              `categories` ON (
        1036. 
-
      1036.           *                          (`categories`.`categoryId` = `items`.`id`)
        1037. 
-
      1037.           *                              AND
        1038. 
-
      1038.           *                          (`categories`.`categoryId` IN (1,2, 3))
        1039. 
-
      1039.           *                          )
        1040. 
+
      1040.           * var Model = patio.addModel("validator", {
        1041. 
+
      1041.           *      plugins:[ValidatorPlugin]
        1042. 
+
      1042.           * });
        1043. 
+
      1043.           * //this ensures column assignment
        1044. 
+
      1044.           * Model.validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
        1045. 
+
      1045.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
        1046. 
+
      1046.           * Model.validate("col2").like(/hello/ig);
        1047. 
+
      1047.           * //Ensures that the emailAddress column is a valid email address.
        1048. 
+
      1048.           * Model.validate("emailAddress").isEmailAddress();
        1049. 
+
      1049.           * }
        1050. 
+
      1050.           *
        1051. 
+
      1051.           * Or you can do a mass validation through a callback.
        1052. 
+
      1052.           * {@code
        1053. 
 
      1053.           *
        1054. 
-
      1054.           * DB.from("items").leftOuterJoin("categories", {categoryId:"id"}).sql
        1055. 
-
      1055.           *          //=> SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1056. 
+
      1056.           * var Model = patio.addModel("validator", {
        1057. 
+
      1057.           *      plugins:[ValidatorPlugin]
        1058. 
+
      1058.           * });
        1059. 
+
      1059.           * Model.validate(function(validate){
        1060. 
+
      1060.           *      //this ensures column assignment
        1061. 
+
      1061.           *      validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
        1062. 
+
      1062.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
        1063. 
+
      1063.           *      validate("col2").isLike(/hello/ig);
        1064. 
+
      1064.           *      //Ensures that the emailAddress column is a valid email address.
        1065. 
+
      1065.           *      validate("emailAddress").isEmail();
        1066. 
+
      1066.           * });
        1067. 
+
      1067.           * }
        1068. 
 
      1068.           *
        1069. 
-
      1069.           * DB.from("items").rightOuterJoin("categories", {categoryId:"id"}).sql
        1070. 
-
      1070.           *          //=> SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1071. 
+
      1071.           * To check if a {@link patio.Model} is valid you can run the <code>isValid</code> method.
        1072. 
 
      1072.           *
        1073. 
-
      1073.           * DB.from("items").fullOuterJoin("categories", {categoryId:"id"}).sql
        1074. 
-
      1074.           *          //=> SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1075. 
+
      1075.           * {@code
        1076. 
+
      1076.           * var model1 = new Model({col2 : 'grape', emailAddress : "test"}),
        1077. 
+
      1077.           *     model2 = new Model({col1 : "grape", col2 : "hello", emailAddress : "test@test.com"});
        1078. 
 
      1078.           *
        1079. 
-
      1079.           * DB.from("items").innerJoin("categories", {categoryId:"id"}).sql
        1080. 
-
      1080.           *          //=> SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1081. 
+
      1081.           * model1.isValid() //false
        1082. 
+
      1082.           * model2.isValid() //true
        1083. 
+
      1083.           * }
        1084. 
 
      1084.           *
        1085. 
-
      1085.           * DB.from("items").leftJoin("categories", {categoryId:"id"}).sql
        1086. 
-
      1086.           *          //=> SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1087. 
+
      1087.           * To get the errors associated with an invalid model you can access the errors property
        1088. 
 
      1088.           *
        1089. 
-
      1089.           * DB.from("items").rightJoin("categories", {categoryId:"id"}).sql
        1090. 
-
      1090.           *          //=> SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1091. 
+
      1091.           * {@code
        1092. 
+
      1092.           * model1.errors; //{ col1: [ 'col1 must be defined.' ],
        1093. 
+
      1093.           *                //  col2: [ 'col2 must be like /hello/gi got grape.' ],
        1094. 
+
      1094.           *                //  emailAddress: [ 'emailAddress must be a valid Email Address got test' ] }
        1095. 
+
      1095.           * }
        1096. 
 
      1096.           *
        1097. 
-
      1097.           * DB.from("items").fullJoin("categories", {categoryId:"id"}).sql
        1098. 
-
      1098.           *          //=> SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."categoryId" = "items"."id")
        1099. 
+
      1099.           * Validation is also run pre save and pre update. To prevent this you can specify the <code>validate</code> option
        1100. 
 
      1100.           *
        1101. 
-
      1101.           * DB.from("items").naturalJoin("categories").sql
        1102. 
-
      1102.           *          //=> SELECT * FROM "items" NATURAL JOIN "categories"
        1103. 
+
      1103.           * {@code
        1104. 
+
      1104.           * model1.save(null, {validate : false});
        1105. 
+
      1105.           * model2.save(null, {validate : false});
        1106. 
+
      1106.           * }
        1107. 
 
      1107.           *
        1108. 
-
      1108.           * DB.from("items").naturalLeftJoin("categories").sql
        1109. 
-
      1109.           *          //=> SELECT * FROM "items" NATURAL LEFT JOIN "categories"
        1110. 
+
      1110.           * Or you can specify the class level properties <code>validateOnSave</code> and <code>validateOnUpdate</code>
        1111. 
+
      1111.           * to false respectively
        1112. 
+
      1112.           * {@code
        1113. 
+
      1113.           * Model.validateOnSave = false;
        1114. 
+
      1114.           * Model.validateOnUpdate = false;
        1115. 
+
      1115.           * }
        1116. 
 
      1116.           *
        1117. 
-
      1117.           * DB.from("items").naturalRightJoin("categories").sql
        1118. 
-
      1118.           *          //=> SELECT * FROM "items" NATURAL RIGHT JOIN "categories"
        1119. 
+
      1119.           * Avaiable validation methods are.
        1120. 
 
      1120.           *
        1121. 
-
      1121.           * DB.from("items").naturalFullJoin("categories").sql
        1122. 
-
      1122.           *          //=> SELECT * FROM "items" NATURAL FULL JOIN "categories"'
        1123. 
+
      1123.           * <ul>
        1124. 
+
      1124.           *  <li><code>isAfter</code> : check that a date is after a specified date</li>
        1125. 
+
      1125.           *  <li><code>isBefore</code> : check that a date is after before a specified date </li>
        1126. 
+
      1126.           *  <li><code>isDefined</code> : ensure that a column is defined</li>
        1127. 
+
      1127.           *  <li><code>isNotDefined</code> : ensure that a column is not defined</li>
        1128. 
+
      1128.           *  <li><code>isNotNull</code> : ensure that a column is defined and not null</li>
        1129. 
+
      1129.           *  <li><code>isNull</code> : ensure that a column is not defined or null</li>
        1130. 
+
      1130.           *  <li><code>isEq</code> : ensure that a column equals a value <b>this uses deep equal</b></li>
        1131. 
+
      1131.           *  <li><code>isNeq</code> : ensure that a column does not equal a value <b>this uses deep equal</b></li>
        1132. 
+
      1132.           *  <li><code>isLike</code> : ensure that a column is like a value, can be a regexp or string</li>
        1133. 
+
      1133.           *  <li><code>isNotLike</code> : ensure that a column is not like a value, can be a regexp or string</li>
        1134. 
+
      1134.           *  <li><code>isLt</code> : ensure that a column is less than a value</li>
        1135. 
+
      1135.           *  <li><code>isGt</code> : ensure that a column is greater than a value</li>
        1136. 
+
      1136.           *  <li><code>isLte</code> : ensure that a column is less than or equal to a value</li>
        1137. 
+
      1137.           *  <li><code>isGte</code> : ensure that a column is greater than or equal to a value</li>
        1138. 
+
      1138.           *  <li><code>isIn</code> : ensure that a column is contained in an array of values</li>
        1139. 
+
      1139.           *  <li><code>isNotIn</code> : ensure that a column is not contained in an array of values</li>
        1140. 
+
      1140.           *  <li><code>isMacAddress</code> : ensure that a column is a valid MAC address</li>
        1141. 
+
      1141.           *  <li><code>isIPAddress</code> : ensure that a column is a valid IPv4 or IPv6 address</li>
        1142. 
+
      1142.           *  <li><code>isIPv4Address</code> : ensure that a column is a valid IPv4 address</li>
        1143. 
+
      1143.           *  <li><code>isIPv6Address</code> : ensure that a column is a valid IPv6 address</li>
        1144. 
+
      1144.           *  <li><code>isUUID</code> : ensure that a column is a valid UUID</li>
        1145. 
+
      1145.           *  <li><code>isEmail</code> : ensure that a column is a valid email address</li>
        1146. 
+
      1146.           *  <li><code>isUrl</code> : ensure than a column is a valid URL</li>
        1147. 
+
      1147.           *  <li><code>isAlpha</code> : ensure than a column is all letters</li>
        1148. 
+
      1148.           *  <li><code>isAlphaNumeric</code> : ensure than a column is all letters or numbers</li>
        1149. 
+
      1149.           *  <li><code>hasLength</code> : ensure than a column is fits within the specified length accepts a min and optional max value</li>
        1150. 
+
      1150.           *  <li><code>isLowercase</code> : ensure than a column is lowercase</li>
        1151. 
+
      1151.           *  <li><code>isUppercase</code> : ensure than a column is uppercase</li>
        1152. 
+
      1152.           *  <li><code>isEmpty</code> : ensure than a column empty (i.e. a blank string)</li>
        1153. 
+
      1153.           *  <li><code>isNotEmpty</code> : ensure than a column not empty (i.e. not a blank string)</li>
        1154. 
+
      1154.           *  <li><code>isCreditCard</code> : ensure than a is a valid credit card number</li>
        1155. 
+
      1155.           *  <li><code>check</code> : accepts a function to perform validation</li>
        1156. 
+
      1156.           * </ul>
        1157. 
 
      1157.           *
        1158. 
-
      1158.           * DB.from("items").crossJoin("categories").sql
        1159. 
-
      1159.           *          //=> SELECT * FROM "items" CROSS JOIN "categories"
        1160. 
+
      1160.           * All of the validation methods are chainable, and accept an options argument.
        1161. 
 
      1161.           *
        1162. 
-
      1162.           * @param {String} type the type of join to do.
        1163. 
-
      1163.           * @param {String|patio.sql.Identifier|patio.Dataset|Object} table depends on the type.
        1164. 
-
      1164.           *  <ul>
        1165. 
-
      1165.           *      <li>{@link patio.Dataset} - a subselect is performed with an alias</li>
        1166. 
-
      1166.           *      <li>Object - an object that has a tableName property.</li>
        1167. 
-
      1167.           *      <li>String|{@link patio.sql.Identifier}  - the name of the table</li>
        1168. 
-
      1168.           *  </ul>
        1169. 
-
      1169.           * @param [expr] - depends on type
        1170. 
+
      1170.           * The options include
        1171. 
 
      1171.           * <ul>
        1172. 
-
      1172.           *     <li>Object|Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already
        1173. 
-
      1173.           *     qualified), and value (2nd arg) is column of the last joined or primary table (or the
        1174. 
-
      1174.           *     implicitQualifier option</li>.
        1175. 
-
      1175.           *     <li>Array - If all members of the array are string or {@link patio.sql.Identifier}, considers
        1176. 
-
      1176.           *     them as columns and uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
        1177. 
-
      1177.           *     the result set if this is used.</li>
        1178. 
-
      1178.           *     <li>null|undefined(not passed in) - If a cb is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
        1179. 
-
      1179.           *     or CROSS join. If a block is given, uses an ON clause based on the block, see below.</li>
        1180. 
-
      1180.           *     <li>Everything else - pretty much the same as a using the argument in a call to {@link patio.Dataset#filter},
        1181. 
-
      1181.           *     so strings are considered literal, {@link patio.sql.Identifiers} specify boolean columns, and patio.sql
        1182. 
-
      1182.           *      expressions can be used. Uses a JOIN with an ON clause.</li>
        1183. 
+
      1183.           *     <li><code>message</code> : a message to return if a column fails validation. The message can include <code>{val}</code> and <code>{col}</code>
        1184. 
+
      1184.           *     replacements which will insert the invalid value and the column name.
        1185. 
+
      1185.           *     </li>
        1186. 
+
      1186.           *     <li><code>[onlyDefined=true]</code> : set to false to run the method even if the column value is not defined.</li>
        1187. 
+
      1187.           *     <li><code>[onlyNotNull=true]</code> : set to false to run the method even if the column value is null.</li>
        1188. 
 
      1188.           * </ul>
        1189. 
-
      1189.           * @param {Object} options an object of options.
        1190. 
-
      1190.           * @param {String|patio.sql.Identifier} [options.tableAlias=undefined] the name of the table's alias when joining, necessary for joining
        1191. 
-
      1191.           *     to the same table more than once.  No alias is used by default.
        1192. 
-
      1192.           * @param {String|patio.sql.Identifier} [options.implicitQualifier=undefined] The name to use for qualifying implicit conditions.  By default,
        1193. 
-
      1193.           *     the last joined or primary table is used.
        1194. 
-
      1194.           * @param {Function} [cb]  cb - The cb argument should only be given if a JOIN with an ON clause is used,
        1195. 
-
      1195.           *   in which case it is called with
        1196. 
-
      1196.           *   <ul>
        1197. 
-
      1197.           *       <li>table alias/name for the table currently being joined</li>
        1198. 
-
      1198.           *       <li> the table alias/name for the last joined (or first table)
        1199. 
-
      1199.           *       <li>array of previous</li>
        1200. 
-
      1200.           *   </ul>
        1201. 
-
      1201.           *   the cb should return an expression to be used in the ON clause.
        1202. 
 
      1202.           *
        1203. 
-
      1203.           * @return {patio.Dataset} a cloned dataset joined using the arguments.
        1204. 
+
      1204.           *
        1205. 
+
      1205.           * @constructs
        1206. 
+
      1206.           * @name ValidatorPlugin
        1207. 
+
      1207.           * @memberOf patio.plugins
        1208. 
+
      1208.           * @property {Object} [errors={}] the validation errors for this model.
        1209. 
+
      1209.           *
        1210. 
 
      1210.           */
        1211. 
+
      1211.          constructor:function () {
        1212. 
+
      1212. 114            this._super(arguments);
        1213. 
+
      1213. 114            this.errors = {};
        1214. 
+
      1214.          },
        1215. 
 
      1215.  
        1216. 
-
      1216.          joinTable: function (type, table, expr, options, cb) {
        1217. 
-
      1217. 634            var args = argsToArray(arguments);
        1218. 
-
      1218. 634            if (isFunction(args[args.length - 1])) {
        1219. 
-
      1219. 12                cb = args[args.length - 1];
        1220. 
-
      1220. 12                args.pop();
        1221. 
-
      1221.              } else {
        1222. 
-
      1222. 622                cb = null;
        1223. 
-
      1223.              }
        1224. 
-
      1224. 634            type = args.shift(), table = args.shift(), expr = args.shift(), options = args.shift();
        1225. 
-
      1225. 634            expr = isUndefined(expr) ? null : expr, options = isUndefined(options) ? {} : options;
        1226. 
+
      1226.          /**
        1227. 
+
      1227.           * Validates a model, returning an array of error messages for each invalid property.
        1228. 
+
      1228.           * @return {String[]} an array of error messages for each invalid property.
        1229. 
+
      1229.           */
        1230. 
+
      1230.          validate:function () {
        1231. 
+
      1231. 159            this.errors = {};
        1232. 
+
      1232. 159            return flatten(this._static.validators.map(function runValidator(validator) {
        1233. 
+
      1233. 218                var col = validator.col, val = this.__values[validator.col], ret = validator.validate(val);
        1234. 
+
      1234. 218                this.errors[col] = ret;
        1235. 
+
      1235. 218                return ret;
        1236. 
+
      1236.              }, this));
        1237. 
+
      1237.          },
        1238. 
 
      1238.  
        1239. 
-
      1239. 634            var h;
        1240. 
-
      1240. 634            var usingJoin = isArray(expr) && expr.length && expr.every(function (x) {
        1241. 
-
      1241. 223                return isString(x) || isInstanceOf(x, Identifier)
        1242. 
-
      1242.              });
        1243. 
-
      1243. 634            if (usingJoin && !this.supportsJoinUsing) {
        1244. 
-
      1244. 1                h = {};
        1245. 
-
      1245. 1                expr.forEach(function (s) {
        1246. 
-
      1246. 1                    h[s] = s;
        1247. 
-
      1247.                  });
        1248. 
-
      1248. 1                return this.joinTable(type, table, h, options);
        1249. 
-
      1249.              }
        1250. 
-
      1250. 633            var tableAlias, lastAlias;
        1251. 
-
      1251. 633            if (isHash(options)) {
        1252. 
-
      1252. 623                tableAlias = options.tableAlias;
        1253. 
-
      1253. 623                lastAlias = options.implicitQualifier;
        1254. 
-
      1254. 10            } else if (isString(options) || isInstanceOf(options, Identifier)) {
        1255. 
-
      1255. 9                tableAlias = options;
        1256. 
-
      1256. 9                lastAlias = null;
        1257. 
-
      1257.              } else {
        1258. 
-
      1258. 1                throw new QueryError("Invalid options format for joinTable %j4", [options]);
        1259. 
-
      1259.              }
        1260. 
-
      1260. 632            var tableAliasNum, tableName;
        1261. 
-
      1261. 632            if (isInstanceOf(table, Dataset)) {
        1262. 
-
      1262. 11                if (!tableAlias) {
        1263. 
-
      1263. 6                    tableAliasNum = (this.__opts.numDatasetSources || 0) + 1;
        1264. 
-
      1264. 6                    tableAlias = this._datasetAlias(tableAliasNum);
        1265. 
-
      1265.                  }
        1266. 
-
      1266. 11                tableName = tableAlias;
        1267. 
-
      1267.              } else {
        1268. 
-
      1268. 621                if (!isUndefined(table.tableName)) {
        1269. 
-
      1269. 1                    table = table.tableName;
        1270. 
-
      1270.                  }
        1271. 
-
      1271. 621                if (isArray(table)) {
        1272. 
-
      1272. 2                    table = table.map(this.stringToIdentifier, this);
        1273. 
-
      1273.                  } else {
        1274. 
-
      1274. 619                    table = isString(table) ? this.stringToIdentifier(table) : table;
        1275. 
-
      1275. 619                    var parts = this._splitAlias(table), implicitTableAlias = parts[1];
        1276. 
-
      1276. 619                    table = parts[0]
        1277. 
-
      1277. 619                    tableAlias = tableAlias || implicitTableAlias;
        1278. 
-
      1278. 619                    tableName = tableAlias || table;
        1279. 
-
      1279.                  }
        1280. 
-
      1280.              }
        1281. 
-
      1281. 632            var join;
        1282. 
-
      1282. 632            if (!expr && !cb) {
        1283. 
-
      1283. 22                join = new JoinClause(type, table, tableAlias);
        1284. 
-
      1284. 610            } else if (usingJoin) {
        1285. 
-
      1285. 9                if (cb) {
        1286. 
-
      1286. 1                    throw new QueryError("cant use a cb if an array is given");
        1287. 
-
      1287.                  }
        1288. 
-
      1288. 8                join = new JoinUsingClause(expr, type, table, tableAlias);
        1289. 
-
      1289.              } else {
        1290. 
-
      1290. 601                lastAlias = lastAlias || this.__opts["lastJoinedTable"] || this.firstSourceAlias;
        1291. 
-
      1291. 600                if (Expression.isConditionSpecifier(expr)) {
        1292. 
-
      1292. 588                    var newExpr = [];
        1293. 
-
      1293. 588                    for (var i in expr) {
        1294. 
-
      1294. 909                        var val = expr[i];
        1295. 
-
      1295. 909                        if (isArray(val) && val.length == 2) {
        1296. 
-
      1296. 418                            i = val[0], val = val[1];
        1297. 
-
      1297.                          }
        1298. 
-
      1298. 909                        var k = this.qualifiedColumnName(i, tableName), v;
        1299. 
-
      1299. 909                        if (isInstanceOf(val, Identifier)) {
        1300. 
-
      1300. 405                            v = val.qualify(lastAlias);
        1301. 
-
      1301.                          } else {
        1302. 
-
      1302. 504                            v = val;
        1303. 
-
      1303.                          }
        1304. 
-
      1304. 909                        newExpr.push([k, v]);
        1305. 
-
      1305.                      }
        1306. 
-
      1306. 588                    expr = newExpr;
        1307. 
-
      1307.                  }
        1308. 
-
      1308. 600                if (isFunction(cb)) {
        1309. 
-
      1309. 11                    var expr2 = cb.apply(sql, [tableName, lastAlias, this.__opts.join || []]);
        1310. 
-
      1310. 11                    expr = expr ? new BooleanExpression("AND", expr, expr2) : expr2;
        1311. 
-
      1311.                  }
        1312. 
-
      1312. 600                join = new JoinOnClause(expr, type, table, tableAlias);
        1313. 
-
      1313.              }
        1314. 
-
      1314. 630            var opts = {join: (this.__opts.join || []).concat([join]), lastJoinedTable: tableName};
        1315. 
-
      1315. 630            if (tableAliasNum) {
        1316. 
-
      1316. 6                opts.numDatasetSources = tableAliasNum;
        1317. 
+
      1317.          /**
        1318. 
+
      1318.           * Returns if this model passes validation.
        1319. 
+
      1319.           *
        1320. 
+
      1320.           * @return {Boolean}
        1321. 
+
      1321.           */
        1322. 
+
      1322.          isValid:function () {
        1323. 
+
      1323. 159            return this.validate().length === 0;
        1324. 
+
      1324.          }
        1325. 
+
      1325.      },
        1326. 
+
      1326.  
        1327. 
+
      1327.      "static":{
        1328. 
+
      1328.          /**@lends patio.plugins.ValidatorPlugin*/
        1329. 
+
      1329.  
        1330. 
+
      1330.          /**
        1331. 
+
      1331.           * Set to false to prevent model validation when saving.
        1332. 
+
      1332.           * @default true
        1333. 
+
      1333.           */
        1334. 
+
      1334.          validateOnSave:true,
        1335. 
+
      1335.  
        1336. 
+
      1336.          /**
        1337. 
+
      1337.           * Set to false to prevent model validation when updating.
        1338. 
+
      1338.           * @default true
        1339. 
+
      1339.           */
        1340. 
+
      1340.          validateOnUpdate:true,
        1341. 
+
      1341.  
        1342. 
+
      1342.          init:function () {
        1343. 
+
      1343. 35            this._super(arguments);
        1344. 
+
      1344.          },
        1345. 
+
      1345.  
        1346. 
+
      1346.          __initValidation:function () {
        1347. 
+
      1347. 43            if (!this.__isValidationInited) {
        1348. 
+
      1348. 34                this.validators = [];
        1349. 
+
      1349. 34                this.pre("save", function preSaveValidate(next, opts) {
        1350. 
+
      1350. 114                    validateHook.call(this, this._static.validateOnSave, next, opts);
        1351. 
+
      1351.                  });
        1352. 
+
      1352. 34                this.pre("update", function preUpdateValidate(next, opts) {
        1353. 
+
      1353. 1                    validateHook.call(this, this._static.validateOnSave, next, opts);
        1354. 
+
      1354.                  });
        1355. 
+
      1355. 34                this.__isValidationInited = true;
        1356. 
 
      1356.              }
        1357. 
-
      1357. 630            return this.mergeOptions(opts);
        1358. 
+
      1358.          },
        1359. 
 
      1359.  
        1360. 
+
      1360.          __getValidator:function validator(name) {
        1361. 
+
      1361. 44            var ret = new Validator(name);
        1362. 
+
      1362. 44            this.validators.push(ret);
        1363. 
+
      1363. 44            return ret;
        1364. 
 
      1364.          },
        1365. 
 
      1365.  
        1366. 
 
      1366.          /**
        1367. 
-
      1367.           * If given an integer, the dataset will contain only the first l results.
        1368. 
-
      1368.           If a second argument is given, it is used as an offset. To use
        1369. 
-
      1369.           * an offset without a limit, pass null as the first argument.
        1370. 
+
      1370.           * Sets up validation for a model.
        1371. 
 
      1371.           *
        1372. 
-
      1372.           * @example
        1373. 
+
      1373.           * To do single col validation
        1374. 
+
      1374.           * {@code
        1375. 
 
      1375.           *
        1376. 
-
      1376.           * DB.from("items").limit(10)
        1377. 
-
      1377.           *      //=> SELECT * FROM items LIMIT 10
        1378. 
-
      1378.           * DB.from("items").limit(10, 20)
        1379. 
-
      1379.           *      //=> SELECT * FROM items LIMIT 10 OFFSET 20
        1380. 
-
      1380.           * DB.from("items").limit([3, 7]).sql
        1381. 
-
      1381.           *      //=> SELECT * FROM items LIMIT 5 OFFSET 3');
        1382. 
-
      1382.           * DB.from("items").limit(null, 20)
        1383. 
-
      1383.           *      //=> SELECT * FROM items OFFSET 20
        1384. 
+
      1384.           * var Model = patio.addModel("validator", {
        1385. 
+
      1385.           *      plugins:[ValidatorPlugin]
        1386. 
+
      1386.           * });
        1387. 
+
      1387.           * //this ensures column assignment
        1388. 
+
      1388.           * Model.validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
        1389. 
+
      1389.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
        1390. 
+
      1390.           * Model.validate("col2").like(/hello/ig);
        1391. 
+
      1391.           * //Ensures that the emailAddress column is a valid email address.
        1392. 
+
      1392.           * Model.validate("emailAddress").isEmailAddress();
        1393. 
+
      1393.           * }
        1394. 
 
      1394.           *
        1395. 
-
      1395.           * DB.from("items").limit('6', sql['a() - 1']).sql
        1396. 
-
      1396.           *      => 'SELECT * FROM items LIMIT 6 OFFSET a() - 1');
        1397. 
+
      1397.           * Or you can do a mass validation through a callback.
        1398. 
+
      1398.           * {@code
        1399. 
 
      1399.           *
        1400. 
-
      1400.           * @param {Number|String|Number[]} limit the limit to apply
        1401. 
-
      1401.           * @param {Number|String|patio.sql.LiteralString} offset the offset to apply
        1402. 
+
      1402.           * var Model = patio.addModel("validator", {
        1403. 
+
      1403.           *      plugins:[ValidatorPlugin]
        1404. 
+
      1404.           * });
        1405. 
+
      1405.           * Model.validate(function(validate){
        1406. 
+
      1406.           *      //this ensures column assignment
        1407. 
+
      1407.           *      validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
        1408. 
+
      1408.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
        1409. 
+
      1409.           *      validate("col2").isLike(/hello/ig);
        1410. 
+
      1410.           *      //Ensures that the emailAddress column is a valid email address.
        1411. 
+
      1411.           *      validate("emailAddress").isEmail();
        1412. 
+
      1412.           * });
        1413. 
+
      1413.           * }
        1414. 
 
      1414.           *
        1415. 
-
      1415.           * @return {patio.Dataset}  a cloned dataset witht the LIMIT and OFFSET applied.
        1416. 
-
      1416.           **/
        1417. 
-
      1417.          limit: function (limit, offset) {
        1418. 
-
      1418. 46            if (this.__opts.sql) {
        1419. 
-
      1419. 7                return this.fromSelf().limit(limit, offset);
        1420. 
-
      1420.              }
        1421. 
-
      1421. 39            if (isArray(limit) && limit.length == 2) {
        1422. 
-
      1422. 1                offset = limit[0];
        1423. 
-
      1423. 1                limit = limit[1] - limit[0] + 1;
        1424. 
-
      1424.              }
        1425. 
-
      1425. 39            if (isString(limit) || isInstanceOf(limit, LiteralString)) {
        1426. 
-
      1426. 2                limit = parseInt("" + limit, 10);
        1427. 
-
      1427.              }
        1428. 
-
      1428. 39            if (isNumber(limit) && limit < 1) {
        1429. 
-
      1429. 2                throw new QueryError("Limit must be >= 1");
        1430. 
+
      1430.           *
        1431. 
+
      1431.           * @param {String|Function} name the name of the column, or a callback that accepts a function to create validators.
        1432. 
+
      1432.           *
        1433. 
+
      1433.           * @throws {patio.ModelError} if name is not a function or string.
        1434. 
+
      1434.           * @return {patio.Model|Validator} returns a validator if name is a string, other wise returns this for chaining.
        1435. 
+
      1435.           */
        1436. 
+
      1436.          validate:function (name) {
        1437. 
+
      1437. 43            this.__initValidation();
        1438. 
+
      1438. 43            var ret;
        1439. 
+
      1439. 43            if (isFunction(name)) {
        1440. 
+
      1440. 1                name.apply(this, [this.__getValidator.bind(this)]);
        1441. 
+
      1441. 1                ret = this;
        1442. 
+
      1442. 42            } else if (isString(name)) {
        1443. 
+
      1443. 42                ret = this.__getValidator(name);
        1444. 
+
      1444.              } else {
        1445. 
+
      1445. 0                throw new ModelError("name is must be a string or function when validating");
        1446. 
 
      1446.              }
        1447. 
-
      1447. 37            var opts = {limit: limit};
        1448. 
-
      1448. 37            if (offset) {
        1449. 
-
      1449. 9                if (isString(offset) || isInstanceOf(offset, LiteralString)) {
        1450. 
-
      1450. 1                    offset = parseInt("" + offset, 10);
        1451. 
-
      1451. 1                    isNaN(offset) && (offset = 0);
        1452. 
+
      1452. 43            return ret;
        1453. 
+
      1453.          }
        1454. 
+
      1454.      }
        1455. 
+
      1455.  
        1456. 
+
      1456.  }).as(module);
        1457. 
+
      1457.  
      
+
    + +
    + + + + + +
    +
    dataset/query.js
    +     		+
    + Coverage97.82 + SLOC2347 + LOC458 + Missed10 +
    +
    + 
    1. 1var comb = require("comb"),
      2. 
+
    2.      array = comb.array,
      3. 
+
    3.      flatten = array.flatten,
      4. 
+
    4.      compact = array.compact,
      5. 
+
    5.      define = comb.define,
      6. 
+
    6.      argsToArray = comb.argsToArray,
      7. 
+
    7.      isString = comb.isString,
      8. 
+
    8.      isEmpty = comb.isEmpty,
      9. 
+
    9.      isNull = comb.isNull,
      10. 
+
    10.      isBoolean = comb.isBoolean,
      11. 
+
    11.      isNumber = comb.isNumber,
      12. 
+
    12.      merge = comb.merge,
      13. 
+
    13.      isArray = comb.isArray,
      14. 
+
    14.      isObject = comb.isObject,
      15. 
+
    15.      isFunction = comb.isFunction,
      16. 
+
    16.      isUndefined = comb.isUndefined,
      17. 
+
    17.      isHash = comb.isHash,
      18. 
+
    18.      isInstanceOf = comb.isInstanceOf,
      19. 
+
    19.      sql = require("../sql").sql,
      20. 
+
    20.      LiteralString = sql.LiteralString,
      21. 
+
    21.      Expression = sql.Expression,
      22. 
+
    22.      ComplexExpression = sql.ComplexExpression,
      23. 
+
    23.      BooleanExpression = sql.BooleanExpression,
      24. 
+
    24.      PlaceHolderLiteralString = sql.PlaceHolderLiteralString,
      25. 
+
    25.      Identifier = sql.Identifier,
      26. 
+
    26.      QualifiedIdentifier = sql.QualifiedIdentifier,
      27. 
+
    27.      AliasedExpression = sql.AliasedExpression,
      28. 
+
    28.      StringExpression = sql.StringExpression,
      29. 
+
    29.      NumericExpression = sql.NumericExpression,
      30. 
+
    30.      OrderedExpression = sql.OrderedExpression,
      31. 
+
    31.      JoinClause = sql.JoinClause,
      32. 
+
    32.      JoinOnClause = sql.JoinOnClause,
      33. 
+
    33.      JoinUsingClause = sql.JoinUsingClause,
      34. 
+
    34.      ColumnAll = sql.ColumnAll,
      35. 
+
    35.      QueryError = require("../errors").QueryError;
      36. 
+
    36.  
      37. 
+
    37.  
      38. 
+
    38. 1var Dataset;
      39. 
+
    39.  
      40. 
+
    40. 1function conditionedJoin(type) {
      41. 
+
    41. 539    var args = argsToArray(arguments, 1);
      42. 
+
    42. 539    return this.joinTable.apply(this, [type].concat(args));
      43. 
+
    43.  }
      44. 
+
    44.  
      45. 
+
    45. 1function unConditionJoin(type, table) {
      46. 
+
    46. 6    var args = argsToArray(arguments, 1);
      47. 
+
    47. 6    return this.joinTable.apply(this, [type, table]);
      48. 
+
    48.  }
      49. 
+
    49.  
      50. 
+
    50.  
      51. 
+
    51. 1define(null, {
      52. 
+
    52.      /**@ignore*/
      53. 
+
    53.      instance: {
      54. 
+
    54.  
      55. 
+
    55.          /**@lends patio.Dataset.prototype*/
      56. 
+
    56.  
      57. 
+
    57.          /**
      58. 
+
    58.           * @ignore
      59. 
+
    59.           */
      60. 
+
    60.          constructor: function () {
      61. 
+
    61. 25745            !Dataset && (Dataset = require("../index").Dataset);
      62. 
+
    62. 25745            this._super(arguments);
      63. 
+
    63. 25745            this._static.CONDITIONED_JOIN_TYPES.forEach(function (type) {
      64. 
+
    64. 180215                if (!this[type + "Join"]) {
      65. 
+
    65. 180215                    this[type + "Join"] = conditionedJoin.bind(this, type);
      66. 
 
    66.                  }
      67. 
-
    67. 9                if (isNumber(offset) && offset < 0) {
      68. 
-
    68. 1                    throw new QueryError("Offset must be >= 0");
      69. 
+
    69.  
      70. 
+
    70.              }, this);
      71. 
+
    71. 25745            this._static.UNCONDITIONED_JOIN_TYPES.forEach(function (type) {
      72. 
+
    72. 128725                if (!this[type + "Join"]) {
      73. 
+
    73. 128725                    this[type + "Join"] = unConditionJoin.bind(this, type);
      74. 
 
    74.                  }
      75. 
-
    75. 8                opts.offset = offset;
      76. 
+
    76.  
      77. 
+
    77.              }, this);
      78. 
+
    78.          },
      79. 
+
    79.  
      80. 
+
    80.          /**
      81. 
+
    81.           * Adds a RETURNING clause, which is not supported by all databases. If returning is
      82. 
+
    82.           * used instead of returning the autogenerated primary key or update/delete returning the number of rows modified.
      83. 
+
    83.           *
      84. 
+
    84.           * @example
      85. 
+
    85.           *
      86. 
+
    86.           * ds.from("items").returning() //"RETURNING *"
      87. 
+
    87.           * ds.from("items").returning(null) //"RETURNING NULL"
      88. 
+
    88.           * ds.from("items").returning("id", "name") //"RETURNING id, name"
      89. 
+
    89.           * ds.from("items").returning(["id", "name"]) //"RETURNING id, name"
      90. 
+
    90.           *
      91. 
+
    91.           * @param values columns to return. If values is an array then the array is assumed to contain the columns to
      92. 
+
    92.           * return. Otherwise the arguments will be used.
      93. 
+
    93.           * @return {patio.Dataset} a new dataset with the retuning option added.
      94. 
+
    94.           */
      95. 
+
    95.          returning: function (values) {
      96. 
+
    96. 1087            var args;
      97. 
+
    97. 1087            if (Array.isArray(values)) {
      98. 
+
    98. 0                args = values;
      99. 
+
    99.              } else {
      100. 
+
    100. 1087                args = argsToArray(arguments);
      101. 
 
    101.              }
      102. 
-
    102. 36            return this.mergeOptions(opts);
      103. 
+
    103. 1087            return this.mergeOptions({returning: args.map(function (v) {
      104. 
+
    104. 1005                return isString(v) ? sql.stringToIdentifier(v) : v;
      105. 
+
    105.              })});
      106. 
 
    106.          },
      107. 
 
    107.  
      108. 
+
    108.  
      109. 
 
    109.          /**
      110. 
+
    110.           * Adds a further filter to an existing filter using AND. This method is identical to {@link patio.Dataset#filter}
      111. 
+
    111.           * except it expects an existing filter.
      112. 
 
    112.           *
      113. 
-
    113.           * Returns a cloned dataset with a not equal expression added to the WHERE
      114. 
-
    114.           * clause.
      115. 
+
    115.           * <p>
      116. 
+
    116.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      117. 
+
    117.           * </p>
      118. 
 
    118.           *
      119. 
 
    119.           * @example
      120. 
-
    120.           *  DB.from("test").neq({x : 1});
      121. 
-
    121.           *          //=> SELECT * FROM test WHERE (x != 1)
      122. 
-
    122.           *  DB.from("test").neq({x : 1, y : 10});
      123. 
-
    123.           *          //=> SELECT * FROM test WHERE ((x != 1) AND (y != 10))
      124. 
+
    124.           * DB.from("table").filter("a").and("b").sql;
      125. 
+
    125.           *      //=>SELECT * FROM table WHERE a AND b
      126. 
 
    126.           *
      127. 
-
    127.           * @param {Object} obj object used to create the not equal expression
      128. 
+
    128.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
      129. 
 
    129.           *
      130. 
-
    130.           * @return {patio.Dataset} a cloned dataset with the not equal expression added to the WHERE clause.
      131. 
+
    131.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
      132. 
 
    132.           */
      133. 
-
    133.          neq: function (obj) {
      134. 
-
    134. 2            return this.filter(this.__createBoolExpression("neq", obj));
      135. 
+
    135.          and: function () {
      136. 
+
    136. 7            var tOpts = this.__opts, clauseObj = tOpts[tOpts.having ? "having" : "where"];
      137. 
+
    137. 7            if (clauseObj) {
      138. 
+
    138. 6                return this.filter.apply(this, arguments);
      139. 
+
    139.              } else {
      140. 
+
    140. 1                throw new QueryError("No existing filter found");
      141. 
+
    141.              }
      142. 
+
    142.          },
      143. 
+
    143.  
      144. 
+
    144.          as: function (alias) {
      145. 
+
    145. 8            return new AliasedExpression(this, alias);
      146. 
 
    146.          },
      147. 
 
    147.  
      148. 
 
    148.          /**
      149. 
+
    149.           * Adds an alternate filter to an existing WHERE/HAVING using OR.
      150. 
 
    150.           *
      151. 
-
    151.           * Returns a cloned dataset with an equal expression added to the WHERE
      152. 
-
    152.           * clause.
      153. 
+
    153.           * <p>
      154. 
+
    154.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      155. 
+
    155.           * </p>
      156. 
 
    156.           *
      157. 
 
    157.           * @example
      158. 
-
    158.           *  DB.from("test").eq({x : 1});
      159. 
-
    159.           *          //=> SELECT * FROM test WHERE (x = 1)
      160. 
-
    160.           *  DB.from("test").eq({x : 1, y : 10});
      161. 
-
    161.           *          //=> SELECT * FROM test WHERE ((x = 1) AND (y = 10))
      162. 
 
    162.           *
      163. 
-
    163.           * @param {Object} obj object used to create the equal expression
      164. 
+
    164.           * DB.from("items").filter("a").or("b")
      165. 
+
    165.           *      //=> SELECT * FROM items WHERE a OR b
      166. 
 
    166.           *
      167. 
-
    167.           * @return {patio.Dataset} a cloned dataset with the equal expression added to the WHERE clause.
      168. 
+
    168.           * @throws {patio.QueryError} If no WHERE?HAVING clause exists.
      169. 
+
    169.           * @return {patio.Dataset} a cloned dataset with the condition added to the WHERE/HAVING clause added.
      170. 
 
    170.           */
      171. 
-
    171.          eq: function (obj) {
      172. 
-
    172. 2            return this.filter(this.__createBoolExpression("eq", obj));
      173. 
+
    173.          or: function () {
      174. 
+
    174. 10            var tOpts = this.__opts;
      175. 
+
    175. 10            var clause = (tOpts.having ? "having" : "where"), clauseObj = tOpts[clause];
      176. 
+
    176. 10            if (clauseObj) {
      177. 
+
    177. 9                var args = argsToArray(arguments);
      178. 
+
    178. 9                args = args.length == 1 ? args[0] : args;
      179. 
+
    179. 9                var opts = {};
      180. 
+
    180. 9                opts[clause] = new BooleanExpression("OR", clauseObj, this._filterExpr(args));
      181. 
+
    181. 9                return this.mergeOptions(opts);
      182. 
+
    182.              } else {
      183. 
+
    183. 1                throw new QueryError("No existing filter found");
      184. 
+
    184.              }
      185. 
 
    185.          },
      186. 
 
    186.  
      187. 
 
    187.          /**
      188. 
+
    188.           * Adds a group of ORed conditions wrapped in parens, connected to an existing where/having clause by an AND.
      189. 
+
    189.           * If the where/having clause doesn't yet exist, a where clause is created with the ORed group.
      190. 
 
    190.           *
      191. 
-
    191.           * Returns a cloned dataset with a greater than expression added to the WHERE
      192. 
-
    192.           * clause.
      193. 
+
    193.           * <p>
      194. 
+
    194.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      195. 
+
    195.           * </p>
      196. 
 
    196.           *
      197. 
 
    197.           * @example
      198. 
-
    198.           *  DB.from("test").gt({x : 1});
      199. 
-
    199.           *          //=> SELECT * FROM test WHERE (x > 1)
      200. 
-
    200.           *  DB.from("test").gt({x : 1, y : 10});
      201. 
-
    201.           *          //=> SELECT * FROM test WHERE ((x > 1) AND (y > 10))
      202. 
 
    202.           *
      203. 
-
    203.           * @param {Object} obj object used to create the greater than expression.
      204. 
+
    204.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      205. 
+
    205.           *      //=> SELECT
      206. 
+
    206.           *               *
      207. 
+
    207.           *           FROM
      208. 
+
    208.           *               items
      209. 
+
    209.           *           WHERE
      210. 
+
    210.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      211. 
 
    211.           *
      212. 
-
    212.           * @return {patio.Dataset} a cloned dataset with the greater than expression added to the WHERE clause.
      213. 
+
    213.           * DB.from("items").andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      214. 
+
    214.           *      //=> SELECT
      215. 
+
    215.           *               *
      216. 
+
    216.           *           FROM
      217. 
+
    217.           *               items
      218. 
+
    218.           *           WHERE
      219. 
+
    219.           *               ((price < 0) OR (price > 10))
      220. 
+
    220.           *
      221. 
+
    221.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
      222. 
 
    222.           */
      223. 
-
    223.          gt: function (obj) {
      224. 
-
    224. 2            return this.filter(this.__createBoolExpression("gt", obj));
      225. 
+
    225.          andGroupedOr: function (filterExp) {
      226. 
+
    226. 2            return this._addGroupedCondition("AND", "OR", filterExp);
      227. 
 
    227.          },
      228. 
 
    228.  
      229. 
 
    229.          /**
      230. 
+
    230.           * Adds a group of ANDed conditions wrapped in parens to an existing where/having clause by an AND. If there isn't
      231. 
+
    231.           * yet a clause, a where clause is created with the ANDed conditions
      232. 
 
    232.           *
      233. 
-
    233.           * Returns a cloned dataset with a less than expression added to the WHERE
      234. 
-
    234.           * clause.
      235. 
+
    235.           * <p>
      236. 
+
    236.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      237. 
+
    237.           * </p>
      238. 
 
    238.           *
      239. 
 
    239.           * @example
      240. 
-
    240.           *  DB.from("test").lt({x : 1});
      241. 
-
    241.           *          //=> SELECT * FROM test WHERE (x < 1)
      242. 
-
    242.           *  DB.from("test").lt({x : 1, y : 10});
      243. 
-
    243.           *          //=> SELECT * FROM test WHERE ((x < 1) AND (y < 10))
      244. 
 
    244.           *
      245. 
-
    245.           * @param {Object} obj object used to create the less than expression.
      246. 
+
    246.           * DB.from("items").filter({id, [1,2,3]}).andGroupedAnd([{price: {gt : 0}}, {price: {lt: 10}]).sql;
      247. 
+
    247.           *      //=> SELECT
      248. 
+
    248.           *               *
      249. 
+
    249.           *           FROM
      250. 
+
    250.           *               items
      251. 
+
    251.           *           WHERE
      252. 
+
    252.           *               ((id IN (1, 2, 3)) AND ((price > 0) AND (price < 10)))
      253. 
 
    253.           *
      254. 
-
    254.           * @return {patio.Dataset} a cloned dataset with the less than expression added to the WHERE clause.
      255. 
+
    255.           * DB.from("items").andGroupedAnd([{price: {gt : 0}}, {price: {lt: 10}]).sql;
      256. 
+
    256.           *      //=> SELECT
      257. 
+
    257.           *               *
      258. 
+
    258.           *           FROM
      259. 
+
    259.           *               items
      260. 
+
    260.           *           WHERE
      261. 
+
    261.           *               ((price > 0) AND (price < 10))
      262. 
+
    262.           *
      263. 
+
    263.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
      264. 
 
    264.           */
      265. 
-
    265.          lt: function (obj) {
      266. 
-
    266. 2            return this.filter(this.__createBoolExpression("lt", obj));
      267. 
+
    267.          andGroupedAnd: function (filterExp) {
      268. 
+
    268. 2            return this._addGroupedCondition("AND", "AND", filterExp);
      269. 
 
    269.          },
      270. 
 
    270.  
      271. 
 
    271.          /**
      272. 
-
    272.           * Returnes a cloned dataset with the IS NOT expression added to the WHERE
      273. 
-
    273.           * clause.
      274. 
+
    274.           * Adds a group of ANDed conditions wrapped in parens to an existing where/having clause by an OR. If there isn't
      275. 
+
    275.           * a where/having clause, a where clause is created with the ANDed conditions.
      276. 
 
    276.           *
      277. 
-
    277.           * @example
      278. 
+
    278.           * <p>
      279. 
+
    279.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      280. 
+
    280.           * </p>
      281. 
 
    281.           *
      282. 
-
    282.           * DB.from("test").isNot({boolFlag : null});
      283. 
-
    283.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      284. 
-
    284.           * DB.from("test").isNot({boolFlag : false, otherFlag : true, name : null});
      285. 
-
    285.           *      => SELECT * FROM test WHERE ((boolFlag IS NOT FALSE) AND (otherFlag IS NOT TRUE) AND (name IS NOT NULL));
      286. 
+
    286.           * @example
      287. 
 
    287.           *
      288. 
-
    288.           * @param {Object} obj object used to create the IS NOT expression for.
      289. 
+
    289.           * DB.from("items").filter({id, [1,2,3]}).orGroupedAnd([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      290. 
+
    290.           *      //=> SELECT
      291. 
+
    291.           *               *
      292. 
+
    292.           *           FROM
      293. 
+
    293.           *               items
      294. 
+
    294.           *           WHERE
      295. 
+
    295.           *               ((id IN (1, 2, 3)) OR ((price > 0) AND (price < 10)))
      296. 
 
    296.           *
      297. 
-
    297.           * @return {patio.Dataset} a cloned dataset with the IS NOT expression added to the WHERE clause.
      298. 
+
    298.           * DB.from("items").orGroupedAnd([{price: {gt : 0}}, {price: {gt: 10}]).sql;
      299. 
+
    299.           *      //=> SELECT
      300. 
+
    300.           *               *
      301. 
+
    301.           *           FROM
      302. 
+
    302.           *               items
      303. 
+
    303.           *           WHERE
      304. 
+
    304.           *               ((price > 0) AND (price < 10))
      305. 
 
    305.           *
      306. 
+
    306.           * @return {patio.Dataset} a cloned dataset with the condition 'and group' added to the WHERE/HAVING clause.
      307. 
 
    307.           */
      308. 
-
    308.          isNot: function (obj) {
      309. 
-
    309. 4            return this.filter(this.__createBoolExpression("isNot", obj));
      310. 
+
    310. 2        orGroupedAnd: function () {var tOpts = this.__opts,
      311. 
+
    311.              clause = (tOpts.having ? "having" : "where"),
      312. 
+
    312.              clauseObj = tOpts[clause];
      313. 
+
    313. 2            if (clauseObj) {
      314. 
+
    314. 1                return this.or.apply(this, arguments);
      315. 
+
    315.              } else {
      316. 
+
    316. 1                var args = argsToArray(arguments);
      317. 
+
    317. 1                args = args.length == 1 ? args[0] : args;
      318. 
+
    318. 1                var opts = {};
      319. 
+
    319. 1                opts[clause] = this._filterExpr(args, null, "AND");
      320. 
+
    320. 1                return this.mergeOptions(opts);
      321. 
+
    321.              }
      322. 
 
    322.          },
      323. 
 
    323.  
      324. 
 
    324.          /**
      325. 
-
    325.           * Returnes a cloned dataset with the IS expression added to the WHERE
      326. 
-
    326.           * clause.
      327. 
+
    327.           * Adds a group of ORed conditions wrapped in parens to an existing having/where clause with an OR. If there isn't
      328. 
+
    328.           * already a clause, a where clause is created with the ORed group.
      329. 
 
    329.           *
      330. 
-
    330.           * @example
      331. 
+
    331.           * <p>
      332. 
+
    332.           *     <b>For parameter types see {@link patio.Dataset#filter}.</b>
      333. 
+
    333.           * </p>
      334. 
 
    334.           *
      335. 
-
    335.           * DB.from("test").is({boolFlag : null});
      336. 
-
    336.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      337. 
-
    337.           * DB.from("test").is({boolFlag : false, otherFlag : true, name : null});
      338. 
-
    338.           *      => SELECT * FROM test WHERE ((boolFlag IS FALSE) AND (otherFlag IS TRUE) AND (name IS NULL));
      339. 
+
    339.           * @example
      340. 
 
    340.           *
      341. 
-
    341.           * @param {Object} obj object used to create the IS expression for.
      342. 
+
    342.           * DB.from("items").filter({id, [1,2,3]}).andGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      343. 
+
    343.           *      //=> SELECT
      344. 
+
    344.           *               *
      345. 
+
    345.           *           FROM
      346. 
+
    346.           *               items
      347. 
+
    347.           *           WHERE
      348. 
+
    348.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      349. 
 
    349.           *
      350. 
-
    350.           * @return {patio.Dataset} a cloned dataset with the IS expression added to the WHERE clause.
      351. 
+
    351.           * DB.from("items").orGroupedOr([{price: {lt : 0}}, {price: {gt: 10}]).sql;
      352. 
+
    352.           *      //=> SELECT
      353. 
+
    353.           *               *
      354. 
+
    354.           *           FROM
      355. 
+
    355.           *               items
      356. 
+
    356.           *           WHERE
      357. 
+
    357.           *               ((price < 0) OR (price > 10))
      358. 
 
    358.           *
      359. 
+
    359.           * @return {patio.Dataset} a cloned dataset with the condition 'or group' added to the WHERE/HAVING clause.
      360. 
 
    360.           */
      361. 
-
    361.          is: function (obj) {
      362. 
-
    362. 4            return this.filter(this.__createBoolExpression("is", obj));
      363. 
+
    363.          orGroupedOr: function (filterExp) {
      364. 
+
    364. 2            return this._addGroupedCondition("OR", "OR", filterExp);
      365. 
 
    365.          },
      366. 
 
    366.  
      367. 
 
    367.          /**
      368. 
-
    368.           * Returnes a cloned dataset with the IS NOT NULL boolean expression added to the WHERE
      369. 
-
    369.           * clause.
      370. 
+
    370.           * Returns a copy of the dataset with the SQL DISTINCT clause.
      371. 
+
    371.           * The DISTINCT clause is used to remove duplicate rows from the
      372. 
+
    372.           * output.  If arguments are provided, uses a DISTINCT ON clause,
      373. 
+
    373.           * in which case it will only be distinct on those columns, instead
      374. 
+
    374.           * of all returned columns.
      375. 
 
    375.           *
      376. 
 
    376.           * @example
      377. 
 
    377.           *
      378. 
-
    378.           * DB.from("test").isNotNull("boolFlag");
      379. 
-
    379.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      380. 
-
    380.           * DB.from("test").isNotNull("boolFlag", "otherFlag");
      381. 
-
    381.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL AND otherFlag IS NOT NULL);
      382. 
-
    382.           *
      383. 
-
    383.           * @param {String...} arr variable number of arguments to create an IS NOT NULL expression for.
      384. 
-
    384.           *
      385. 
-
    385.           * @return {patio.Dataset} a cloned dataset with the IS NOT NULL expression added to the WHERE clause.
      386. 
+
    386.           * DB.from("items").distinct().sqll
      387. 
+
    387.           *      //=> SELECT DISTINCT * FROM items
      388. 
+
    388.           * DB.from("items").order("id").distinct("id").sql;
      389. 
+
    389.           *      //=> SELECT DISTINCT ON (id) * FROM items ORDER BY id
      390. 
 
    390.           *
      391. 
+
    391.           * @throws {patio.QueryError}  If arguments are given and DISTINCT ON is not supported.
      392. 
+
    392.           * @param {...String|...patio.sql.Identifier} args variable number of arguments used to create
      393. 
+
    393.           *                                                 the DISTINCT ON clause.
      394. 
+
    394.           * @return {patio.Dataset} a cloned dataset with the DISTINCT/DISTINCT ON clause added.
      395. 
 
    395.           */
      396. 
-
    396.          isNotNull: function (arr) {
      397. 
-
    397. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      398. 
-
    398. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      399. 
+
    399.          distinct: function (args) {
      400. 
+
    400. 13            args = argsToArray(arguments);
      401. 
+
    401. 13            if (args.length && !this.supportsDistinctOn) {
      402. 
+
    402. 1                throw new QueryError("DISTICT ON is not supported");
      403. 
+
    403.              }
      404. 
+
    404. 12            args = args.map(function (a) {
      405. 
+
    405. 6                return isString(a) ? new Identifier(a) : a;
      406. 
+
    406.              });
      407. 
+
    407. 12            return this.mergeOptions({distinct: args});
      408. 
 
    408.          },
      409. 
 
    409.  
      410. 
 
    410.          /**
      411. 
-
    411.           * Returnes a cloned dataset with the IS NULL boolean expression added to the WHERE
      412. 
-
    412.           * clause.
      413. 
+
    413.           * Adds an EXCEPT clause using a second dataset object.
      414. 
+
    414.           * An EXCEPT compound dataset returns all rows in the current dataset
      415. 
+
    415.           * that are not in the given dataset.
      416. 
 
    416.           *
      417. 
 
    417.           * @example
      418. 
 
    418.           *
      419. 
-
    419.           * DB.from("test").isNull("boolFlag");
      420. 
-
    420.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      421. 
-
    421.           * DB.from("test").isNull("boolFlag", "otherFlag");
      422. 
-
    422.           *      => SELECT * FROM test WHERE (boolFlag IS NULL AND otherFlag IS NULL);
      423. 
+
    423.           * DB.from("items").except(DB.from("other_items")).sql;
      424. 
+
    424.           *      //=> SELECT * FROM items EXCEPT SELECT * FROM other_items
      425. 
 
    425.           *
      426. 
-
    426.           * @param {String...} arr variable number of arguments to create an IS NULL expression for.
      427. 
+
    427.           * DB.from("items").except(DB.from("other_items"),
      428. 
+
    428.           *                        {all : true, fromSelf : false}).sql;
      429. 
+
    429.           *      //=> SELECT * FROM items EXCEPT ALL SELECT * FROM other_items
      430. 
 
    430.           *
      431. 
-
    431.           * @return {patio.Dataset} a cloned dataset with the IS NULL expression added to the WHERE clause.
      432. 
+
    432.           * DB.from("items").except(DB.from("other_items"),
      433. 
+
    433.           *                        {alias : "i"}).sql;
      434. 
+
    434.           *      //=>SELECT * FROM (SELECT * FROM items EXCEPT SELECT * FROM other_items) AS i
      435. 
+
    435.           *
      436. 
+
    436.           * @throws {patio.QueryError} if the operation is not supported.
      437. 
+
    437.           * @param {patio.Dataset} dataset the dataset to use to create the EXCEPT clause.
      438. 
+
    438.           * @param {Object} [opts] options to use when creating the EXCEPT clause
      439. 
+
    439.           * @param {String|patio.sql.Identifier} [opt.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias.
      440. 
+
    440.           * @param {Boolean} [opts.all] Set to true to use EXCEPT ALL instead of EXCEPT, so duplicate rows can occur
      441. 
+
    441.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}, use with care.
      442. 
 
    442.           *
      443. 
+
    443.           * @return {patio.Dataset} a cloned dataset with the EXCEPT clause added.
      444. 
 
    444.           */
      445. 
-
    445.          isNull: function (arr) {
      446. 
-
    446. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      447. 
-
    447. 2            return this.filter(this.__createBoolExpression("is", arr));
      448. 
+
    448.          except: function (dataset, opts) {
      449. 
+
    449. 18            opts = isUndefined(opts) ? {} : opts;
      450. 
+
    450. 18            if (!isHash(opts)) {
      451. 
+
    451. 5                opts = {all: true};
      452. 
+
    452.              }
      453. 
+
    453. 18            if (!this.supportsIntersectExcept) {
      454. 
+
    454. 2                throw new QueryError("EXCEPT not supoorted");
      455. 
+
    455. 16            } else if (opts.hasOwnProperty("all") && !this.supportsIntersectExceptAll) {
      456. 
+
    456. 1                throw new QueryError("EXCEPT ALL not supported");
      457. 
+
    457.              }
      458. 
+
    458. 15            return this.compoundClone("except", dataset, opts);
      459. 
 
    459.          },
      460. 
 
    460.  
      461. 
 
    461.          /**
      462. 
-
    462.           * Returnes a cloned dataset with the IS NOT TRUE boolean expression added to the WHERE
      463. 
-
    463.           * clause.
      464. 
+
    464.           * Performs the inverse of {@link patio.Dataset#filter}.  Note that if you have multiple filter
      465. 
+
    465.           * conditions, this is not the same as a negation of all conditions. For argument types see
      466. 
+
    466.           * {@link patio.Dataset#filter}
      467. 
 
    467.           *
      468. 
 
    468.           * @example
      469. 
 
    469.           *
      470. 
-
    470.           * DB.from("test").isNotTrue("boolFlag");
      471. 
-
    471.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE);
      472. 
-
    472.           * DB.from("test").isNotTrue("boolFlag", "otherFlag");
      473. 
-
    473.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE AND otherFlag IS NOT TRUE);
      474. 
-
    474.           *
      475. 
-
    475.           * @param {String...} arr variable number of arguments to create an IS NOT TRUE expression for.
      476. 
-
    476.           *
      477. 
-
    477.           * @return {patio.Dataset} a cloned dataset with the IS NOT TRUE expression added to the WHERE clause.
      478. 
+
    478.           * DB.from("items").exclude({category : "software").sql;
      479. 
+
    479.           *      //=> SELECT * FROM items WHERE (category != 'software')
      480. 
 
    480.           *
      481. 
+
    481.           * DB.from("items").exclude({category : 'software', id : 3}).sql;
      482. 
+
    482.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
      483. 
+
    483.           * @return {patio.Dataset} a cloned dataset with the excluded conditions applied to the HAVING/WHERE clause.
      484. 
 
    484.           */
      485. 
-
    485.          isNotTrue: function (arr) {
      486. 
-
    486. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      487. 
-
    487. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      488. 
+
    488.          exclude: function () {
      489. 
+
    489. 69            var cond = argsToArray(arguments), tOpts = this.__opts;
      490. 
+
    490. 69            var clause = (tOpts["having"] ? "having" : "where"), clauseObj = tOpts[clause];
      491. 
+
    491. 69            cond = cond.length > 1 ? cond : cond[0];
      492. 
+
    492. 69            cond = this._filterExpr.call(this, cond);
      493. 
+
    493. 69            cond = BooleanExpression.invert(cond);
      494. 
+
    494. 69            if (clauseObj) {
      495. 
+
    495. 58                cond = new BooleanExpression("AND", clauseObj, cond)
      496. 
+
    496.              }
      497. 
+
    497. 69            var opts = {};
      498. 
+
    498. 69            opts[clause] = cond;
      499. 
+
    499. 69            return this.mergeOptions(opts);
      500. 
 
    500.          },
      501. 
 
    501.  
      502. 
 
    502.          /**
      503. 
-
    503.           * Returnes a cloned dataset with the IS TRUE boolean expression added to the WHERE
      504. 
-
    504.           * clause.
      505. 
+
    505.           * Returns a copy of the dataset with the given conditions applied to it.
      506. 
+
    506.           * If the query already has a HAVING clause, then the conditions are applied to the
      507. 
+
    507.           * HAVING clause otherwise they are applied to the WHERE clause.
      508. 
 
    508.           *
      509. 
 
    509.           * @example
      510. 
 
    510.           *
      511. 
-
    511.           * DB.from("test").isTrue("boolFlag");
      512. 
-
    512.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE);
      513. 
-
    513.           * DB.from("test").isTrue("boolFlag", "otherFlag");
      514. 
-
    514.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE AND otherFlag IS TRUE);
      515. 
+
    515.           * DB.from("items").filter({id : 3}).sql;
      516. 
+
    516.           *      //=> SELECT * FROM items WHERE (id = 3)
      517. 
 
    517.           *
      518. 
-
    518.           * @param {String...} arr variable number of arguments to create an IS TRUE expression for.
      519. 
+
    519.           * DB.from("items").filter('price < ?', 100)
      520. 
+
    520.           *      //=> SELECT * FROM items WHERE price < 100
      521. 
 
    521.           *
      522. 
-
    522.           * @return {patio.Dataset} a cloned dataset with the IS TRUE expression added to the WHERE clause.
      523. 
+
    523.           * DB.from("items").filter({id, [1,2,3]}).filter({id : {between : [0, 10]}}).sql;
      524. 
+
    524.           *      //=> SELECT
      525. 
+
    525.           *               *
      526. 
+
    526.           *           FROM
      527. 
+
    527.           *               items
      528. 
+
    528.           *           WHERE
      529. 
+
    529.           *               ((id IN (1, 2, 3)) AND ((id >= 0) AND (id <= 10)))
      530. 
 
    530.           *
      531. 
-
    531.           */
      532. 
-
    532.          isTrue: function (arr) {
      533. 
-
    533. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      534. 
-
    534. 2            return this.filter(this.__createBoolExpression("is", arr));
      535. 
-
    535.          },
      536. 
-
    536.  
      537. 
-
    537.          /**
      538. 
-
    538.           * Returnes a cloned dataset with the IS NOT FALSE boolean expression added to the WHERE
      539. 
-
    539.           * clause.
      540. 
+
    540.           * DB.from("items").filter('price < 100');
      541. 
+
    541.           *      //=> SELECT * FROM items WHERE price < 100
      542. 
 
    542.           *
      543. 
-
    543.           * @example
      544. 
+
    544.           * DB.from("items").filter("active").sql;
      545. 
+
    545.           *      //=> SELECT * FROM items WHERE active
      546. 
 
    546.           *
      547. 
-
    547.           * DB.from("test").isNotFalse("boolFlag");
      548. 
-
    548.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE);
      549. 
-
    549.           * DB.from("test").isNotFalse("boolFlag", "otherFlag");
      550. 
-
    550.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE AND otherFlag IS NOT FALSE);
      551. 
-
    551.           * @param {String...} arr variable number of arguments to create an IS NOT FALSE expression for.
      552. 
+
    552.           * DB.from("items").filter(function(){
      553. 
+
    553.           *      return this.price.lt(100);
      554. 
+
    554.           * });
      555. 
+
    555.           *      //=> SELECT * FROM items WHERE (price < 100)
      556. 
 
    556.           *
      557. 
-
    557.           * @return {patio.Dataset} a cloned dataset with the IS NOT FALSE expression added to the WHERE clause.
      558. 
+
    558.           * //Multiple filter calls can be chained for scoping:
      559. 
+
    559.           * DB.from("items").filter(:category => 'software').filter{price < 100}
      560. 
+
    560.           *      //=> SELECT * FROM items WHERE ((category = 'software') AND (price < 100))
      561. 
 
    561.           *
      562. 
-
    562.           */
      563. 
-
    563.          isNotFalse: function (arr) {
      564. 
-
    564. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      565. 
-
    565. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      566. 
-
    566.          },
      567. 
-
    567.  
      568. 
-
    568.          /**
      569. 
-
    569.           * Returnes a cloned dataset with the IS FALSE boolean expression added to the WHERE
      570. 
-
    570.           * clause.
      571. 
 
    571.           *
      572. 
-
    572.           * @example
      573. 
+
    573.           * @param {Object|Array|String|patio.sql.Identifier|patio.sql.BooleanExpression} args filters to apply to the
      574. 
+
    574.           *  WHERE/HAVING clause. Description of each:
      575. 
+
    575.           *  <ul>
      576. 
+
    576.           *      <li>Hash - list of equality/inclusion expressions</li>
      577. 
+
    577.           *      <li>Array - depends:
      578. 
+
    578.           *          <ul>
      579. 
+
    579.           *              <li>If first member is a string, assumes the rest of the arguments
      580. 
+
    580.           *                  are parameters and interpolates them into the string.</li>
      581. 
+
    581.           *              <li>If all members are arrays of length two, treats the same way
      582. 
+
    582.           *                  as a hash, except it allows for duplicate keys to be
      583. 
+
    583.           *                  specified.</li>
      584. 
+
    584.           *              <li>Otherwise, treats each argument as a separate condition.</li>
      585. 
+
    585.           *           </ul>
      586. 
+
    586.           *       </li>
      587. 
+
    587.           *      <li>String - taken literally</li>
      588. 
+
    588.           *      <li>{@link patio.sql.Identifier} - taken as a boolean column argument (e.g. WHERE active)</li>
      589. 
+
    589.           *      <li>{@link patio.sql.BooleanExpression} - an existing condition expression,
      590. 
+
    590.           *          probably created using the patio.sql methods.
      591. 
+
    591.           *       </li>
      592. 
 
    592.           *
      593. 
-
    593.           * DB.from("test").isFalse("boolFlag");
      594. 
-
    594.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE);
      595. 
-
    595.           * DB.from("test").isFalse("boolFlag", "otherFlag");
      596. 
-
    596.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE AND otherFlag IS FALSE);
      597. 
-
    597.           * @param {String...} arr variable number of arguments to create an IS FALSE expression for.
      598. 
+
    598.           * @param {Function} [cb] filter also takes a cb, which should return one of the above argument
      599. 
+
    599.           * types, and is treated the same way.  This block is called with an {@link patio.sql} object which can be used to dynaically create expression.  For more details
      600. 
+
    600.           * on the sql object see {@link patio.sql}
      601. 
 
    601.           *
      602. 
-
    602.           * @return {patio.Dataset} a cloned dataset with the IS FALSE expression added to the WHERE clause.
      603. 
+
    603.           * <p>
      604. 
+
    604.           *     <b>NOTE:</b>If both a cb and regular arguments are provided, they get ANDed together.
      605. 
+
    605.           * </p>
      606. 
 
    606.           *
      607. 
-
    607.           */
      608. 
-
    608.          isFalse: function (arr) {
      609. 
-
    609. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      610. 
-
    610. 2            return this.filter(this.__createBoolExpression("is", arr));
      611. 
+
    611.           * @return {patio.Dataset} a cloned dataset with the filter arumgents applied to the WHERE/HAVING clause.
      612. 
+
    612.           **/
      613. 
+
    613.          filter: function (args, cb) {
      614. 
+
    614. 3468            args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
      615. 
+
    615. 3468            return this._filter.apply(this, args);
      616. 
 
    616.          },
      617. 
 
    617.  
      618. 
 
    618.          /**
      619. 
-
    619.           *
      620. 
-
    620.           * Returns a cloned dataset with a greater than or equal to expression added to the WHERE
      621. 
-
    621.           * clause.
      622. 
-
    622.           *
      623. 
-
    623.           * @example
      624. 
-
    624.           *  DB.from("test").gte({x : 1});
      625. 
-
    625.           *          //=> SELECT * FROM test WHERE (x >= 1)
      626. 
-
    626.           *  DB.from("test").gte({x : 1, y : 10});
      627. 
-
    627.           *          //=> SELECT * FROM test WHERE ((x >= 1) AND (y >= 10))
      628. 
-
    628.           *
      629. 
-
    629.           * @param {Object} obj object used to create the greater than or equal to expression.
      630. 
-
    630.           *
      631. 
-
    631.           * @return {patio.Dataset} a cloned dataset with the greater than or equal to expression added to the WHERE clause.
      632. 
+
    632.           * @see patio.Dataset#filter
      633. 
 
    633.           */
      634. 
-
    634.          gte: function (arr) {
      635. 
-
    635. 2            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "gte");
      636. 
-
    636. 2            return this.filter(this.__createBoolExpression("gte", arr));
      637. 
+
    637.          find: function () {
      638. 
+
    638. 30            var args = [this.__opts["having"] ? "having" : "where"].concat(argsToArray(arguments));
      639. 
+
    639. 30            return this._filter.apply(this, args);
      640. 
 
    640.          },
      641. 
 
    641.  
      642. 
 
    642.          /**
      643. 
-
    643.           *
      644. 
-
    644.           * Returns a cloned dataset with a less than or equal to expression added to the WHERE
      645. 
-
    645.           * clause.
      646. 
-
    646.           *
      647. 
 
    647.           * @example
      648. 
-
    648.           *  DB.from("test").gte({x : 1});
      649. 
-
    649.           *          //=> SELECT * FROM test WHERE (x <= 1)
      650. 
-
    650.           *  DB.from("test").gte({x : 1, y : 10});
      651. 
-
    651.           *          //=> SELECT * FROM test WHERE ((x <= 1) AND (y <= 10))
      652. 
-
    652.           *
      653. 
-
    653.           * @param {Object} obj object used to create the less than or equal to expression.
      654. 
-
    654.           *
      655. 
-
    655.           * @return {patio.Dataset} a cloned dataset with the less than or equal to expression added to the WHERE clause.
      656. 
+
    656.           * DB.from("table").forUpdate()
      657. 
+
    657.           *          //=> SELECT * FROM table FOR UPDATE
      658. 
+
    658.           * @return {patio.Dataset} a cloned dataset with a "update" lock style.
      659. 
 
    659.           */
      660. 
-
    660.          lte: function (obj) {
      661. 
-
    661. 2            var arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "lte");
      662. 
-
    662. 2            return this.filter(this.__createBoolExpression("lte", obj));
      663. 
+
    663.          forUpdate: function () {
      664. 
+
    664. 1            return this.lockStyle("update");
      665. 
 
    665.          },
      666. 
 
    666.  
      667. 
 
    667.          /**
      668. 
-
    668.           * Returns a cloned dataset with a between clause added
      669. 
-
    669.           * to the where clause.
      670. 
+
    670.           * Returns a copy of the dataset with the source changed. If no
      671. 
+
    671.           * source is given, removes all tables.  If multiple sources
      672. 
+
    672.           * are given, it is the same as using a CROSS JOIN (cartesian product) between all tables.
      673. 
 
    673.           *
      674. 
 
    674.           * @example
      675. 
-
    675.           *  ds.notBetween({x:[1, 2]}).sql;
      676. 
-
    676.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      677. 
+
    677.           * var dataset = DB.from("items");
      678. 
 
    678.           *
      679. 
-
    679.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      680. 
-
    680.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      681. 
-
    681.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      682. 
-
    682.           *                     is the item to be greater than or equal to than and the second item is less than or equal to than.
      683. 
+
    683.           * dataset.from().sql;
      684. 
+
    684.           *      //=> SELECT *
      685. 
 
    685.           *
      686. 
-
    686.           * @return {patio.Dataset} a cloned dataset with a between clause added
      687. 
-
    687.           * to the where clause.
      688. 
-
    688.           */
      689. 
-
    689.          between: function (obj) {
      690. 
-
    690. 2            return this.filter(this.__createBetweenExpression(obj));
      691. 
-
    691.          },
      692. 
-
    692.  
      693. 
-
    693.          /**
      694. 
-
    694.           * Returns a cloned dataset with a not between clause added
      695. 
-
    695.           * to the where clause.
      696. 
+
    696.           * dataset.from("blah").sql
      697. 
+
    697.           *      //=> SELECT * FROM blah
      698. 
 
    698.           *
      699. 
-
    699.           * @example
      700. 
-
    700.           *  ds.notBetween({x:[1, 2]}).sql;
      701. 
-
    701.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      702. 
+
    702.           * dataset.from("blah", "foo")
      703. 
+
    703.           *      //=> SELECT * FROM blah, foo
      704. 
 
    704.           *
      705. 
-
    705.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      706. 
-
    706.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      707. 
-
    707.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      708. 
-
    708.           *                     is the item to be less than and the second item is greater than.
      709. 
+
    709.           * dataset.from({a:"b"}).sql;
      710. 
+
    710.           *      //=> SELECT * FROM a AS b
      711. 
 
    711.           *
      712. 
-
    712.           * @return {patio.Dataset} a cloned dataset with a not between clause added
      713. 
-
    713.           * to the where clause.
      714. 
+
    714.           * dataset.from(dataset.from("a").group("b").as("c")).sql;
      715. 
+
    715.           *          //=> "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
      716. 
+
    716.           *
      717. 
+
    717.           * @param {...String|...patio.sql.Identifier|...patio.Dataset|...Object} [source] tables to select from
      718. 
+
    718.           *
      719. 
+
    719.           * @return {patio.Dataset} a cloned dataset with the FROM clause overridden.
      720. 
 
    720.           */
      721. 
-
    721.          notBetween: function (obj) {
      722. 
-
    722. 2            return this.filter(this.__createBetweenExpression(obj, true));
      723. 
+
    723.          from: function (source) {
      724. 
+
    724. 821            source = argsToArray(arguments);
      725. 
+
    725. 821            var tableAliasNum = 0, sources = [];
      726. 
+
    726. 821            source.forEach(function (s) {
      727. 
+
    727. 1003                if (isInstanceOf(s, Dataset)) {
      728. 
+
    728. 86                    sources.push(new AliasedExpression(s, this._datasetAlias(++tableAliasNum)));
      729. 
+
    729. 917                } else if (isHash(s)) {
      730. 
+
    730. 3                    for (var i in s) {
      731. 
+
    731. 3                        sources.push(new AliasedExpression(new Identifier(i), s[i]));
      732. 
+
    732.                      }
      733. 
+
    733. 914                } else if (isString(s)) {
      734. 
+
    734. 889                    sources.push(this.stringToIdentifier(s))
      735. 
+
    735.                  } else {
      736. 
+
    736. 25                    sources.push(s);
      737. 
+
    737.                  }
      738. 
+
    738.              }, this);
      739. 
+
    739.  
      740. 
+
    740. 821            var o = {from: sources.length ? sources : null}
      741. 
+
    741. 821            if (tableAliasNum) {
      742. 
+
    742. 84                o.numDatasetSources = tableAliasNum;
      743. 
+
    743.              }
      744. 
+
    744. 821            return this.mergeOptions(o)
      745. 
 
    745.          },
      746. 
 
    746.  
      747. 
 
    747.          /**
      748. 
-
    748.           * Returns a cloned dataset with the given lock style.  If style is a
      749. 
-
    749.           * string, it will be used directly.Currently "update" is respected
      750. 
-
    750.           * by most databases, and "share" is supported by some.
      751. 
+
    751.           * Returns a dataset selecting from the current dataset.
      752. 
+
    752.           * Supplying the alias option controls the alias of the result.
      753. 
 
    753.           *
      754. 
 
    754.           * @example
      755. 
-
    755.           * DB.from("items").lockStyle('FOR SHARE') # SELECT * FROM items FOR SHARE
      756. 
 
    756.           *
      757. 
-
    757.           * @param {String} style the lock style to use.
      758. 
+
    758.           * ds = DB.from("items").order("name").select("id", "name")
      759. 
+
    759.           *      //=> SELECT id,name FROM items ORDER BY name
      760. 
 
    760.           *
      761. 
-
    761.           * @return {patio.Dataset} a cloned datase with the given lock style.
      762. 
-
    762.           **/
      763. 
-
    763.          lockStyle: function (style) {
      764. 
-
    764. 4            return this.mergeOptions({lock: style});
      765. 
-
    765.          },
      766. 
-
    766.  
      767. 
-
    767.          /**
      768. 
-
    768.           * Returns a copy of the dataset with the order changed. If the dataset has an
      769. 
-
    769.           * existing order, it is ignored and overwritten with this order. If null is given
      770. 
-
    770.           * the returned dataset has no order. This can accept multiple arguments
      771. 
-
    771.           * of varying kinds, such as SQL functions.  This also takes a function similar
      772. 
-
    772.           * to {@link patio.Dataset#filter}
      773. 
+
    773.           * ds.fromSelf().sql;
      774. 
+
    774.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1
      775. 
 
    775.           *
      776. 
-
    776.           * @example
      777. 
+
    777.           * ds.fromSelf({alias : "foo"}).sql;
      778. 
+
    778.           *      //=> SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo
      779. 
 
    779.           *
      780. 
-
    780.           *  DB.from("items").order("name")
      781. 
-
    781.           *          //=> SELECT * FROM items ORDER BY name
      782. 
+
    782.           * @param {Object} [opts] options
      783. 
+
    783.           * @param {String|patio.sql.Identifier} [opts.alias] alias to use
      784. 
 
    784.           *
      785. 
-
    785.           *  DB.from("items").order("a", "b")
      786. 
-
    786.           *          //=> SELECT * FROM items ORDER BY a, b
      787. 
+
    787.           * @return {patio.Dataset} a cloned dataset with the FROM clause set as the current dataset.
      788. 
+
    788.           */
      789. 
+
    789.          fromSelf: function (opts) {
      790. 
+
    790. 84            opts = isUndefined(opts) ? {} : opts;
      791. 
+
    791. 84            var fs = {};
      792. 
+
    792. 84            var nonSqlOptions = this._static.NON_SQL_OPTIONS;
      793. 
+
    793. 84            Object.keys(this.__opts).forEach(function (k) {
      794. 
+
    794. 302                if (nonSqlOptions.indexOf(k) == -1) {
      795. 
+
    795. 302                    fs[k] = null;
      796. 
+
    796.                  }
      797. 
+
    797.              });
      798. 
+
    798. 84            return this.mergeOptions(fs).from(opts["alias"] ? this.as(opts["alias"]) : this);
      799. 
+
    799.          },
      800. 
+
    800.  
      801. 
+
    801.          /**
      802. 
+
    802.           * Match any of the columns to any of the patterns. The terms can be
      803. 
+
    803.           * strings (which use LIKE) or regular expressions (which are only
      804. 
+
    804.           * supported on MySQL and PostgreSQL).  Note that the total number of
      805. 
+
    805.           * pattern matches will be columns[].length * terms[].length,
      806. 
+
    806.           * which could cause performance issues.
      807. 
 
    807.           *
      808. 
-
    808.           *  DB.from("items").order(sql.literal('a + b'))
      809. 
-
    809.           *          //=> SELECT * FROM items ORDER BY a + b
      810. 
+
    810.           * @example
      811. 
 
    811.           *
      812. 
-
    812.           *  DB.from("items").order(sql.identifier("a").plus("b"))
      813. 
-
    813.           *          //=> SELECT * FROM items ORDER BY (a + b)
      814. 
+
    814.           * DB.from("items").grep("a", "%test%").sql;
      815. 
+
    815.           *      //=> SELECT * FROM items WHERE (a LIKE '%test%');
      816. 
 
    816.           *
      817. 
-
    817.           *  DB.from("items").order(sql.identifier("name").desc())
      818. 
-
    818.           *          //=> SELECT * FROM items ORDER BY name DESC
      819. 
+
    819.           * DB.from("items").grep(["a", "b"], ["%test%" "foo"]).sql;
      820. 
+
    820.           *      //=> SELECT * FROM items WHERE ((a LIKE '%test%') OR (a LIKE 'foo') OR (b LIKE '%test%') OR (b LIKE 'foo'))
      821. 
 
    821.           *
      822. 
-
    822.           *  DB.from("items").order(sql.identifier("name").asc({nulls : "last"))
      823. 
-
    823.           *          //=> SELECT * FROM items ORDER BY name ASC NULLS LAST
      824. 
+
    824.           * DB.from("items").grep(['a', 'b'], ["%foo%", "%bar%"], {allPatterns : true}).sql;
      825. 
+
    825.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%')) AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
      826. 
 
    826.           *
      827. 
-
    827.           *  DB.from("items").order(function(){
      828. 
-
    828.           *          return this.sum("name").desc();
      829. 
-
    829.           *  }); //=> SELECT * FROM items ORDER BY sum(name) DESC
      830. 
+
    830.           * DB.from("items").grep(["a", "b"], ['%foo%", "%bar%", {allColumns : true})sql;
      831. 
+
    831.           *      //=> SELECT * FROM a WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%')) AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
      832. 
 
    832.           *
      833. 
-
    833.           *  DB.from("items").order(null)
      834. 
-
    834.           *          //=>SELECT * FROM items
      835. 
-
    835.           *  @param arg variable number of arguments similar to {@link patio.Dataset#filter}
      836. 
+
    836.           * DB.from("items").grep(["a", "b"], ["%foo%", "%bar%"], {allPatterns : true, allColumns : true}).sql;
      837. 
+
    837.           *      //=> SELECT * FROM a WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%') AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
      838. 
 
    838.           *
      839. 
-
    839.           *  @return {patio.Dataset} a cloned dataset with the order changed.
      840. 
-
    840.           * */
      841. 
-
    841.          order: function (args) {
      842. 
-
    842. 381            args = argsToArray(arguments);
      843. 
-
    843. 381            var order = [];
      844. 
-
    844. 381            args = compact(args).length ? args : null;
      845. 
-
    845. 381            if (args) {
      846. 
-
    846. 263                args.forEach(function (a) {
      847. 
-
    847. 326                    if (isString(a)) {
      848. 
-
    848. 204                        order.push(this.stringToIdentifier(a));
      849. 
-
    849. 122                    } else if (isFunction(a)) {
      850. 
-
    850. 16                        var res = a.apply(sql, [sql]);
      851. 
-
    851. 16                        order = order.concat(isArray(res) ? res : [res]);
      852. 
-
    852.                      } else {
      853. 
-
    853. 106                        order.push(a);
      854. 
-
    854.                      }
      855. 
-
    855.                  }, this);
      856. 
+
    856.           * @param {String[]|patio.sql.Identifier[]} columns columns to search
      857. 
+
    857.           * @param {String|RegExp} patterns patters to search with
      858. 
+
    858.           * @param {Object} [opts] options to use when searching. NOTE If both allColumns and allPatterns are true, all columns must match all patterns
      859. 
+
    859.           * @param {Boolean} [opts.allColumns] All columns must be matched to any of the given patterns.
      860. 
+
    860.           * @param {Boolean} [opts.allPatterns] All patterns must match at least one of the columns.
      861. 
+
    861.           * @param {Boolean} [opts.caseInsensitive] Use a case insensitive pattern match (the default is
      862. 
+
    862.           *                      case sensitive if the database supports it).
      863. 
+
    863.           * @return {patio.Dataset} a dataset with the LIKE clauses added
      864. 
+
    864.           */
      865. 
+
    865.  
      866. 
+
    866.          grep: function (columns, patterns, opts) {
      867. 
+
    867. 15            opts = isUndefined(opts) ? {} : opts;
      868. 
+
    868. 15            var conds;
      869. 
+
    869. 15            if (opts.hasOwnProperty("allPatterns")) {
      870. 
+
    870. 4                conds = array.toArray(patterns).map(function (pat) {
      871. 
+
    871. 8                    return BooleanExpression.fromArgs(
      872. 
+
    872.                          [(opts.allColumns ? "AND" : "OR")]
      873. 
+
    873.                              .concat(array.toArray(columns)
      874. 
+
    874.                                  .map(function (c) {
      875. 
+
    875. 16                                    return StringExpression.like(c, pat, opts);
      876. 
+
    876.                                  })));
      877. 
+
    877.                  });
      878. 
+
    878. 4                return this.filter(BooleanExpression.fromArgs([opts.allPatterns ? "AND" : "OR"].concat(conds)));
      879. 
 
    879.              } else {
      880. 
-
    880. 118                order = null;
      881. 
+
    881. 11                conds = array.toArray(columns)
      882. 
+
    882.                      .map(function (c) {
      883. 
+
    883. 16                        return BooleanExpression.fromArgs(["OR"].concat(array.toArray(patterns).map(function (pat) {
      884. 
+
    884. 26                            return StringExpression.like(c, pat, opts);
      885. 
+
    885.                          })));
      886. 
+
    886.                      });
      887. 
+
    887. 11                return this.filter(BooleanExpression.fromArgs([opts.allColumns ? "AND" : "OR"].concat(conds)));
      888. 
 
    888.              }
      889. 
-
    889. 381            return this.mergeOptions({order: order});
      890. 
 
    890.          },
      891. 
 
    891.  
      892. 
 
    892.          /**
      893. 
-
    893.           * Alias of {@link patio.Dataset#orderMore};
      894. 
+
    894.           * @see patio.Dataset#grep
      895. 
 
    895.           */
      896. 
-
    896.          orderAppend: function () {
      897. 
-
    897. 4            return this.orderMore.apply(this, arguments);
      898. 
+
    898.          like: function () {
      899. 
+
    899. 1            return this.grep.apply(this, arguments);
      900. 
 
    900.          },
      901. 
 
    901.  
      902. 
-
    902.          /**
      903. 
-
    903.           * @see patio.Dataset#order
      904. 
-
    904.           */
      905. 
-
    905.          orderBy: function () {
      906. 
-
    906. 6            return this.order.apply(this, arguments);
      907. 
-
    907.          },
      908. 
 
    908.  
      909. 
 
    909.          /**
      910. 
-
    910.           * Returns a copy of the dataset with the order columns added
      911. 
-
    911.           * to the end of the existing order. For more detail
      912. 
-
    912.           * @see patio.Dataset#order
      913. 
-
    913.           *
      914. 
+
    914.           * Returns a copy of the dataset with the results grouped by the value of
      915. 
+
    915.           * the given columns.
      916. 
 
    916.           * @example
      917. 
+
    917.           *   DB.from("items").group("id")
      918. 
+
    918.           *          //=>SELECT * FROM items GROUP BY id
      919. 
+
    919.           *   DB.from("items").group("id", "name")
      920. 
+
    920.           *          //=> SELECT * FROM items GROUP BY id, name
      921. 
+
    921.           * @param {String...|patio.sql.Identifier...} columns columns to group by.
      922. 
 
    922.           *
      923. 
-
    923.           * DB.from("items").order("a").order("b");
      924. 
-
    924.           *      //=> SELECT * FROM items ORDER BY b
      925. 
-
    925.           *
      926. 
-
    926.           * DB.from("items").order("a").orderMore("b");
      927. 
-
    927.           *      //=>SELECT * FROM items ORDER BY a, b
      928. 
-
    928.           */
      929. 
-
    929.          orderMore: function () {
      930. 
-
    930. 11            var args = argsToArray(arguments);
      931. 
-
    931. 11            if (this.__opts.order) {
      932. 
-
    932. 9                args = this.__opts.order.concat(args);
      933. 
-
    933.              }
      934. 
-
    934. 11            return this.order.apply(this, args);
      935. 
+
    935.           * @return {patio.Dataset} a cloned dataset with the GROUP BY clause added.
      936. 
+
    936.           **/
      937. 
+
    937.          group: function (columns) {
      938. 
+
    938. 32            columns = argsToArray(arguments);
      939. 
+
    939. 32            var stringToIdentifier = this.stringToIdentifier.bind(this)
      940. 
+
    940. 32            return this.mergeOptions({group: (array.compact(columns).length == 0 ? null : columns.map(function (c) {
      941. 
+
    941. 32                return isString(c) ? stringToIdentifier(c) : c;
      942. 
+
    942.              }))});
      943. 
 
    943.          },
      944. 
 
    944.  
      945. 
 
    945.          /**
      946. 
-
    946.           * Returns a copy of the dataset with the order columns added
      947. 
-
    947.           * to the beginning of the existing order. For more detail
      948. 
-
    948.           * @see patio.Dataset#order
      949. 
-
    949.           *
      950. 
-
    950.           * @example
      951. 
-
    951.           * DB.from("items").order("a").order("b");
      952. 
-
    952.           *      //=> SELECT * FROM items ORDER BY b
      953. 
-
    953.           *
      954. 
-
    954.           * DB.from("items").order("a").orderPrepend("b");
      955. 
-
    955.           *      //=>SELECT * FROM items ORDER BY b, a
      956. 
-
    956.           *
      957. 
-
    957.           *
      958. 
-
    958.           **/
      959. 
-
    959.          orderPrepend: function () {
      960. 
-
    960. 4            var ds = this.order.apply(this, arguments);
      961. 
-
    961. 4            return this.__opts.order ? ds.orderMore.apply(ds, this.__opts.order) : ds;
      962. 
+
    962.           * @see patio.Dataset#group
      963. 
+
    963.           */
      964. 
+
    964.          groupBy: function () {
      965. 
+
    965. 10            return this.group.apply(this, arguments);
      966. 
 
    966.          },
      967. 
 
    967.  
      968. 
+
    968.  
      969. 
 
    969.          /**
      970. 
-
    970.           * Qualify to the given table, or {@link patio.Dataset#firstSourceAlias} if not table is given.
      971. 
+
    971.           * Returns a dataset grouped by the given column with count by group.
      972. 
+
    972.           * Column aliases may be supplied, and will be included in the select clause.
      973. 
 
    973.           *
      974. 
 
    974.           * @example
      975. 
-
    975.           * DB.from("items").filter({id : 1}).qualify();
      976. 
-
    976.           *    //=> SELECT items.* FROM items WHERE (items.id = 1)
      977. 
 
    977.           *
      978. 
-
    978.           * DB.from("items").filter({id : 1}).qualify("i");
      979. 
-
    979.           *   //=> SELECT i.* FROM items WHERE (i.id = 1)
      980. 
-
    980.           *
      981. 
-
    981.           * @param {String|patio.sql.Identifier} [table={@link patio.Dataset#firstSourceAlias}] the table name to qualify to.
      982. 
-
    982.           *
      983. 
-
    983.           * @return {patio.Dataset} a cloned dataset qualified to the table or {@link patio.Dataset#firstSourceAlias}
      984. 
-
    984.           **/
      985. 
-
    985.          qualify: function (table) {
      986. 
-
    986. 19            table = table || this.firstSourceAlias;
      987. 
-
    987. 19            return this.qualifyTo(table);
      988. 
-
    988.          },
      989. 
-
    989.  
      990. 
-
    990.          /**
      991. 
-
    991.           * Qualify the dataset to its current first source(first from clause).  This is useful
      992. 
-
    992.           * if you have unqualified identifiers in the query that all refer to
      993. 
-
    993.           * the first source, and you want to join to another table which
      994. 
-
    994.           * has columns with the same name as columns in the current dataset.
      995. 
-
    995.           * See {@link patio.Dataset#qualifyTo}
      996. 
+
    996.           * DB.from("items").groupAndCount("name").all()
      997. 
+
    997.           *      //=> SELECT name, count(*) AS count FROM items GROUP BY name
      998. 
+
    998.           *      //=> [{name : 'a', count : 1}, ...]
      999. 
 
    999.           *
      1000. 
-
    1000.           * @example
      1001. 
+
    1001.           * DB.from("items").groupAndCount("first_name", "last_name").all()
      1002. 
+
    1002.           *      //SELECT first_name, last_name, count(*) AS count FROM items GROUP BY first_name, last_name
      1003. 
+
    1003.           *      //=> [{first_name : 'a', last_name : 'b', count : 1}, ...]
      1004. 
 
    1004.           *
      1005. 
-
    1005.           * DB.from("items").filter({id : 1}).qualifyToFirstSource();
      1006. 
-
    1006.           *      //=> SELECT items.* FROM items WHERE (items.id = 1)
      1007. 
+
    1007.           * DB.from("items").groupAndCount("first_name___name").all()
      1008. 
+
    1008.           *      //=> SELECT first_name AS name, count(*) AS count FROM items GROUP BY first_name
      1009. 
+
    1009.           *      //=> [{name : 'a', count:1}, ...]
      1010. 
+
    1010.           * @param {String...|patio.sql.Identifier...} columns columns to croup and count on.
      1011. 
 
    1011.           *
      1012. 
-
    1012.           * @return {patio.Dataset} a cloned dataset that is qualified with the first source.
      1013. 
-
    1013.           * */
      1014. 
-
    1014.          qualifyToFirstSource: function () {
      1015. 
-
    1015. 18            return this.qualifyTo(this.firstSourceAlias);
      1016. 
+
    1016.           * @return {patio.Dataset} a cloned dataset with the GROUP clause and count added.
      1017. 
+
    1017.           */
      1018. 
+
    1018.          groupAndCount: function (columns) {
      1019. 
+
    1019. 8            columns = argsToArray(arguments);
      1020. 
+
    1020. 8            var group = this.group.apply(this, columns.map(function (c) {
      1021. 
+
    1021. 9                return this._unaliasedIdentifier(c);
      1022. 
+
    1022.              }, this));
      1023. 
+
    1023. 8            return group.select.apply(group, columns.concat([this._static.COUNT_OF_ALL_AS_COUNT]));
      1024. 
+
    1024.  
      1025. 
 
    1025.          },
      1026. 
 
    1026.  
      1027. 
 
    1027.          /**
      1028. 
-
    1028.           * Return a copy of the dataset with unqualified identifiers in the
      1029. 
-
    1029.           * SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
      1030. 
-
    1030.           * given table. If no columns are currently selected, select all
      1031. 
-
    1031.           * columns of the given table.
      1032. 
+
    1032.           * Returns a copy of the dataset with the HAVING conditions changed. See {@link patio.Dataset#filter} for argument types.
      1033. 
 
    1033.           *
      1034. 
 
    1034.           * @example
      1035. 
-
    1035.           *   DB.from("items").filter({id : 1}).qualifyTo("i");
      1036. 
-
    1036.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      1037. 
-
    1037.           *
      1038. 
-
    1038.           * @param {String} table the name to qualify identifier to.
      1039. 
+
    1039.           * DB.from("items").group("sum").having({sum : 10}).sql;
      1040. 
+
    1040.           *      //=> SELECT * FROM items GROUP BY sum HAVING (sum = 10)
      1041. 
 
    1041.           *
      1042. 
-
    1042.           * @return {patio.Dataset} a cloned dataset with unqualified identifiers qualified.
      1043. 
-
    1043.           */
      1044. 
-
    1044.          qualifyTo: function (table) {
      1045. 
-
    1045. 40            var o = this.__opts;
      1046. 
-
    1046. 40            if (o.sql) {
      1047. 
-
    1047. 2                return this.mergeOptions();
      1048. 
-
    1048.              }
      1049. 
-
    1049. 38            var h = {};
      1050. 
-
    1050. 38            array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
      1051. 
-
    1051. 65                h[k] = this._qualifiedExpression(o[k], table);
      1052. 
+
    1052.           * @return {patio.Dataset} a cloned dataset with HAVING clause changed or added.
      1053. 
+
    1053.           **/
      1054. 
+
    1054.          having: function () {
      1055. 
+
    1055. 12            var cond = argsToArray(arguments).map(function (s) {
      1056. 
+
    1056. 12                return isString(s) && s !== '' ? this.stringToIdentifier(s) : s
      1057. 
 
    1057.              }, this);
      1058. 
-
    1058. 38            if (!o.select || isEmpty(o.select)) {
      1059. 
-
    1059. 14                h.select = [new ColumnAll(table)];
      1060. 
-
    1060.              }
      1061. 
-
    1061. 38            return this.mergeOptions(h);
      1062. 
+
    1062. 12            return this._filter.apply(this, ["having"].concat(cond));
      1063. 
 
    1063.          },
      1064. 
 
    1064.  
      1065. 
 
    1065.          /**
      1066. 
-
    1066.           * Same as {@link patio.Dataset@qualifyTo} except that it forces qualification on methods called
      1067. 
-
    1067.           * after it has been called.
      1068. 
+
    1068.           * Adds an INTERSECT clause using a second dataset object.
      1069. 
+
    1069.           * An INTERSECT compound dataset returns all rows in both the current dataset
      1070. 
+
    1070.           * and the given dataset.
      1071. 
 
    1071.           *
      1072. 
 
    1072.           * @example
      1073. 
 
    1073.           *
      1074. 
-
    1074.           * //qualfyTo would generate
      1075. 
-
    1075.           * DB.from("items").qualifyTo("i").filter({id : 1});
      1076. 
-
    1076.           *      //=> SELECT i.* FROM items WHERE (id = 1)
      1077. 
+
    1077.           * DB.from("items").intersect(DB.from("other_items")).sql;
      1078. 
+
    1078.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS t1
      1079. 
 
    1079.           *
      1080. 
-
    1080.           * //alwaysQualify qualifies filter also.
      1081. 
-
    1081.           * DB.from("items").alwaysQualify("i").filter({id : 1});
      1082. 
-
    1082.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      1083. 
+
    1083.           * DB.from("items").intersect(DB.from("other_items"), {all : true, fromSelf : false}).sql;
      1084. 
+
    1084.           *   //=> SELECT * FROM items INTERSECT ALL SELECT * FROM other_items
      1085. 
 
    1085.           *
      1086. 
+
    1086.           * DB.from("items").intersect(DB.from("other_items"), {alias : "i"}).sql;
      1087. 
+
    1087.           *   //=> SELECT * FROM (SELECT * FROM items INTERSECT SELECT * FROM other_items) AS i
      1088. 
 
    1088.           *
      1089. 
-
    1089.           * @param {String|patio.sql.Identifier} [table=this.firstSourceAlias] the table to qualify to.
      1090. 
-
    1090.           * @return {patio.Dataset} a cloned dataset that will always qualify.
      1091. 
-
    1091.           */
      1092. 
-
    1092.          alwaysQualify: function (table) {
      1093. 
-
    1093. 3            return this.mergeOptions({alwaysQualify: table || this.firstSourceAlias});
      1094. 
+
    1094.           * @throws {patio.QueryError} if the operation is not supported.
      1095. 
+
    1095.           * @param  {patio.Dataset} dataset the dataset to intersect
      1096. 
+
    1096.           * @param  {Object} [opts] options
      1097. 
+
    1097.           * @param {String|patio.sql.Identifier} [opts.alias] Use the given value as the {@link patio.Dataset#fromSelf} alias
      1098. 
+
    1098.           * @param {Boolean} [opts.all] Set to true to use INTERSECT ALL instead of INTERSECT, so duplicate rows can occur
      1099. 
+
    1099.           * @param {Boolean} [opts.fromSelf] Set to false to not wrap the returned dataset in a {@link patio.Dataset#fromSelf}.
      1100. 
+
    1100.           *
      1101. 
+
    1101.           * @return {patio.Dataset} a cloned dataset with the INTERSECT clause.
      1102. 
+
    1102.           **/
      1103. 
+
    1103.          intersect: function (dataset, opts) {
      1104. 
+
    1104. 18            opts = isUndefined(opts) ? {} : opts;
      1105. 
+
    1105. 18            if (!isHash(opts)) {
      1106. 
+
    1106. 5                opts = {all: opts};
      1107. 
+
    1107.              }
      1108. 
+
    1108. 18            if (!this.supportsIntersectExcept) {
      1109. 
+
    1109. 2                throw new QueryError("INTERSECT not supported");
      1110. 
+
    1110. 16            } else if (opts.all && !this.supportsIntersectExceptAll) {
      1111. 
+
    1111. 1                throw new QueryError("INTERSECT ALL not supported");
      1112. 
+
    1112.              }
      1113. 
+
    1113. 15            return this.compoundClone("intersect", dataset, opts);
      1114. 
 
    1114.          },
      1115. 
 
    1115.  
      1116. 
-
    1116.  
      1117. 
 
    1117.          /**
      1118. 
-
    1118.           * Returns a copy of the dataset with the order reversed. If no order is
      1119. 
-
    1119.           * given, the existing order is inverted.
      1120. 
+
    1120.           * Inverts the current filter.
      1121. 
 
    1121.           *
      1122. 
 
    1122.           * @example
      1123. 
-
    1123.           * DB.from("items").reverse("id");
      1124. 
-
    1124.           *      //=> SELECT * FROM items ORDER BY id DESC
      1125. 
-
    1125.           *
      1126. 
-
    1126.           * DB.from("items").order("id").reverse();
      1127. 
-
    1127.           *      //=> SELECT * FROM items ORDER BY id DESC
      1128. 
-
    1128.           *
      1129. 
-
    1129.           * DB.from("items").order("id").reverse(sql.identifier("name").asc);
      1130. 
-
    1130.           *      //=> SELECT * FROM items ORDER BY name ASC
      1131. 
-
    1131.           *
      1132. 
-
    1132.           * @param {String|patio.sql.Identifier|Function} args variable number of columns add to order before reversing.
      1133. 
+
    1133.           * DB.from("items").filter({category : 'software'}).invert()
      1134. 
+
    1134.           *      //=> SELECT * FROM items WHERE (category != 'software')
      1135. 
 
    1135.           *
      1136. 
-
    1136.           * @return {patio.Dataset} a cloned dataset with the order reversed.
      1137. 
+
    1137.           * @example
      1138. 
+
    1138.           * DB.from("items").filter({category : 'software', id : 3}).invert()
      1139. 
+
    1139.           *      //=> SELECT * FROM items WHERE ((category != 'software') OR (id != 3))
      1140. 
 
    1140.           *
      1141. 
+
    1141.           * @return {patio.Dataset} a cloned dataset with the filter inverted.
      1142. 
 
    1142.           **/
      1143. 
-
    1143.          reverse: function (args) {
      1144. 
-
    1144. 46            args = argsToArray(arguments);
      1145. 
-
    1145. 46            return this.order.apply(this, this._invertOrder(args.length ? args : this.__opts.order));
      1146. 
+
    1146.          invert: function () {
      1147. 
+
    1147. 3            var having = this.__opts.having, where = this.__opts.where;
      1148. 
+
    1148. 3            if (!(having || where)) {
      1149. 
+
    1149. 1                throw new QueryError("No current filter");
      1150. 
+
    1150.              }
      1151. 
+
    1151. 2            var o = {}
      1152. 
+
    1152. 2            if (having) {
      1153. 
+
    1153. 1                o.having = BooleanExpression.invert(having);
      1154. 
+
    1154.              }
      1155. 
+
    1155. 2            if (where) {
      1156. 
+
    1156. 2                o.where = BooleanExpression.invert(where);
      1157. 
+
    1157.              }
      1158. 
+
    1158. 2            return this.mergeOptions(o);
      1159. 
 
    1159.          },
      1160. 
 
    1160.  
      1161. 
 
    1161.          /**
      1162. 
-
    1162.           * @see patio.Dataset#reverse
      1163. 
+
    1163.           * Returns a cloned dataset with an inner join applied.
      1164. 
+
    1164.           *
      1165. 
+
    1165.           * @see patio.Dataset#joinTable
      1166. 
 
    1166.           */
      1167. 
-
    1167.          reverseOrder: function () {
      1168. 
-
    1168. 16            return this.reverse.apply(this, arguments);
      1169. 
+
    1169.          join: function () {
      1170. 
+
    1170. 212            return this.innerJoin.apply(this, arguments);
      1171. 
 
    1171.          },
      1172. 
 
    1172.  
      1173. 
 
    1173.          /**
      1174. 
-
    1174.           * Returns a copy of the dataset with the columns selected changed
      1175. 
-
    1175.           * to the given columns. This also takes a function similar to {@link patio.Dataset#filter}
      1176. 
+
    1176.           * Returns a joined dataset.  Uses the following arguments:
      1177. 
 
    1177.           *
      1178. 
 
    1178.           * @example
      1179. 
-
    1179.           *   DB.from("items").select("a");
      1180. 
-
    1180.           *      //=> SELECT a FROM items
      1181. 
 
    1181.           *
      1182. 
-
    1182.           *   DB.from("items").select("a", "b");
      1183. 
-
    1183.           *      //=> SELECT a, b FROM items
      1184. 
+
    1184.           * DB.from("items").joinTable("leftOuter", "categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
      1185. 
+
    1185.           *      //=>'SELECT
      1186. 
+
    1186.           *             *
      1187. 
+
    1187.           *            FROM
      1188. 
+
    1188.           *              `items`
      1189. 
+
    1189.           *                  LEFT OUTER JOIN
      1190. 
+
    1190.           *              `categories` ON (
      1191. 
+
    1191.           *                          (`categories`.`categoryId` = `items`.`id`)
      1192. 
+
    1192.           *                              AND
      1193. 
+
    1193.           *                          (`categories`.`categoryId` IN (1,2, 3))
      1194. 
+
    1194.           *                          )
      1195. 
+
    1195.           * DB.from("items").leftOuter("categories", [["categoryId", "id"],["categoryId", [1, 2, 3]]]).sql;
      1196. 
+
    1196.           *      //=>'SELECT
      1197. 
+
    1197.           *             *
      1198. 
+
    1198.           *            FROM
      1199. 
+
    1199.           *              `items`
      1200. 
+
    1200.           *                  LEFT OUTER JOIN
      1201. 
+
    1201.           *              `categories` ON (
      1202. 
+
    1202.           *                          (`categories`.`categoryId` = `items`.`id`)
      1203. 
+
    1203.           *                              AND
      1204. 
+
    1204.           *                          (`categories`.`categoryId` IN (1,2, 3))
      1205. 
+
    1205.           *                          )
      1206. 
 
    1206.           *
      1207. 
-
    1207.           *   DB.from("items").select("a", function(){
      1208. 
-
    1208.           *          return this.sum("b")
      1209. 
-
    1209.           *   }).sql;  //=> SELECT a, sum(b) FROM items
      1210. 
+
    1210.           * DB.from("items").leftOuterJoin("categories", {categoryId:"id"}).sql
      1211. 
+
    1211.           *          //=> SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1212. 
 
    1212.           *
      1213. 
-
    1213.           *  @param {String|patio.sql.Identifier|Function} args variable number of colums to select
      1214. 
-
    1214.           *  @return {patio.Dataset} a cloned dataset with the columns selected changed.
      1215. 
-
    1215.           */
      1216. 
-
    1216.          select: function (args) {
      1217. 
-
    1217. 663            args = flatten(argsToArray(arguments));
      1218. 
-
    1218. 663            var columns = [];
      1219. 
-
    1219. 663            args.forEach(function (c) {
      1220. 
-
    1220. 1043                if (isFunction(c)) {
      1221. 
-
    1221. 23                    var res = c.apply(sql, [sql]);
      1222. 
-
    1222. 23                    columns = columns.concat(isArray(res) ? res : [res]);
      1223. 
-
    1223.                  } else {
      1224. 
-
    1224. 1020                    columns.push(c);
      1225. 
-
    1225.                  }
      1226. 
-
    1226.              });
      1227. 
-
    1227. 663            var select = [];
      1228. 
-
    1228. 663            columns.forEach(function (c) {
      1229. 
-
    1229. 1046                if (isHash(c)) {
      1230. 
-
    1230. 3                    for (var i in c) {
      1231. 
-
    1231. 4                        select.push(new AliasedExpression(new Identifier(i), c[i]));
      1232. 
-
    1232.                      }
      1233. 
-
    1233. 1043                } else if (isString(c)) {
      1234. 
-
    1234. 344                    select.push(this.stringToIdentifier(c));
      1235. 
-
    1235.                  } else {
      1236. 
-
    1236. 699                    select.push(c);
      1237. 
-
    1237.                  }
      1238. 
-
    1238.              }, this);
      1239. 
-
    1239. 663            return this.mergeOptions({select: select});
      1240. 
-
    1240.  
      1241. 
-
    1241.          },
      1242. 
-
    1242.  
      1243. 
-
    1243.          /**
      1244. 
-
    1244.           * Returns a cloned dataset that selects *.
      1245. 
+
    1245.           * DB.from("items").rightOuterJoin("categories", {categoryId:"id"}).sql
      1246. 
+
    1246.           *          //=> SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1247. 
 
    1247.           *
      1248. 
-
    1248.           * @return {patio.Dataset}  a cloned dataset that selects *.
      1249. 
-
    1249.           */
      1250. 
-
    1250.          selectAll: function () {
      1251. 
-
    1251. 6            return this.mergeOptions({select: null});
      1252. 
-
    1252.          },
      1253. 
-
    1253.  
      1254. 
-
    1254.          /**
      1255. 
-
    1255.           * Selects the columns if only if there is not already select sources.
      1256. 
+
    1256.           * DB.from("items").fullOuterJoin("categories", {categoryId:"id"}).sql
      1257. 
+
    1257.           *          //=> SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1258. 
 
    1258.           *
      1259. 
-
    1259.           * @example
      1260. 
+
    1260.           * DB.from("items").innerJoin("categories", {categoryId:"id"}).sql
      1261. 
+
    1261.           *          //=> SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1262. 
 
    1262.           *
      1263. 
-
    1263.           * var ds = DB.from("items"); //SELECT * FROM items
      1264. 
+
    1264.           * DB.from("items").leftJoin("categories", {categoryId:"id"}).sql
      1265. 
+
    1265.           *          //=> SELECT * FROM "items" LEFT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1266. 
 
    1266.           *
      1267. 
-
    1267.           * ds.select("a"); //SELECT a FROM items;
      1268. 
-
    1268.           * ds.select("a").selectIfNoSource("a", "b"). //SELECT a FROM items;
      1269. 
-
    1269.           * ds.selectIfNoSource("a", "b"). //SELECT a, b FROM items;
      1270. 
+
    1270.           * DB.from("items").rightJoin("categories", {categoryId:"id"}).sql
      1271. 
+
    1271.           *          //=> SELECT * FROM "items" RIGHT JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1272. 
 
    1272.           *
      1273. 
-
    1273.           * @param cols columns to select if there is not already select sources.
      1274. 
-
    1274.           * @return {patio.Dataset} a cloned dataset with the appropriate select sources.
      1275. 
+
    1275.           * DB.from("items").fullJoin("categories", {categoryId:"id"}).sql
      1276. 
+
    1276.           *          //=> SELECT * FROM "items" FULL JOIN "categories" ON ("categories"."categoryId" = "items"."id")
      1277. 
+
    1277.           *
      1278. 
+
    1278.           * DB.from("items").naturalJoin("categories").sql
      1279. 
+
    1279.           *          //=> SELECT * FROM "items" NATURAL JOIN "categories"
      1280. 
+
    1280.           *
      1281. 
+
    1281.           * DB.from("items").naturalLeftJoin("categories").sql
      1282. 
+
    1282.           *          //=> SELECT * FROM "items" NATURAL LEFT JOIN "categories"
      1283. 
+
    1283.           *
      1284. 
+
    1284.           * DB.from("items").naturalRightJoin("categories").sql
      1285. 
+
    1285.           *          //=> SELECT * FROM "items" NATURAL RIGHT JOIN "categories"
      1286. 
+
    1286.           *
      1287. 
+
    1287.           * DB.from("items").naturalFullJoin("categories").sql
      1288. 
+
    1288.           *          //=> SELECT * FROM "items" NATURAL FULL JOIN "categories"'
      1289. 
+
    1289.           *
      1290. 
+
    1290.           * DB.from("items").crossJoin("categories").sql
      1291. 
+
    1291.           *          //=> SELECT * FROM "items" CROSS JOIN "categories"
      1292. 
+
    1292.           *
      1293. 
+
    1293.           * @param {String} type the type of join to do.
      1294. 
+
    1294.           * @param {String|patio.sql.Identifier|patio.Dataset|Object} table depends on the type.
      1295. 
+
    1295.           *  <ul>
      1296. 
+
    1296.           *      <li>{@link patio.Dataset} - a subselect is performed with an alias</li>
      1297. 
+
    1297.           *      <li>Object - an object that has a tableName property.</li>
      1298. 
+
    1298.           *      <li>String|{@link patio.sql.Identifier}  - the name of the table</li>
      1299. 
+
    1299.           *  </ul>
      1300. 
+
    1300.           * @param [expr] - depends on type
      1301. 
+
    1301.           * <ul>
      1302. 
+
    1302.           *     <li>Object|Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already
      1303. 
+
    1303.           *     qualified), and value (2nd arg) is column of the last joined or primary table (or the
      1304. 
+
    1304.           *     implicitQualifier option</li>.
      1305. 
+
    1305.           *     <li>Array - If all members of the array are string or {@link patio.sql.Identifier}, considers
      1306. 
+
    1306.           *     them as columns and uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
      1307. 
+
    1307.           *     the result set if this is used.</li>
      1308. 
+
    1308.           *     <li>null|undefined(not passed in) - If a cb is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
      1309. 
+
    1309.           *     or CROSS join. If a block is given, uses an ON clause based on the block, see below.</li>
      1310. 
+
    1310.           *     <li>Everything else - pretty much the same as a using the argument in a call to {@link patio.Dataset#filter},
      1311. 
+
    1311.           *     so strings are considered literal, {@link patio.sql.Identifiers} specify boolean columns, and patio.sql
      1312. 
+
    1312.           *      expressions can be used. Uses a JOIN with an ON clause.</li>
      1313. 
+
    1313.           * </ul>
      1314. 
+
    1314.           * @param {Object} options an object of options.
      1315. 
+
    1315.           * @param {String|patio.sql.Identifier} [options.tableAlias=undefined] the name of the table's alias when joining, necessary for joining
      1316. 
+
    1316.           *     to the same table more than once.  No alias is used by default.
      1317. 
+
    1317.           * @param {String|patio.sql.Identifier} [options.implicitQualifier=undefined] The name to use for qualifying implicit conditions.  By default,
      1318. 
+
    1318.           *     the last joined or primary table is used.
      1319. 
+
    1319.           * @param {Function} [cb]  cb - The cb argument should only be given if a JOIN with an ON clause is used,
      1320. 
+
    1320.           *   in which case it is called with
      1321. 
+
    1321.           *   <ul>
      1322. 
+
    1322.           *       <li>table alias/name for the table currently being joined</li>
      1323. 
+
    1323.           *       <li> the table alias/name for the last joined (or first table)
      1324. 
+
    1324.           *       <li>array of previous</li>
      1325. 
+
    1325.           *   </ul>
      1326. 
+
    1326.           *   the cb should return an expression to be used in the ON clause.
      1327. 
+
    1327.           *
      1328. 
+
    1328.           * @return {patio.Dataset} a cloned dataset joined using the arguments.
      1329. 
 
    1329.           */
      1330. 
-
    1330.          selectIfNoSource: function (cols) {
      1331. 
-
    1331. 0            var ret;
      1332. 
-
    1332. 0            if (!this.hasSelectSource) {
      1333. 
-
    1333. 0                ret = this.select.apply(this, arguments);
      1334. 
+
    1334.  
      1335. 
+
    1335.          joinTable: function (type, table, expr, options, cb) {
      1336. 
+
    1336. 634            var args = argsToArray(arguments);
      1337. 
+
    1337. 634            if (isFunction(args[args.length - 1])) {
      1338. 
+
    1338. 12                cb = args[args.length - 1];
      1339. 
+
    1339. 12                args.pop();
      1340. 
+
    1340.              } else {
      1341. 
+
    1341. 622                cb = null;
      1342. 
+
    1342.              }
      1343. 
+
    1343. 634            type = args.shift(), table = args.shift(), expr = args.shift(), options = args.shift();
      1344. 
+
    1344. 634            expr = isUndefined(expr) ? null : expr, options = isUndefined(options) ? {} : options;
      1345. 
+
    1345.  
      1346. 
+
    1346. 634            var h;
      1347. 
+
    1347. 634            var usingJoin = isArray(expr) && expr.length && expr.every(function (x) {
      1348. 
+
    1348. 223                return isString(x) || isInstanceOf(x, Identifier)
      1349. 
+
    1349.              });
      1350. 
+
    1350. 634            if (usingJoin && !this.supportsJoinUsing) {
      1351. 
+
    1351. 1                h = {};
      1352. 
+
    1352. 1                expr.forEach(function (s) {
      1353. 
+
    1353. 1                    h[s] = s;
      1354. 
+
    1354.                  });
      1355. 
+
    1355. 1                return this.joinTable(type, table, h, options);
      1356. 
+
    1356.              }
      1357. 
+
    1357. 633            var tableAlias, lastAlias;
      1358. 
+
    1358. 633            if (isHash(options)) {
      1359. 
+
    1359. 623                tableAlias = options.tableAlias;
      1360. 
+
    1360. 623                lastAlias = options.implicitQualifier;
      1361. 
+
    1361. 10            } else if (isString(options) || isInstanceOf(options, Identifier)) {
      1362. 
+
    1362. 9                tableAlias = options;
      1363. 
+
    1363. 9                lastAlias = null;
      1364. 
+
    1364.              } else {
      1365. 
+
    1365. 1                throw new QueryError("Invalid options format for joinTable %j4", [options]);
      1366. 
+
    1366.              }
      1367. 
+
    1367. 632            var tableAliasNum, tableName;
      1368. 
+
    1368. 632            if (isInstanceOf(table, Dataset)) {
      1369. 
+
    1369. 11                if (!tableAlias) {
      1370. 
+
    1370. 6                    tableAliasNum = (this.__opts.numDatasetSources || 0) + 1;
      1371. 
+
    1371. 6                    tableAlias = this._datasetAlias(tableAliasNum);
      1372. 
+
    1372.                  }
      1373. 
+
    1373. 11                tableName = tableAlias;
      1374. 
+
    1374.              } else {
      1375. 
+
    1375. 621                if (!isUndefined(table.tableName)) {
      1376. 
+
    1376. 1                    table = table.tableName;
      1377. 
+
    1377.                  }
      1378. 
+
    1378. 621                if (isArray(table)) {
      1379. 
+
    1379. 2                    table = table.map(this.stringToIdentifier, this);
      1380. 
+
    1380.                  } else {
      1381. 
+
    1381. 619                    table = isString(table) ? this.stringToIdentifier(table) : table;
      1382. 
+
    1382. 619                    var parts = this._splitAlias(table), implicitTableAlias = parts[1];
      1383. 
+
    1383. 619                    table = parts[0]
      1384. 
+
    1384. 619                    tableAlias = tableAlias || implicitTableAlias;
      1385. 
+
    1385. 619                    tableName = tableAlias || table;
      1386. 
+
    1386.                  }
      1387. 
+
    1387.              }
      1388. 
+
    1388. 632            var join;
      1389. 
+
    1389. 632            if (!expr && !cb) {
      1390. 
+
    1390. 22                join = new JoinClause(type, table, tableAlias);
      1391. 
+
    1391. 610            } else if (usingJoin) {
      1392. 
+
    1392. 9                if (cb) {
      1393. 
+
    1393. 1                    throw new QueryError("cant use a cb if an array is given");
      1394. 
+
    1394.                  }
      1395. 
+
    1395. 8                join = new JoinUsingClause(expr, type, table, tableAlias);
      1396. 
 
    1396.              } else {
      1397. 
-
    1397. 0                ret = this.mergeOptions();
      1398. 
+
    1398. 601                lastAlias = lastAlias || this.__opts["lastJoinedTable"] || this.firstSourceAlias;
      1399. 
+
    1399. 600                if (Expression.isConditionSpecifier(expr)) {
      1400. 
+
    1400. 588                    var newExpr = [];
      1401. 
+
    1401. 588                    for (var i in expr) {
      1402. 
+
    1402. 909                        var val = expr[i];
      1403. 
+
    1403. 909                        if (isArray(val) && val.length == 2) {
      1404. 
+
    1404. 418                            i = val[0], val = val[1];
      1405. 
+
    1405.                          }
      1406. 
+
    1406. 909                        var k = this.qualifiedColumnName(i, tableName), v;
      1407. 
+
    1407. 909                        if (isInstanceOf(val, Identifier)) {
      1408. 
+
    1408. 405                            v = val.qualify(lastAlias);
      1409. 
+
    1409.                          } else {
      1410. 
+
    1410. 504                            v = val;
      1411. 
+
    1411.                          }
      1412. 
+
    1412. 909                        newExpr.push([k, v]);
      1413. 
+
    1413.                      }
      1414. 
+
    1414. 588                    expr = newExpr;
      1415. 
+
    1415.                  }
      1416. 
+
    1416. 600                if (isFunction(cb)) {
      1417. 
+
    1417. 11                    var expr2 = cb.apply(sql, [tableName, lastAlias, this.__opts.join || []]);
      1418. 
+
    1418. 11                    expr = expr ? new BooleanExpression("AND", expr, expr2) : expr2;
      1419. 
+
    1419.                  }
      1420. 
+
    1420. 600                join = new JoinOnClause(expr, type, table, tableAlias);
      1421. 
 
    1421.              }
      1422. 
-
    1422. 0            return ret;
      1423. 
+
    1423. 630            var opts = {join: (this.__opts.join || []).concat([join]), lastJoinedTable: tableName};
      1424. 
+
    1424. 630            if (tableAliasNum) {
      1425. 
+
    1425. 6                opts.numDatasetSources = tableAliasNum;
      1426. 
+
    1426.              }
      1427. 
+
    1427. 630            return this.mergeOptions(opts);
      1428. 
+
    1428.  
      1429. 
 
    1429.          },
      1430. 
 
    1430.  
      1431. 
 
    1431.          /**
      1432. 
-
    1432.           * Returns a copy of the dataset with the given columns added
      1433. 
-
    1433.           * to the existing selected columns. If no columns are currently selected,
      1434. 
-
    1434.           * it will select the columns given in addition to *.
      1435. 
+
    1435.           * If given an integer, the dataset will contain only the first l results.
      1436. 
+
    1436.           If a second argument is given, it is used as an offset. To use
      1437. 
+
    1437.           * an offset without a limit, pass null as the first argument.
      1438. 
 
    1438.           *
      1439. 
 
    1439.           * @example
      1440. 
-
    1440.           *   DB.from("items").select("a").selectAppend("b").sql;
      1441. 
-
    1441.           *      //=> SELECT b FROM items
      1442. 
 
    1442.           *
      1443. 
-
    1443.           *   DB.from("items").select("a").selectAppend("b", "c", "d").sql
      1444. 
-
    1444.           *      //=> SELECT a, b, c, d FROM items
      1445. 
+
    1445.           * DB.from("items").limit(10)
      1446. 
+
    1446.           *      //=> SELECT * FROM items LIMIT 10
      1447. 
+
    1447.           * DB.from("items").limit(10, 20)
      1448. 
+
    1448.           *      //=> SELECT * FROM items LIMIT 10 OFFSET 20
      1449. 
+
    1449.           * DB.from("items").limit([3, 7]).sql
      1450. 
+
    1450.           *      //=> SELECT * FROM items LIMIT 5 OFFSET 3');
      1451. 
+
    1451.           * DB.from("items").limit(null, 20)
      1452. 
+
    1452.           *      //=> SELECT * FROM items OFFSET 20
      1453. 
 
    1453.           *
      1454. 
-
    1454.           *   DB.from("items").selectAppend("b").sql
      1455. 
-
    1455.           *      //=> SELECT *, b FROM items
      1456. 
+
    1456.           * DB.from("items").limit('6', sql['a() - 1']).sql
      1457. 
+
    1457.           *      => 'SELECT * FROM items LIMIT 6 OFFSET a() - 1');
      1458. 
 
    1458.           *
      1459. 
-
    1459.           * @param [...] cols variable number of columns to add to the select statement
      1460. 
+
    1460.           * @param {Number|String|Number[]} limit the limit to apply
      1461. 
+
    1461.           * @param {Number|String|patio.sql.LiteralString} offset the offset to apply
      1462. 
 
    1462.           *
      1463. 
-
    1463.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      1464. 
-
    1464.           */
      1465. 
-
    1465.          selectAppend: function (cols) {
      1466. 
-
    1466. 7            cols = argsToArray(arguments);
      1467. 
-
    1467. 7            var currentSelect = this.__opts.select;
      1468. 
-
    1468. 7            if (!currentSelect || !currentSelect.length) {
      1469. 
-
    1469. 3                currentSelect = [this._static.WILDCARD];
      1470. 
+
    1470.           * @return {patio.Dataset}  a cloned dataset witht the LIMIT and OFFSET applied.
      1471. 
+
    1471.           **/
      1472. 
+
    1472.          limit: function (limit, offset) {
      1473. 
+
    1473. 46            if (this.__opts.sql) {
      1474. 
+
    1474. 7                return this.fromSelf().limit(limit, offset);
      1475. 
 
    1475.              }
      1476. 
-
    1476. 7            return this.select.apply(this, currentSelect.concat(cols));
      1477. 
+
    1477. 39            if (isArray(limit) && limit.length == 2) {
      1478. 
+
    1478. 1                offset = limit[0];
      1479. 
+
    1479. 1                limit = limit[1] - limit[0] + 1;
      1480. 
+
    1480.              }
      1481. 
+
    1481. 39            if (isString(limit) || isInstanceOf(limit, LiteralString)) {
      1482. 
+
    1482. 2                limit = parseInt("" + limit, 10);
      1483. 
+
    1483.              }
      1484. 
+
    1484. 39            if (isNumber(limit) && limit < 1) {
      1485. 
+
    1485. 2                throw new QueryError("Limit must be >= 1");
      1486. 
+
    1486.              }
      1487. 
+
    1487. 37            var opts = {limit: limit};
      1488. 
+
    1488. 37            if (offset) {
      1489. 
+
    1489. 9                if (isString(offset) || isInstanceOf(offset, LiteralString)) {
      1490. 
+
    1490. 1                    offset = parseInt("" + offset, 10);
      1491. 
+
    1491. 1                    isNaN(offset) && (offset = 0);
      1492. 
+
    1492.                  }
      1493. 
+
    1493. 9                if (isNumber(offset) && offset < 0) {
      1494. 
+
    1494. 1                    throw new QueryError("Offset must be >= 0");
      1495. 
+
    1495.                  }
      1496. 
+
    1496. 8                opts.offset = offset;
      1497. 
+
    1497.              }
      1498. 
+
    1498. 36            return this.mergeOptions(opts);
      1499. 
 
    1499.          },
      1500. 
 
    1500.  
      1501. 
 
    1501.          /**
      1502. 
-
    1502.           * Returns a copy of the dataset with the given columns added
      1503. 
-
    1503.           * to the existing selected columns. If no columns are currently selected
      1504. 
-
    1504.           * it will just select the columns given.
      1505. 
-
    1505.           *
      1506. 
-
    1506.           * @example
      1507. 
-
    1507.           *   DB.from("items").select("a").select("b").sql;
      1508. 
-
    1508.           *      //=> SELECT b FROM items
      1509. 
 
    1509.           *
      1510. 
-
    1510.           *   DB.from("items").select("a").selectMore("b", "c", "d").sql
      1511. 
-
    1511.           *      //=> SELECT a, b, c, d FROM items
      1512. 
+
    1512.           * Returns a cloned dataset with a not equal expression added to the WHERE
      1513. 
+
    1513.           * clause.
      1514. 
 
    1514.           *
      1515. 
-
    1515.           *   DB.from("items").selectMore("b").sql
      1516. 
-
    1516.           *      //=> SELECT b FROM items
      1517. 
+
    1517.           * @example
      1518. 
+
    1518.           *  DB.from("test").neq({x : 1});
      1519. 
+
    1519.           *          //=> SELECT * FROM test WHERE (x != 1)
      1520. 
+
    1520.           *  DB.from("test").neq({x : 1, y : 10});
      1521. 
+
    1521.           *          //=> SELECT * FROM test WHERE ((x != 1) AND (y != 10))
      1522. 
 
    1522.           *
      1523. 
-
    1523.           * @param [...] cols variable number of columns to add to the select statement
      1524. 
+
    1524.           * @param {Object} obj object used to create the not equal expression
      1525. 
 
    1525.           *
      1526. 
-
    1526.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      1527. 
+
    1527.           * @return {patio.Dataset} a cloned dataset with the not equal expression added to the WHERE clause.
      1528. 
 
    1528.           */
      1529. 
-
    1529.          selectMore: function (cols) {
      1530. 
-
    1530. 10            cols = argsToArray(arguments);
      1531. 
-
    1531. 10            var currentSelect = this.__opts.select;
      1532. 
-
    1532. 10            return this.select.apply(this, (currentSelect || []).concat(cols));
      1533. 
+
    1533.          neq: function (obj) {
      1534. 
+
    1534. 2            return this.filter(this.__createBoolExpression("neq", obj));
      1535. 
 
    1535.          },
      1536. 
 
    1536.  
      1537. 
 
    1537.          /**
      1538. 
-
    1538.           * Set the default values for insert and update statements.  The values hash passed
      1539. 
-
    1539.           * to insert or update are merged into this hash, so any values in the hash passed
      1540. 
-
    1540.           * to insert or update will override values passed to this method.
      1541. 
-
    1541.           *
      1542. 
-
    1542.           *  @example
      1543. 
-
    1543.           *   DB.from("items").setDefaults({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      1544. 
-
    1544.           *      //=> INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
      1545. 
-
    1545.           *
      1546. 
-
    1546.           * @param {Object} hash object with key value pairs to use as override values
      1547. 
 
    1547.           *
      1548. 
-
    1548.           * @return {patio.Dataset} a cloned dataset with the defaults added to the current datasets defaults.
      1549. 
-
    1549.           */
      1550. 
-
    1550.          setDefaults: function (hash) {
      1551. 
-
    1551. 5            return this.mergeOptions({defaults: merge({}, this.__opts.defaults || {}, hash)});
      1552. 
-
    1552.          },
      1553. 
-
    1553.  
      1554. 
-
    1554.          /**
      1555. 
-
    1555.           * Set values that override hash arguments given to insert and update statements.
      1556. 
-
    1556.           * This hash is merged into the hash provided to insert or update, so values
      1557. 
-
    1557.           * will override any values given in the insert/update hashes.
      1558. 
+
    1558.           * Returns a cloned dataset with an equal expression added to the WHERE
      1559. 
+
    1559.           * clause.
      1560. 
 
    1560.           *
      1561. 
 
    1561.           * @example
      1562. 
-
    1562.           *   DB.from("items").setOverrides({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      1563. 
-
    1563.           *      //=> INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
      1564. 
+
    1564.           *  DB.from("test").eq({x : 1});
      1565. 
+
    1565.           *          //=> SELECT * FROM test WHERE (x = 1)
      1566. 
+
    1566.           *  DB.from("test").eq({x : 1, y : 10});
      1567. 
+
    1567.           *          //=> SELECT * FROM test WHERE ((x = 1) AND (y = 10))
      1568. 
 
    1568.           *
      1569. 
-
    1569.           * @param {Object} hash object with key value pairs to use as override values
      1570. 
+
    1570.           * @param {Object} obj object used to create the equal expression
      1571. 
 
    1571.           *
      1572. 
-
    1572.           * @return {patio.Dataset} a cloned dataset with the overrides added to the current datasets overrides.
      1573. 
+
    1573.           * @return {patio.Dataset} a cloned dataset with the equal expression added to the WHERE clause.
      1574. 
 
    1574.           */
      1575. 
-
    1575.          setOverrides: function (hash) {
      1576. 
-
    1576. 5            return this.mergeOptions({overrides: merge({}, this.__opts.overrides || {}, hash)});
      1577. 
+
    1577.          eq: function (obj) {
      1578. 
+
    1578. 2            return this.filter(this.__createBoolExpression("eq", obj));
      1579. 
 
    1579.          },
      1580. 
 
    1580.  
      1581. 
 
    1581.          /**
      1582. 
-
    1582.           * Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
      1583. 
-
    1583.           * @example
      1584. 
-
    1584.           *  DB.from("items").group("a").having({a : 1}).where("b").unfiltered().sql;
      1585. 
-
    1585.           *      //=> SELECT * FROM items GROUP BY a
      1586. 
 
    1586.           *
      1587. 
-
    1587.           * @return {patio.Dataset} a cloned dataset with no HAVING or WHERE clause.
      1588. 
-
    1588.           */
      1589. 
-
    1589.          unfiltered: function () {
      1590. 
-
    1590. 14            return this.mergeOptions({where: null, having: null});
      1591. 
-
    1591.          },
      1592. 
-
    1592.  
      1593. 
-
    1593.          /**
      1594. 
-
    1594.           * Returns a copy of the dataset with no GROUP or HAVING clause.
      1595. 
+
    1595.           * Returns a cloned dataset with a greater than expression added to the WHERE
      1596. 
+
    1596.           * clause.
      1597. 
 
    1597.           *
      1598. 
 
    1598.           * @example
      1599. 
-
    1599.           *  DB.from("t").group("a").having({a : 1}).where("b").ungrouped().sql;
      1600. 
-
    1600.           *      //=> SELECT * FROM t WHERE b
      1601. 
+
    1601.           *  DB.from("test").gt({x : 1});
      1602. 
+
    1602.           *          //=> SELECT * FROM test WHERE (x > 1)
      1603. 
+
    1603.           *  DB.from("test").gt({x : 1, y : 10});
      1604. 
+
    1604.           *          //=> SELECT * FROM test WHERE ((x > 1) AND (y > 10))
      1605. 
 
    1605.           *
      1606. 
-
    1606.           * @return {patio.Dataset} a cloned dataset with no GROUP or HAVING clause.
      1607. 
+
    1607.           * @param {Object} obj object used to create the greater than expression.
      1608. 
+
    1608.           *
      1609. 
+
    1609.           * @return {patio.Dataset} a cloned dataset with the greater than expression added to the WHERE clause.
      1610. 
 
    1610.           */
      1611. 
-
    1611.          ungrouped: function () {
      1612. 
-
    1612. 1            return this.mergeOptions({group: null, having: null});
      1613. 
+
    1613.          gt: function (obj) {
      1614. 
+
    1614. 2            return this.filter(this.__createBoolExpression("gt", obj));
      1615. 
 
    1615.          },
      1616. 
 
    1616.  
      1617. 
 
    1617.          /**
      1618. 
-
    1618.           * Adds a UNION clause using a second dataset object.
      1619. 
-
    1619.           * A UNION compound dataset returns all rows in either the current dataset
      1620. 
-
    1620.           * or the given dataset.
      1621. 
-
    1621.           * Options:
      1622. 
-
    1622.           * :alias :: Use the given value as the from_self alias
      1623. 
-
    1623.           * :all :: Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
      1624. 
-
    1624.           * :from_self :: Set to false to not wrap the returned dataset in a from_self, use with care.
      1625. 
-
    1625.           *
      1626. 
-
    1626.           * @example
      1627. 
-
    1627.           * DB.from("items").union(DB.from("otherItems")).sql;
      1628. 
-
    1628.           *      //=> SELECT * FROM items UNION SELECT * FROM other_items
      1629. 
-
    1629.           *
      1630. 
-
    1630.           * DB.from("items").union(DB.from("otherItems"), {all : true, fromSelf : false}).sql;
      1631. 
-
    1631.           *      //=> SELECT * FROM items UNION ALL SELECT * FROM other_items
      1632. 
 
    1632.           *
      1633. 
-
    1633.           * DB.from("items").union(DB.from("otherItems"), {alias : "i"})
      1634. 
-
    1634.           *      //=> SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS i
      1635. 
+
    1635.           * Returns a cloned dataset with a less than expression added to the WHERE
      1636. 
+
    1636.           * clause.
      1637. 
 
    1637.           *
      1638. 
-
    1638.           * @param {patio.Dataset} dataset dataset to union with
      1639. 
-
    1639.           * @param {Object} opts addional options
      1640. 
-
    1640.           * @param {String|patio.sql.Identifier} [opts.alias] Alias to use as the fromSelf alias.
      1641. 
-
    1641.           * @param {Boolean} [opt.all=false] Set to true to use UNION ALL instead of UNION so duplicate rows can occur
      1642. 
-
    1642.           * @param {Boolean} [opts.fromSelf=true] Set to false to not wrap the returned dataset in a fromSelf.
      1643. 
+
    1643.           * @example
      1644. 
+
    1644.           *  DB.from("test").lt({x : 1});
      1645. 
+
    1645.           *          //=> SELECT * FROM test WHERE (x < 1)
      1646. 
+
    1646.           *  DB.from("test").lt({x : 1, y : 10});
      1647. 
+
    1647.           *          //=> SELECT * FROM test WHERE ((x < 1) AND (y < 10))
      1648. 
 
    1648.           *
      1649. 
-
    1649.           * @return {patio.Dataset} a cloned dataset with the union.
      1650. 
+
    1650.           * @param {Object} obj object used to create the less than expression.
      1651. 
 
    1651.           *
      1652. 
+
    1652.           * @return {patio.Dataset} a cloned dataset with the less than expression added to the WHERE clause.
      1653. 
 
    1653.           */
      1654. 
-
    1654.          union: function (dataset, opts) {
      1655. 
-
    1655. 21            opts = isUndefined(opts) ? {} : opts;
      1656. 
-
    1656. 21            if (!isHash(opts)) {
      1657. 
-
    1657. 3                opts = {all: opts};
      1658. 
-
    1658.              }
      1659. 
-
    1659. 21            return this.compoundClone("union", dataset, opts);
      1660. 
+
    1660.          lt: function (obj) {
      1661. 
+
    1661. 2            return this.filter(this.__createBoolExpression("lt", obj));
      1662. 
 
    1662.          },
      1663. 
 
    1663.  
      1664. 
 
    1664.          /**
      1665. 
-
    1665.           * Returns a copy of the dataset with no limit or offset.
      1666. 
+
    1666.           * Returnes a cloned dataset with the IS NOT expression added to the WHERE
      1667. 
+
    1667.           * clause.
      1668. 
 
    1668.           *
      1669. 
 
    1669.           * @example
      1670. 
-
    1670.           *  DB.from("t").limit(10, 20).unlimited().sql;
      1671. 
-
    1671.           *      //=> SELECT * FROM t
      1672. 
-
    1672.           *
      1673. 
-
    1673.           * @return {patio.Dataset} a cloned dataset with no limit or offset.
      1674. 
-
    1674.           */
      1675. 
-
    1675.          unlimited: function () {
      1676. 
-
    1676. 1            return this.mergeOptions({limit: null, offset: null});
      1677. 
-
    1677.          },
      1678. 
-
    1678.  
      1679. 
-
    1679.          /**
      1680. 
-
    1680.           * Returns a copy of the dataset with no order.
      1681. 
 
    1681.           *
      1682. 
-
    1682.           * @example
      1683. 
-
    1683.           *  DB.from("t").order("a", sql.identifier("b").desc()).unordered().sql;
      1684. 
-
    1684.           *      //=> SELECT * FROM t
      1685. 
+
    1685.           * DB.from("test").isNot({boolFlag : null});
      1686. 
+
    1686.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      1687. 
+
    1687.           * DB.from("test").isNot({boolFlag : false, otherFlag : true, name : null});
      1688. 
+
    1688.           *      => SELECT * FROM test WHERE ((boolFlag IS NOT FALSE) AND (otherFlag IS NOT TRUE) AND (name IS NOT NULL));
      1689. 
 
    1689.           *
      1690. 
-
    1690.           * @return {patio.Dataset} a cloned dataset with no order.
      1691. 
-
    1691.           */
      1692. 
-
    1692.          unordered: function () {
      1693. 
-
    1693. 115            return this.order(null);
      1694. 
-
    1694.          },
      1695. 
-
    1695.  
      1696. 
-
    1696.          /**
      1697. 
-
    1697.           * Add a condition to the WHERE clause.  See {@link patio.Dataset#filter} for argument types.
      1698. 
+
    1698.           * @param {Object} obj object used to create the IS NOT expression for.
      1699. 
 
    1699.           *
      1700. 
-
    1700.           * @example
      1701. 
-
    1701.           *   DB.from("test").where('price < ? AND id in ?', 100, [1, 2, 3]).sql;
      1702. 
-
    1702.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
      1703. 
-
    1703.           *   DB.from("test").where('price < {price} AND id in {ids}', {price:100, ids:[1, 2, 3]}).sql;
      1704. 
-
    1704.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))")
      1705. 
+
    1705.           * @return {patio.Dataset} a cloned dataset with the IS NOT expression added to the WHERE clause.
      1706. 
 
    1706.           *
      1707. 
 
    1707.           */
      1708. 
-
    1708.          where: function () {
      1709. 
-
    1709. 252            return this._filter.apply(this, ["where"].concat(argsToArray(arguments)));
      1710. 
+
    1710.          isNot: function (obj) {
      1711. 
+
    1711. 4            return this.filter(this.__createBoolExpression("isNot", obj));
      1712. 
 
    1712.          },
      1713. 
 
    1713.  
      1714. 
 
    1714.          /**
      1715. 
-
    1715.           * Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
      1716. 
-
    1716.           * A common table expression acts as an inline view for the query.
      1717. 
+
    1717.           * Returnes a cloned dataset with the IS expression added to the WHERE
      1718. 
+
    1718.           * clause.
      1719. 
 
    1719.           *
      1720. 
-
    1720.           * @name with
      1721. 
 
    1721.           * @example
      1722. 
 
    1722.           *
      1723. 
-
    1723.           * DB.from("t")["with"]("t", db.from("x"))["with"]("j", db.from("y")).sql;
      1724. 
-
    1724.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y) SELECT * FROM t'
      1725. 
-
    1725.           *
      1726. 
-
    1726.           * DB.from("t")["with"]("t", db.from("x")).withRecursive("j", db.from("y"), db.from("j")).sql;
      1727. 
-
    1727.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
      1728. 
+
    1728.           * DB.from("test").is({boolFlag : null});
      1729. 
+
    1729.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      1730. 
+
    1730.           * DB.from("test").is({boolFlag : false, otherFlag : true, name : null});
      1731. 
+
    1731.           *      => SELECT * FROM test WHERE ((boolFlag IS FALSE) AND (otherFlag IS TRUE) AND (name IS NULL));
      1732. 
 
    1732.           *
      1733. 
-
    1733.           * DB.from("t")["with"]("t", db.from("x"), {args:["b"]}).sql;
      1734. 
-
    1734.           *      //=> 'WITH t(b) AS (SELECT * FROM x) SELECT * FROM t'
      1735. 
+
    1735.           * @param {Object} obj object used to create the IS expression for.
      1736. 
 
    1736.           *
      1737. 
-
    1737.           * @param {String} name the name of the to assign to the CTE.
      1738. 
-
    1738.           * @param {patio.Dataset} dataset the dataset to use for the CTE.
      1739. 
-
    1739.           * @param {Object} opts extra options.
      1740. 
-
    1740.           * @param {String[]} [opts.args] colums/args for the CTE.
      1741. 
-
    1741.           * @param {Boolean} [opts.recursive] set to true that the CTE is recursive.
      1742. 
+
    1742.           * @return {patio.Dataset} a cloned dataset with the IS expression added to the WHERE clause.
      1743. 
 
    1743.           *
      1744. 
-
    1744.           * @return {patio.Dataset} a cloned dataset with the CTE.
      1745. 
 
    1745.           */
      1746. 
-
    1746.          "with": function (name, dataset, opts) {
      1747. 
-
    1747. 6            if (!this.supportsCte) {
      1748. 
-
    1748. 1                throw new QueryError("this dataset does not support common table expressions");
      1749. 
-
    1749.              }
      1750. 
-
    1750. 5            return this.mergeOptions({
      1751. 
-
    1751.                  "with": (this.__opts["with"] || []).concat([merge(opts || {}, {name: this.stringToIdentifier(name), dataset: dataset})])
      1752. 
-
    1752.              });
      1753. 
+
    1753.          is: function (obj) {
      1754. 
+
    1754. 4            return this.filter(this.__createBoolExpression("is", obj));
      1755. 
 
    1755.          },
      1756. 
 
    1756.  
      1757. 
 
    1757.          /**
      1758. 
-
    1758.           * Add a recursive common table expression (CTE) with the given name, a dataset that
      1759. 
-
    1759.           * defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
      1760. 
-
    1760.           * of the CTE.
      1761. 
-
    1761.           *
      1762. 
-
    1762.           *  @example
      1763. 
-
    1763.           *
      1764. 
-
    1764.           * //Sing withRecursive call.
      1765. 
-
    1765.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t")).sql;
      1766. 
-
    1766.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      1767. 
+
    1767.           * Returnes a cloned dataset with the IS NOT NULL boolean expression added to the WHERE
      1768. 
+
    1768.           * clause.
      1769. 
 
    1769.           *
      1770. 
-
    1770.           * //Multiple withRecursive calls.
      1771. 
-
    1771.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"))
      1772. 
-
    1772.           *    .withRecursive("j", db.from("y"), db.from("j")).sql;
      1773. 
-
    1773.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t),
      1774. 
-
    1774.           *                     j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t';
      1775. 
+
    1775.           * @example
      1776. 
 
    1776.           *
      1777. 
-
    1777.           * //Adding args
      1778. 
-
    1778.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {args:["b", "c"]}).sql;
      1779. 
-
    1779.           *          //=> 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      1780. 
+
    1780.           * DB.from("test").isNotNull("boolFlag");
      1781. 
+
    1781.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL);
      1782. 
+
    1782.           * DB.from("test").isNotNull("boolFlag", "otherFlag");
      1783. 
+
    1783.           *      => SELECT * FROM test WHERE (boolFlag IS NOT NULL AND otherFlag IS NOT NULL);
      1784. 
 
    1784.           *
      1785. 
-
    1785.           * //Setting union all to false
      1786. 
-
    1786.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {unionAll:false}).sql;
      1787. 
-
    1787.           *          //=> 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t');
      1788. 
+
    1788.           * @param {String...} arr variable number of arguments to create an IS NOT NULL expression for.
      1789. 
 
    1789.           *
      1790. 
-
    1790.           * @param {String} name the name to assign to the CTE
      1791. 
-
    1791.           * @param {patio.Dataset} nonRecursive the non-recursive part of the CTE
      1792. 
-
    1792.           * @param {patio.Dataset} recursive the recursive part of the CTE
      1793. 
-
    1793.           * @param {Object} [opts={}] extra options
      1794. 
-
    1794.           * @param {String[]} [opts.args] columns to include with the CTE
      1795. 
-
    1795.           * @param {Boolena} [opts.unionAll] set to false to use UNION instead of UNION ALL when combining non recursive
      1796. 
-
    1796.           *                                with recursive.
      1797. 
+
    1797.           * @return {patio.Dataset} a cloned dataset with the IS NOT NULL expression added to the WHERE clause.
      1798. 
 
    1798.           *
      1799. 
-
    1799.           * @return {patio.Dataset} a cloned dataset with the CTE.
      1800. 
 
    1800.           */
      1801. 
-
    1801.          withRecursive: function (name, nonRecursive, recursive, opts) {
      1802. 
-
    1802. 7            if (!this.supportsCte) {
      1803. 
-
    1803. 1                throw new QueryError("This dataset does not support common table expressions");
      1804. 
-
    1804.              }
      1805. 
-
    1805. 6            opts = opts || {};
      1806. 
-
    1806. 6            var wit = (this.__opts["with"] || []).concat([merge(opts, {recursive: true, name: this.stringToIdentifier(name), dataset: nonRecursive.union(recursive, {all: opts.unionAll != false, fromSelf: false})})]);
      1807. 
-
    1807. 6            return this.mergeOptions({"with": wit});
      1808. 
+
    1808.          isNotNull: function (arr) {
      1809. 
+
    1809. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      1810. 
+
    1810. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      1811. 
 
    1811.          },
      1812. 
 
    1812.  
      1813. 
 
    1813.          /**
      1814. 
-
    1814.           * Returns a copy of the dataset with the static SQL used.  This is useful if you want
      1815. 
-
    1815.           * to keep the same {@link patio.Dataset#rowCb}/{@link patio.Dataset#graph},
      1816. 
-
    1816.           *  but change the SQL used to custom SQL.
      1817. 
+
    1817.           * Returnes a cloned dataset with the IS NULL boolean expression added to the WHERE
      1818. 
+
    1818.           * clause.
      1819. 
 
    1819.           *
      1820. 
 
    1820.           * @example
      1821. 
-
    1821.           *  DB.from("items").withSql('SELECT * FROM foo')
      1822. 
-
    1822.           *          //=> SELECT * FROM foo
      1823. 
 
    1823.           *
      1824. 
-
    1824.           *  @param {String} sql sql for the dataset to use.
      1825. 
+
    1825.           * DB.from("test").isNull("boolFlag");
      1826. 
+
    1826.           *      => SELECT * FROM test WHERE (boolFlag IS NULL);
      1827. 
+
    1827.           * DB.from("test").isNull("boolFlag", "otherFlag");
      1828. 
+
    1828.           *      => SELECT * FROM test WHERE (boolFlag IS NULL AND otherFlag IS NULL);
      1829. 
 
    1829.           *
      1830. 
-
    1830.           *  @return {patio.Dataset} a cloned dataset with the static sql set.
      1831. 
-
    1831.           */
      1832. 
-
    1832.          withSql: function (sql) {
      1833. 
-
    1833. 46            var args = argsToArray(arguments).slice(1);
      1834. 
-
    1834. 46            if (args.length) {
      1835. 
-
    1835. 23                sql = new PlaceHolderLiteralString(sql, args)
      1836. 
-
    1836.              }
      1837. 
-
    1837. 46            return this.mergeOptions({sql: sql});
      1838. 
-
    1838.          },
      1839. 
-
    1839.  
      1840. 
-
    1840.  
      1841. 
-
    1841.          /**
      1842. 
-
    1842.           * Add the dataset to the list of compounds
      1843. 
+
    1843.           * @param {String...} arr variable number of arguments to create an IS NULL expression for.
      1844. 
 
    1844.           *
      1845. 
-
    1845.           * @param {String} type the type of compound (i.e. "union", "intersect")
      1846. 
-
    1846.           * @param {patio.Dataset} dataset the dataset to add to
      1847. 
-
    1847.           * @param [Object] [options={}] compound option to use (i.e {all : true})
      1848. 
+
    1848.           * @return {patio.Dataset} a cloned dataset with the IS NULL expression added to the WHERE clause.
      1849. 
 
    1849.           *
      1850. 
-
    1850.           * @return {patio.Dataset} ds with the dataset added to the compounds.
      1851. 
 
    1851.           */
      1852. 
-
    1852.          compoundClone: function (type, dataset, options) {
      1853. 
-
    1853. 51            var ds = this._compoundFromSelf().mergeOptions({compounds: (array.toArray(this.__opts.compounds || [])).concat([
      1854. 
-
    1854.                  [type, dataset._compoundFromSelf(), options.all]
      1855. 
-
    1855.              ])});
      1856. 
-
    1856. 51            return options.fromSelf === false ? ds : ds.fromSelf(options);
      1857. 
+
    1857.          isNull: function (arr) {
      1858. 
+
    1858. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), null);
      1859. 
+
    1859. 2            return this.filter(this.__createBoolExpression("is", arr));
      1860. 
 
    1860.          },
      1861. 
 
    1861.  
      1862. 
 
    1862.          /**
      1863. 
-
    1863.           * Returns the a cloned dataset with out the {@link patio.Dataset#rowCb}
      1864. 
+
    1864.           * Returnes a cloned dataset with the IS NOT TRUE boolean expression added to the WHERE
      1865. 
+
    1865.           * clause.
      1866. 
 
    1866.           *
      1867. 
 
    1867.           * @example
      1868. 
-
    1868.           * var ds = DB.from("test");
      1869. 
-
    1869.           * ds.rowCb = function(r){
      1870. 
-
    1870.           *     r.a = r.a * 2;
      1871. 
-
    1871.           * }
      1872. 
 
    1872.           *
      1873. 
-
    1873.           * ds.all().then(function(ret){
      1874. 
-
    1874.           *      //ret === [{a : 4}, {a : 6}]
      1875. 
-
    1875.           * });
      1876. 
-
    1876.           * ds.naked().all().then(function(ret){
      1877. 
-
    1877.           *      //ret ===  [{a : 2}, {a : 3}];
      1878. 
-
    1878.           * });
      1879. 
+
    1879.           * DB.from("test").isNotTrue("boolFlag");
      1880. 
+
    1880.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE);
      1881. 
+
    1881.           * DB.from("test").isNotTrue("boolFlag", "otherFlag");
      1882. 
+
    1882.           *      => SELECT * FROM test WHERE (boolFlag IS NOT TRUE AND otherFlag IS NOT TRUE);
      1883. 
 
    1883.           *
      1884. 
-
    1884.           * @return {patio.Dataset} a cloned dataset with out the {@link patio.Dataset#rowCb}
      1885. 
-
    1885.           */
      1886. 
-
    1886.          naked: function () {
      1887. 
-
    1887. 2266            var ds = this.mergeOptions({});
      1888. 
-
    1888. 2266            ds.rowCb = null;
      1889. 
-
    1889. 2266            return ds;
      1890. 
-
    1890.          },
      1891. 
-
    1891.  
      1892. 
-
    1892.          /**
      1893. 
-
    1893.           * @private
      1894. 
-
    1894.           * Protected
      1895. 
+
    1895.           * @param {String...} arr variable number of arguments to create an IS NOT TRUE expression for.
      1896. 
 
    1896.           *
      1897. 
-
    1897.           * Internal filter method so it works on either the having or where clauses.
      1898. 
-
    1898.           */
      1899. 
-
    1899.          _filter: function (clause) {
      1900. 
-
    1900. 3765            var cond = argsToArray(arguments).slice(1), cb;
      1901. 
-
    1901. 3765            if (cond.length && isFunction(cond[cond.length - 1])) {
      1902. 
-
    1902. 59                cb = cond.pop();
      1903. 
-
    1903.              }
      1904. 
-
    1904. 3765            cond = cond.length == 1 ? cond[0] : cond
      1905. 
-
    1905. 3765            if ((cond == null || cond == undefined || cond === "") || (isArray(cond) && cond.length == 0 && !cb) || (isObject(cond) && isEmpty(cond) && !cb)) {
      1906. 
-
    1906. 293                return this.mergeOptions();
      1907. 
-
    1907.              } else {
      1908. 
-
    1908. 3472                cond = this._filterExpr(cond, cb);
      1909. 
-
    1909. 3469                var cl = this.__opts[clause];
      1910. 
-
    1910. 3469                cl && (cond = new BooleanExpression("AND", cl, cond));
      1911. 
-
    1911. 3469                var opts = {};
      1912. 
-
    1912. 3469                opts[clause] = cond;
      1913. 
-
    1913. 3469                return this.mergeOptions(opts);
      1914. 
-
    1914.              }
      1915. 
-
    1915.          },
      1916. 
-
    1916.  
      1917. 
-
    1917.          /**
      1918. 
-
    1918.           * Splits a possible implicit alias, handling both {@link patio.sql.AliasedExpression}s
      1919. 
-
    1919.           * and strings.  Returns an array of two elements, with the first being the
      1920. 
-
    1920.           * main expression, and the second being the alias. Alias may be null if it is a
      1921. 
-
    1921.           * string that does not contain an alias {table}___{alias}.
      1922. 
-
    1922.           */
      1923. 
-
    1923.          _splitAlias: function (c) {
      1924. 
-
    1924. 619            var ret;
      1925. 
-
    1925. 619            if (isInstanceOf(c, AliasedExpression)) {
      1926. 
-
    1926. 5                ret = [c.expression, c.alias];
      1927. 
-
    1927. 614            } else if (isString(c)) {
      1928. 
-
    1928. 0                var parts = this._splitString(c), cTable = parts[0], column = parts[1], alias = parts[2];
      1929. 
-
    1929. 0                if (alias) {
      1930. 
-
    1930. 0                    ret = [cTable ? new QualifiedIdentifier(cTable, column) : column, alias];
      1931. 
-
    1931.                  } else {
      1932. 
-
    1932. 0                    ret = [c, null];
      1933. 
-
    1933.                  }
      1934. 
-
    1934.              } else {
      1935. 
-
    1935. 614                ret = [c, null];
      1936. 
-
    1936.              }
      1937. 
-
    1937. 619            return ret;
      1938. 
-
    1938.          },
      1939. 
-
    1939.  
      1940. 
-
    1940.  
      1941. 
-
    1941.          /**
      1942. 
-
    1942.           * @private
      1943. 
-
    1943.           * Inverts the given order by breaking it into a list of column references
      1944. 
-
    1944.           * and inverting them.
      1945. 
+
    1945.           * @return {patio.Dataset} a cloned dataset with the IS NOT TRUE expression added to the WHERE clause.
      1946. 
 
    1946.           *
      1947. 
-
    1947.           *   ds.invertOrder([sql.identifier("id").desc()]]) //=> [id]
      1948. 
-
    1948.           *   ds.invertOrder("category", sql.identifier("price").desc()]) #=> [category.desc(), price]
      1949. 
 
    1949.           */
      1950. 
-
    1950.  
      1951. 
-
    1951.          _invertOrder: function (order) {
      1952. 
-
    1952. 46            var ret = order;
      1953. 
-
    1953. 46            if (order) {
      1954. 
-
    1954. 45                ret = order.map(function (o) {
      1955. 
-
    1955. 57                    if (isInstanceOf(o, OrderedExpression)) {
      1956. 
-
    1956. 17                        return o.invert();
      1957. 
-
    1957.                      } else {
      1958. 
-
    1958. 40                        return new OrderedExpression(isString(o) ? new Identifier(o) : o);
      1959. 
-
    1959.                      }
      1960. 
-
    1960.                  }, this);
      1961. 
-
    1961.              }
      1962. 
-
    1962. 46            return ret;
      1963. 
+
    1963.          isNotTrue: function (arr) {
      1964. 
+
    1964. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      1965. 
+
    1965. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      1966. 
 
    1966.          },
      1967. 
 
    1967.  
      1968. 
 
    1968.          /**
      1969. 
-
    1969.           * Creates a boolean expression that each key is compared to its value using the provided operator.
      1970. 
+
    1970.           * Returnes a cloned dataset with the IS TRUE boolean expression added to the WHERE
      1971. 
+
    1971.           * clause.
      1972. 
 
    1972.           *
      1973. 
 
    1973.           * @example
      1974. 
 
    1974.           *
      1975. 
-
    1975.           * ds.__createBoolExpression("gt", {x : 1, y:2, z : 5}) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1976. 
-
    1976.           * ds.__createBoolExpression("gt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1977. 
-
    1977.           * ds.__createBoolExpression("lt", {x : 1, y:2, z : 5}) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1978. 
-
    1978.           * ds.__createBoolExpression("lt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1979. 
+
    1979.           * DB.from("test").isTrue("boolFlag");
      1980. 
+
    1980.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE);
      1981. 
+
    1981.           * DB.from("test").isTrue("boolFlag", "otherFlag");
      1982. 
+
    1982.           *      => SELECT * FROM test WHERE (boolFlag IS TRUE AND otherFlag IS TRUE);
      1983. 
 
    1983.           *
      1984. 
-
    1984.           * @param {String} op valid boolean expression operator to capare each K,V pair with
      1985. 
-
    1985.           * @param {Object| Array } obj object or two dimensional array containing key value pairs
      1986. 
+
    1986.           * @param {String...} arr variable number of arguments to create an IS TRUE expression for.
      1987. 
+
    1987.           *
      1988. 
+
    1988.           * @return {patio.Dataset} a cloned dataset with the IS TRUE expression added to the WHERE clause.
      1989. 
 
    1989.           *
      1990. 
-
    1990.           * @return {patio.sql.BooleanExpression} boolean expression joined by a AND of each key value pair compared by the op
      1991. 
 
    1991.           */
      1992. 
-
    1992.          __createBoolExpression: function (op, obj) {
      1993. 
-
    1993. 32            var pairs = [];
      1994. 
-
    1994. 32            if (Expression.isConditionSpecifier(obj)) {
      1995. 
-
    1995. 32                if (isHash(obj)) {
      1996. 
-
    1996. 18                    obj = array.toArray(obj);
      1997. 
-
    1997.                  }
      1998. 
-
    1998. 32                obj.forEach(function (pair) {
      1999. 
-
    1999. 42                    pairs.push(new BooleanExpression(op, new Identifier(pair[0]), pair[1]));
      2000. 
-
    2000.                  });
      2001. 
-
    2001.              }
      2002. 
-
    2002. 32            return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
      2003. 
+
    2003.          isTrue: function (arr) {
      2004. 
+
    2004. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), true);
      2005. 
+
    2005. 2            return this.filter(this.__createBoolExpression("is", arr));
      2006. 
 
    2006.          },
      2007. 
 
    2007.  
      2008. 
 
    2008.          /**
      2009. 
-
    2009.           * @private
      2010. 
-
    2010.           *
      2011. 
-
    2011.           * Creates a boolean expression where the key is '>=' value 1 and '<=' value two.
      2012. 
+
    2012.           * Returnes a cloned dataset with the IS NOT FALSE boolean expression added to the WHERE
      2013. 
+
    2013.           * clause.
      2014. 
 
    2014.           *
      2015. 
 
    2015.           * @example
      2016. 
 
    2016.           *
      2017. 
-
    2017.           * ds.__createBetweenExpression({x : [1,2]}) => //=> WHERE ((x >= 1) AND (x <= 10))
      2018. 
-
    2018.           * ds.__createBetweenExpression({x : [1,2]}, true) => //=> WHERE ((x < 1) OR (x > 10))
      2019. 
+
    2019.           * DB.from("test").isNotFalse("boolFlag");
      2020. 
+
    2020.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE);
      2021. 
+
    2021.           * DB.from("test").isNotFalse("boolFlag", "otherFlag");
      2022. 
+
    2022.           *      => SELECT * FROM test WHERE (boolFlag IS NOT FALSE AND otherFlag IS NOT FALSE);
      2023. 
+
    2023.           * @param {String...} arr variable number of arguments to create an IS NOT FALSE expression for.
      2024. 
 
    2024.           *
      2025. 
-
    2025.           * @param {Object} obj object where the keys are columns and the values are two element arrays.
      2026. 
-
    2026.           * @param {Boolean} [invert] if set to true it inverts the between to make it not between the two values
      2027. 
+
    2027.           * @return {patio.Dataset} a cloned dataset with the IS NOT FALSE expression added to the WHERE clause.
      2028. 
 
    2028.           *
      2029. 
-
    2029.           * @return {patio.sql.BooleanExpression} a boolean expression containing the between expression.
      2030. 
 
    2030.           */
      2031. 
-
    2031.          __createBetweenExpression: function (obj, invert) {
      2032. 
-
    2032. 4            var pairs = [];
      2033. 
-
    2033. 4            for (var i in obj) {
      2034. 
-
    2034. 4                var v = obj[i];
      2035. 
-
    2035. 4                if (isArray(v) && v.length) {
      2036. 
-
    2036. 2                    var ident = this.stringToIdentifier(i);
      2037. 
-
    2037. 2                    pairs.push(new BooleanExpression("AND", new BooleanExpression("gte", ident, v[0]), new BooleanExpression("lte", ident, v[1])));
      2038. 
-
    2038.                  } else {
      2039. 
-
    2039. 2                    throw new QueryError("Between requires an array for the value");
      2040. 
-
    2040.                  }
      2041. 
-
    2041.              }
      2042. 
-
    2042. 2            var ret = pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs))
      2043. 
-
    2043. 2            return invert ? BooleanExpression.invert(ret) : ret;
      2044. 
+
    2044.          isNotFalse: function (arr) {
      2045. 
+
    2045. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      2046. 
+
    2046. 2            return this.filter(this.__createBoolExpression("isNot", arr));
      2047. 
 
    2047.          },
      2048. 
 
    2048.  
      2049. 
-
    2049.  
      2050. 
 
    2050.          /**
      2051. 
-
    2051.           * @private
      2052. 
-
    2052.           * Converts an array to a two dimensional array where the first element
      2053. 
-
    2053.           * is the identifier and the second argument is the value that the value should equal
      2054. 
-
    2054.           * used by is{Null|NotNull|True|NotTrue|False|notFalse} functions to join all the values passed in.
      2055. 
-
    2055.           * @param {String[]|patio.sql.Identifier} arr array of elements to make a condition specifier out of
      2056. 
-
    2056.           * @param defaultOp the value to assign a value if one is not provided.
      2057. 
+
    2057.           * Returnes a cloned dataset with the IS FALSE boolean expression added to the WHERE
      2058. 
+
    2058.           * clause.
      2059. 
+
    2059.           *
      2060. 
+
    2060.           * @example
      2061. 
+
    2061.           *
      2062. 
+
    2062.           * DB.from("test").isFalse("boolFlag");
      2063. 
+
    2063.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE);
      2064. 
+
    2064.           * DB.from("test").isFalse("boolFlag", "otherFlag");
      2065. 
+
    2065.           *      => SELECT * FROM test WHERE (boolFlag IS FALSE AND otherFlag IS FALSE);
      2066. 
+
    2066.           * @param {String...} arr variable number of arguments to create an IS FALSE expression for.
      2067. 
+
    2067.           *
      2068. 
+
    2068.           * @return {patio.Dataset} a cloned dataset with the IS FALSE expression added to the WHERE clause.
      2069. 
 
    2069.           *
      2070. 
-
    2070.           * @return { [[]] } an array of two element arrays.
      2071. 
 
    2071.           */
      2072. 
-
    2072.          __arrayToConditionSpecifier: function (arr, defaultOp) {
      2073. 
-
    2073. 22            var ret = [];
      2074. 
-
    2074. 22            arr.forEach(function (a) {
      2075. 
-
    2075. 28                if (isString(a)) {
      2076. 
-
    2076. 18                    a = this.stringToIdentifier(a);
      2077. 
-
    2077.                  }
      2078. 
-
    2078. 28                if (isInstanceOf(a, Identifier)) {
      2079. 
-
    2079. 18                    ret.push([a, defaultOp]);
      2080. 
-
    2080. 10                } else if (isHash(a)) {
      2081. 
-
    2081. 4                    ret = ret.concat(array.toArray(a));
      2082. 
-
    2082.                  } else {
      2083. 
-
    2083. 6                    throw new QueryError("Invalid condition specifier " + a);
      2084. 
-
    2084.                  }
      2085. 
-
    2085.              }, this);
      2086. 
-
    2086. 16            return ret;
      2087. 
+
    2087.          isFalse: function (arr) {
      2088. 
+
    2088. 3            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), false);
      2089. 
+
    2089. 2            return this.filter(this.__createBoolExpression("is", arr));
      2090. 
 
    2090.          },
      2091. 
 
    2091.  
      2092. 
 
    2092.          /**
      2093. 
-
    2093.           * @private
      2094. 
 
    2094.           *
      2095. 
-
    2095.           * SQL expression object based on the expr type.  See {@link patio.Dataset#filter}
      2096. 
+
    2096.           * Returns a cloned dataset with a greater than or equal to expression added to the WHERE
      2097. 
+
    2097.           * clause.
      2098. 
+
    2098.           *
      2099. 
+
    2099.           * @example
      2100. 
+
    2100.           *  DB.from("test").gte({x : 1});
      2101. 
+
    2101.           *          //=> SELECT * FROM test WHERE (x >= 1)
      2102. 
+
    2102.           *  DB.from("test").gte({x : 1, y : 10});
      2103. 
+
    2103.           *          //=> SELECT * FROM test WHERE ((x >= 1) AND (y >= 10))
      2104. 
+
    2104.           *
      2105. 
+
    2105.           * @param {Object} obj object used to create the greater than or equal to expression.
      2106. 
+
    2106.           *
      2107. 
+
    2107.           * @return {patio.Dataset} a cloned dataset with the greater than or equal to expression added to the WHERE clause.
      2108. 
 
    2108.           */
      2109. 
-
    2109.          _filterExpr: function (expr, cb, joinCond) {
      2110. 
-
    2110. 4283            expr = (isUndefined(expr) || isNull(expr) || (isArray(expr) && !expr.length)) ? null : expr;
      2111. 
-
    2111. 4283            if (expr && cb) {
      2112. 
-
    2112. 1                return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond))
      2113. 
-
    2113. 4282            } else if (cb) {
      2114. 
-
    2114. 58                expr = cb
      2115. 
-
    2115.              }
      2116. 
-
    2116. 4282            if (isInstanceOf(expr, Expression)) {
      2117. 
-
    2117. 459                if (isInstanceOf(expr, NumericExpression, StringExpression)) {
      2118. 
-
    2118. 2                    throw new QueryError("Invalid SQL Expression type : " + expr);
      2119. 
-
    2119.                  }
      2120. 
-
    2120. 457                return expr;
      2121. 
-
    2121. 3823            } else if (isArray(expr)) {
      2122. 
-
    2122. 740                if (expr.length) {
      2123. 
-
    2123. 740                    var first = expr[0];
      2124. 
-
    2124. 740                    if (isString(first)) {
      2125. 
-
    2125. 25                        return new PlaceHolderLiteralString(first, expr.slice(1), true);
      2126. 
-
    2126. 715                    } else if (Expression.isConditionSpecifier(expr)) {
      2127. 
-
    2127. 708                        return BooleanExpression.fromValuePairs(expr, joinCond)
      2128. 
-
    2128.                      } else {
      2129. 
-
    2129. 7                        return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
      2130. 
-
    2130. 15                            return this._filterExpr(e, null, joinCond);
      2131. 
-
    2131.                          }, this)));
      2132. 
-
    2132.                      }
      2133. 
-
    2133.                  }
      2134. 
-
    2134. 3083            } else if (isFunction(expr)) {
      2135. 
-
    2135. 59                return this._filterExpr(expr.call(sql, sql), null, joinCond);
      2136. 
-
    2136. 3024            } else if (isBoolean(expr)) {
      2137. 
-
    2137. 7                return new BooleanExpression("NOOP", expr);
      2138. 
-
    2138. 3017            } else if (isString(expr)) {
      2139. 
-
    2139. 1                return this.stringToIdentifier(expr);
      2140. 
-
    2140. 3016            } else if (isInstanceOf(expr, LiteralString)) {
      2141. 
-
    2141. 16                return new LiteralString("(" + expr + ")");
      2142. 
-
    2142. 3000            } else if (isHash(expr)) {
      2143. 
-
    2143. 2999                return BooleanExpression.fromValuePairs(expr, joinCond);
      2144. 
-
    2144.              } else {
      2145. 
-
    2145. 1                throw new QueryError("Invalid filter argument");
      2146. 
-
    2146.              }
      2147. 
+
    2147.          gte: function (arr) {
      2148. 
+
    2148. 2            arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "gte");
      2149. 
+
    2149. 2            return this.filter(this.__createBoolExpression("gte", arr));
      2150. 
 
    2150.          },
      2151. 
 
    2151.  
      2152. 
-
    2152.  
      2153. 
-
    2153.          /**@ignore*/
      2154. 
-
    2154.          getters: {
      2155. 
-
    2155.  
      2156. 
-
    2156.              /**
      2157. 
-
    2157.               * @ignore
      2158. 
-
    2158.               * Returns true if this dataset is a simple SELECT * FROM {table}, otherwise false.
      2159. 
-
    2159.               */
      2160. 
-
    2160.              isSimpleSelectAll: function () {
      2161. 
-
    2161. 33                var o = {}, opts = this.__opts, count = 0;
      2162. 
-
    2162. 33                for (var i in opts) {
      2163. 
-
    2163. 70                    if (opts[i] != null && this._static.NON_SQL_OPTIONS.indexOf(i) == -1) {
      2164. 
-
    2164. 37                        o[i] = opts[i];
      2165. 
-
    2165. 37                        count++;
      2166. 
-
    2166.                      }
      2167. 
-
    2167.                  }
      2168. 
-
    2168. 33                var f = o.from
      2169. 
-
    2169. 33                return count == 1 && f.length == 1 && (isString(f[0]) || isInstanceOf(f[0], AliasedExpression, Identifier));
      2170. 
-
    2170.              }
      2171. 
-
    2171.          }
      2172. 
-
    2172.      },
      2173. 
-
    2173.  
      2174. 
-
    2174.      static: {
      2175. 
-
    2175.          /**@lends patio.Dataset*/
      2176. 
-
    2176.  
      2177. 
-
    2177.          /**
      2178. 
-
    2178.           * These strings have {name}Join methods created (e.g. {@link patio.Dataset#innerJoin}) that
      2179. 
-
    2179.           * call {@link patio.Dataset#joinTable} with the string, passing along the arguments and
      2180. 
-
    2180.           * block from the method call.
      2181. 
-
    2181.           **/
      2182. 
-
    2182.          CONDITIONED_JOIN_TYPES: ["inner", "fullOuter", "rightOuter", "leftOuter", "full", "right", "left"],
      2183. 
-
    2183.  
      2184. 
 
    2184.          /**
      2185. 
 
    2185.           *
      2186. 
-
    2186.           * These strings have {name}Join methods created (e.g. naturalJoin) that
      2187. 
-
    2187.           * call {@link patio.Dataset#joinTable}.  They only accept a single table
      2188. 
-
    2188.           * argument which is passed to {@link patio.Dataset#joinTable}, and they throw an error
      2189. 
-
    2189.           * if called with a block.
      2190. 
-
    2190.           **/
      2191. 
-
    2191.          UNCONDITIONED_JOIN_TYPES: ["natural", "naturalLeft", "naturalRight", "naturalFull", "cross"],
      2192. 
-
    2192.  
      2193. 
-
    2193.          /**
      2194. 
-
    2194.           *  The dataset options that require the removal of cached columns
      2195. 
-
    2195.           *  if changed.
      2196. 
-
    2196.           */
      2197. 
-
    2197.          COLUMN_CHANGE_OPTS: ["select", "sql", "from", "join"],
      2198. 
-
    2198.  
      2199. 
-
    2199.          /**
      2200. 
-
    2200.           * Which options don't affect the SQL generation.  Used by {@link patio.Dataset#simpleSelectAll}
      2201. 
-
    2201.           * to determine if this is a simple SELECT * FROM table.
      2202. 
-
    2202.           */
      2203. 
-
    2203.          NON_SQL_OPTIONS: ["server", "defaults", "overrides", "graph", "eagerGraph", "graphAliases"],
      2204. 
-
    2204.  
      2205. 
-
    2205.  
      2206. 
-
    2206.          /**
      2207. 
-
    2207.           *  All methods that return modified datasets with a joined table added.
      2208. 
+
    2208.           * Returns a cloned dataset with a less than or equal to expression added to the WHERE
      2209. 
+
    2209.           * clause.
      2210. 
+
    2210.           *
      2211. 
+
    2211.           * @example
      2212. 
+
    2212.           *  DB.from("test").gte({x : 1});
      2213. 
+
    2213.           *          //=> SELECT * FROM test WHERE (x <= 1)
      2214. 
+
    2214.           *  DB.from("test").gte({x : 1, y : 10});
      2215. 
+
    2215.           *          //=> SELECT * FROM test WHERE ((x <= 1) AND (y <= 10))
      2216. 
+
    2216.           *
      2217. 
+
    2217.           * @param {Object} obj object used to create the less than or equal to expression.
      2218. 
+
    2218.           *
      2219. 
+
    2219.           * @return {patio.Dataset} a cloned dataset with the less than or equal to expression added to the WHERE clause.
      2220. 
 
    2220.           */
      2221. 
-
    2221.          JOIN_METHODS: ["join", "joinTable"],
      2222. 
+
    2222.          lte: function (obj) {
      2223. 
+
    2223. 2            var arr = this.__arrayToConditionSpecifier(argsToArray(arguments), "lte");
      2224. 
+
    2224. 2            return this.filter(this.__createBoolExpression("lte", obj));
      2225. 
+
    2225.          },
      2226. 
 
    2226.  
      2227. 
 
    2227.          /**
      2228. 
-
    2228.           * Methods that return modified datasets
      2229. 
-
    2229.           */
      2230. 
-
    2230.          QUERY_METHODS: ['addGraphAliases', "and", "distinct", "except", "exclude", "filter", "find", "is", "isNot",
      2231. 
-
    2231.              "eq", "neq", "lt", "lte", "gt", "gte", "forUpdate", "from", "fromSelf", "graph", "grep", "group",
      2232. 
-
    2232.              "groupAndCount", "groupBy", "having", "intersect", "invert", "limit", "lockStyle", "naked", "or", "order",
      2233. 
-
    2233.              "orderAppend", "orderBy", "orderMore", "orderPrepend", "qualify", "reverse",
      2234. 
-
    2234.              "reverseOrder", "select", "selectAll", "selectAppend", "selectMore", "setDefaults",
      2235. 
-
    2235.              "setGraphAliases", "setOverrides", "unfiltered", "ungraphed", "ungrouped", "union", "unlimited",
      2236. 
-
    2236.              "unordered", "where", "with", "withRecursive", "withSql"],
      2237. 
-
    2237.  
      2238. 
-
    2238.          init: function () {
      2239. 
-
    2239. 35            this._super(arguments);
      2240. 
-
    2240.              //initialize our join methods array
      2241. 
-
    2241. 35            var joinMethods = this.JOIN_METHODS;
      2242. 
-
    2242. 35            var queryMethods = this.QUERY_METHODS;
      2243. 
-
    2243. 35            this.UNCONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      2244. 
-
    2244. 175                var m = joinType + "Join";
      2245. 
-
    2245. 175                joinMethods.push(m);
      2246. 
-
    2246. 175                queryMethods.push(m);
      2247. 
-
    2247.              });
      2248. 
-
    2248. 35            this.CONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      2249. 
-
    2249. 245                var m = joinType + "Join";
      2250. 
-
    2250. 245                joinMethods.push(m);
      2251. 
-
    2251. 245                queryMethods.push(m);
      2252. 
-
    2252.              });
      2253. 
-
    2253. 35            this.QUERY_METHODS = queryMethods.concat(joinMethods);
      2254. 
-
    2254.          }
      2255. 
-
    2255.      }
      2256. 
-
    2256.  }).
      2257. 
-
    2257.      as(module);
    -
    - -
    - - - - - -
    -
    plugins/validation.js
    -     		-
    - Coverage97.66 - SLOC535 - LOC128 - Missed3 -
    -
    - 
    1. 1var comb = require("comb"),
      2. 
-
    2.      array = comb.array,
      3. 
-
    3.      compact = array.compact,
      4. 
-
    4.      flatten = array.flatten,
      5. 
-
    5.      toArray = array.toArray,
      6. 
-
    6.      net = require("net"),
      7. 
-
    7.      isIP = net.isIP,
      8. 
-
    8.      isIPv4 = net.isIPv4,
      9. 
-
    9.      isIPv6 = net.isIPv6,
      10. 
-
    10.      validator = require("validator"),
      11. 
-
    11.      validatorCheck = validator.check,
      12. 
-
    12.      dateCmp = comb.date.compare,
      13. 
-
    13.      isArray = comb.isArray,
      14. 
-
    14.      combDeepEqual = comb.deepEqual,
      15. 
-
    15.      combIsBoolean = comb.isBoolean,
      16. 
-
    16.      isString = comb.isString,
      17. 
-
    17.      combIsDefined = comb.isDefined,
      18. 
-
    18.      combIsNull = comb.isNull,
      19. 
-
    19.      ModelError = require("../errors.js").ModelError,
      20. 
-
    20.      isFunction = comb.isFunction,
      21. 
-
    21.      format = comb.string.format,
      22. 
-
    22.      Promise = comb.Promise,
      23. 
-
    23.      serial = comb.serial,
      24. 
-
    24.      when = comb.when,
      25. 
-
    25.      merge = comb.merge,
      26. 
-
    26.      define = comb.define;
      27. 
-
    27.  
      28. 
-
    28. 1var Validator = define(null, {
      29. 
-
    29.      instance:{
      30. 
+
    30.           * Returns a cloned dataset with a between clause added
      31. 
+
    31.           * to the where clause.
      32. 
+
    32.           *
      33. 
+
    33.           * @example
      34. 
+
    34.           *  ds.notBetween({x:[1, 2]}).sql;
      35. 
+
    35.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      36. 
+
    36.           *
      37. 
+
    37.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      38. 
+
    38.           *          //=> SELECT * FROM test WHERE ((x >= 1) OR (x <= 2))
      39. 
+
    39.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      40. 
+
    40.           *                     is the item to be greater than or equal to than and the second item is less than or equal to than.
      41. 
+
    41.           *
      42. 
+
    42.           * @return {patio.Dataset} a cloned dataset with a between clause added
      43. 
+
    43.           * to the where clause.
      44. 
+
    44.           */
      45. 
+
    45.          between: function (obj) {
      46. 
+
    46. 2            return this.filter(this.__createBetweenExpression(obj));
      47. 
+
    47.          },
      48. 
 
    48.  
      49. 
-
    49.          constructor:function validator(col) {
      50. 
-
    50. 44            this.col = col;
      51. 
-
    51. 44            this.__actions = [];
      52. 
+
    52.          /**
      53. 
+
    53.           * Returns a cloned dataset with a not between clause added
      54. 
+
    54.           * to the where clause.
      55. 
+
    55.           *
      56. 
+
    56.           * @example
      57. 
+
    57.           *  ds.notBetween({x:[1, 2]}).sql;
      58. 
+
    58.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      59. 
+
    59.           *
      60. 
+
    60.           *  ds.find({x:{notBetween:[1, 2]}}).sql;
      61. 
+
    61.           *          //=> SELECT * FROM test WHERE ((x < 1) OR (x > 2))
      62. 
+
    62.           * @param {Object} obj object where the key is the column and the value is an array where the first element
      63. 
+
    63.           *                     is the item to be less than and the second item is greater than.
      64. 
+
    64.           *
      65. 
+
    65.           * @return {patio.Dataset} a cloned dataset with a not between clause added
      66. 
+
    66.           * to the where clause.
      67. 
+
    67.           */
      68. 
+
    68.          notBetween: function (obj) {
      69. 
+
    69. 2            return this.filter(this.__createBetweenExpression(obj, true));
      70. 
 
    70.          },
      71. 
 
    71.  
      72. 
-
    72.          __addAction:function __addAction(action, opts) {
      73. 
-
    73. 46            this.__actions.push({
      74. 
-
    74.                  action:action,
      75. 
-
    75.                  opts:merge({onlyDefined:true, onlyNotNull:false}, opts)
      76. 
-
    76.              });
      77. 
-
    77. 46            return this;
      78. 
+
    78.          /**
      79. 
+
    79.           * Returns a cloned dataset with the given lock style.  If style is a
      80. 
+
    80.           * string, it will be used directly.Currently "update" is respected
      81. 
+
    81.           * by most databases, and "share" is supported by some.
      82. 
+
    82.           *
      83. 
+
    83.           * @example
      84. 
+
    84.           * DB.from("items").lockStyle('FOR SHARE') # SELECT * FROM items FOR SHARE
      85. 
+
    85.           *
      86. 
+
    86.           * @param {String} style the lock style to use.
      87. 
+
    87.           *
      88. 
+
    88.           * @return {patio.Dataset} a cloned datase with the given lock style.
      89. 
+
    89.           **/
      90. 
+
    90.          lockStyle: function (style) {
      91. 
+
    91. 4            return this.mergeOptions({lock: style});
      92. 
 
    92.          },
      93. 
 
    93.  
      94. 
-
    94.          isAfter:function (date, opts) {
      95. 
-
    95. 1            opts = opts || {};
      96. 
-
    96. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
      97. 
-
    97. 1            return this.__addAction(function (col) {
      98. 
-
    98. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") > 0;
      99. 
-
    99.              }, merge({message:"{col} must be after " + date + " got {val}."}, opts));
      100. 
+
    100.          /**
      101. 
+
    101.           * Returns a copy of the dataset with the order changed. If the dataset has an
      102. 
+
    102.           * existing order, it is ignored and overwritten with this order. If null is given
      103. 
+
    103.           * the returned dataset has no order. This can accept multiple arguments
      104. 
+
    104.           * of varying kinds, such as SQL functions.  This also takes a function similar
      105. 
+
    105.           * to {@link patio.Dataset#filter}
      106. 
+
    106.           *
      107. 
+
    107.           * @example
      108. 
+
    108.           *
      109. 
+
    109.           *  DB.from("items").order("name")
      110. 
+
    110.           *          //=> SELECT * FROM items ORDER BY name
      111. 
+
    111.           *
      112. 
+
    112.           *  DB.from("items").order("a", "b")
      113. 
+
    113.           *          //=> SELECT * FROM items ORDER BY a, b
      114. 
+
    114.           *
      115. 
+
    115.           *  DB.from("items").order(sql.literal('a + b'))
      116. 
+
    116.           *          //=> SELECT * FROM items ORDER BY a + b
      117. 
+
    117.           *
      118. 
+
    118.           *  DB.from("items").order(sql.identifier("a").plus("b"))
      119. 
+
    119.           *          //=> SELECT * FROM items ORDER BY (a + b)
      120. 
+
    120.           *
      121. 
+
    121.           *  DB.from("items").order(sql.identifier("name").desc())
      122. 
+
    122.           *          //=> SELECT * FROM items ORDER BY name DESC
      123. 
+
    123.           *
      124. 
+
    124.           *  DB.from("items").order(sql.identifier("name").asc({nulls : "last"))
      125. 
+
    125.           *          //=> SELECT * FROM items ORDER BY name ASC NULLS LAST
      126. 
+
    126.           *
      127. 
+
    127.           *  DB.from("items").order(function(){
      128. 
+
    128.           *          return this.sum("name").desc();
      129. 
+
    129.           *  }); //=> SELECT * FROM items ORDER BY sum(name) DESC
      130. 
+
    130.           *
      131. 
+
    131.           *  DB.from("items").order(null)
      132. 
+
    132.           *          //=>SELECT * FROM items
      133. 
+
    133.           *  @param arg variable number of arguments similar to {@link patio.Dataset#filter}
      134. 
+
    134.           *
      135. 
+
    135.           *  @return {patio.Dataset} a cloned dataset with the order changed.
      136. 
+
    136.           * */
      137. 
+
    137.          order: function (args) {
      138. 
+
    138. 381            args = argsToArray(arguments);
      139. 
+
    139. 381            var order = [];
      140. 
+
    140. 381            args = compact(args).length ? args : null;
      141. 
+
    141. 381            if (args) {
      142. 
+
    142. 263                args.forEach(function (a) {
      143. 
+
    143. 326                    if (isString(a)) {
      144. 
+
    144. 204                        order.push(this.stringToIdentifier(a));
      145. 
+
    145. 122                    } else if (isFunction(a)) {
      146. 
+
    146. 16                        var res = a.apply(sql, [sql]);
      147. 
+
    147. 16                        order = order.concat(isArray(res) ? res : [res]);
      148. 
+
    148.                      } else {
      149. 
+
    149. 106                        order.push(a);
      150. 
+
    150.                      }
      151. 
+
    151.                  }, this);
      152. 
+
    152.              } else {
      153. 
+
    153. 118                order = null;
      154. 
+
    154.              }
      155. 
+
    155. 381            return this.mergeOptions({order: order});
      156. 
 
    156.          },
      157. 
 
    157.  
      158. 
-
    158.          isBefore:function (date, opts) {
      159. 
-
    159. 1            opts = opts || {};
      160. 
-
    160. 1            var cmpDate = combIsBoolean(opts.date) ? opts.date : true;
      161. 
-
    161. 1            return this.__addAction(function (col) {
      162. 
-
    162. 3                return dateCmp(col, date, cmpDate ? "date" : "datetime") === -1;
      163. 
-
    163.              }, merge({message:"{col} must be before " + date + " got {val}."}, opts));
      164. 
+
    164.          /**
      165. 
+
    165.           * Alias of {@link patio.Dataset#orderMore};
      166. 
+
    166.           */
      167. 
+
    167.          orderAppend: function () {
      168. 
+
    168. 4            return this.orderMore.apply(this, arguments);
      169. 
 
    169.          },
      170. 
 
    170.  
      171. 
-
    171.          isDefined:function isDefined(opts) {
      172. 
-
    172. 1            return this.__addAction(function (col) {
      173. 
-
    173. 3                return combIsDefined(col);
      174. 
-
    174.              }, merge({message:"{col} must be defined.", onlyDefined:false, onlyNotNull:false}, opts));
      175. 
+
    175.          /**
      176. 
+
    176.           * @see patio.Dataset#order
      177. 
+
    177.           */
      178. 
+
    178.          orderBy: function () {
      179. 
+
    179. 6            return this.order.apply(this, arguments);
      180. 
 
    180.          },
      181. 
 
    181.  
      182. 
-
    182.          isNotDefined:function isNotDefined(opts) {
      183. 
-
    183. 1            return this.__addAction(function (col) {
      184. 
-
    184. 3                return !combIsDefined(col);
      185. 
-
    185.              }, merge({message:"{col} cannot be defined.", onlyDefined:false, onlyNotNull:false}, opts));
      186. 
+
    186.          /**
      187. 
+
    187.           * Returns a copy of the dataset with the order columns added
      188. 
+
    188.           * to the end of the existing order. For more detail
      189. 
+
    189.           * @see patio.Dataset#order
      190. 
+
    190.           *
      191. 
+
    191.           * @example
      192. 
+
    192.           *
      193. 
+
    193.           * DB.from("items").order("a").order("b");
      194. 
+
    194.           *      //=> SELECT * FROM items ORDER BY b
      195. 
+
    195.           *
      196. 
+
    196.           * DB.from("items").order("a").orderMore("b");
      197. 
+
    197.           *      //=>SELECT * FROM items ORDER BY a, b
      198. 
+
    198.           */
      199. 
+
    199.          orderMore: function () {
      200. 
+
    200. 11            var args = argsToArray(arguments);
      201. 
+
    201. 11            if (this.__opts.order) {
      202. 
+
    202. 9                args = this.__opts.order.concat(args);
      203. 
+
    203.              }
      204. 
+
    204. 11            return this.order.apply(this, args);
      205. 
 
    205.          },
      206. 
 
    206.  
      207. 
-
    207.          isNotNull:function isNotNull(opts) {
      208. 
-
    208. 3            return this.__addAction(function (col) {
      209. 
-
    209. 21                return combIsDefined(col) && !combIsNull(col);
      210. 
-
    210.              }, merge({message:"{col} cannot be null.", onlyDefined:false, onlyNotNull:false}, opts));
      211. 
+
    211.          /**
      212. 
+
    212.           * Returns a copy of the dataset with the order columns added
      213. 
+
    213.           * to the beginning of the existing order. For more detail
      214. 
+
    214.           * @see patio.Dataset#order
      215. 
+
    215.           *
      216. 
+
    216.           * @example
      217. 
+
    217.           * DB.from("items").order("a").order("b");
      218. 
+
    218.           *      //=> SELECT * FROM items ORDER BY b
      219. 
+
    219.           *
      220. 
+
    220.           * DB.from("items").order("a").orderPrepend("b");
      221. 
+
    221.           *      //=>SELECT * FROM items ORDER BY b, a
      222. 
+
    222.           *
      223. 
+
    223.           *
      224. 
+
    224.           **/
      225. 
+
    225.          orderPrepend: function () {
      226. 
+
    226. 4            var ds = this.order.apply(this, arguments);
      227. 
+
    227. 4            return this.__opts.order ? ds.orderMore.apply(ds, this.__opts.order) : ds;
      228. 
 
    228.          },
      229. 
 
    229.  
      230. 
-
    230.          isNull:function isNull(opts) {
      231. 
-
    231. 1            return this.__addAction(function (col) {
      232. 
-
    232. 3                return !combIsDefined(col) || combIsNull(col);
      233. 
-
    233.              }, merge({message:"{col} must be null got {val}.", onlyDefined:false, onlyNotNull:false}, opts));
      234. 
+
    234.          /**
      235. 
+
    235.           * Qualify to the given table, or {@link patio.Dataset#firstSourceAlias} if not table is given.
      236. 
+
    236.           *
      237. 
+
    237.           * @example
      238. 
+
    238.           * DB.from("items").filter({id : 1}).qualify();
      239. 
+
    239.           *    //=> SELECT items.* FROM items WHERE (items.id = 1)
      240. 
+
    240.           *
      241. 
+
    241.           * DB.from("items").filter({id : 1}).qualify("i");
      242. 
+
    242.           *   //=> SELECT i.* FROM items WHERE (i.id = 1)
      243. 
+
    243.           *
      244. 
+
    244.           * @param {String|patio.sql.Identifier} [table={@link patio.Dataset#firstSourceAlias}] the table name to qualify to.
      245. 
+
    245.           *
      246. 
+
    246.           * @return {patio.Dataset} a cloned dataset qualified to the table or {@link patio.Dataset#firstSourceAlias}
      247. 
+
    247.           **/
      248. 
+
    248.          qualify: function (table) {
      249. 
+
    249. 19            table = table || this.firstSourceAlias;
      250. 
+
    250. 19            return this.qualifyTo(table);
      251. 
 
    251.          },
      252. 
 
    252.  
      253. 
-
    253.          isEq:function eq(val, opts) {
      254. 
-
    254. 4            return this.__addAction(function (col) {
      255. 
-
    255. 15                return combDeepEqual(col, val);
      256. 
-
    256.              }, merge({message:"{col} must === " + val + " got {val}."}, opts));
      257. 
+
    257.          /**
      258. 
+
    258.           * Qualify the dataset to its current first source(first from clause).  This is useful
      259. 
+
    259.           * if you have unqualified identifiers in the query that all refer to
      260. 
+
    260.           * the first source, and you want to join to another table which
      261. 
+
    261.           * has columns with the same name as columns in the current dataset.
      262. 
+
    262.           * See {@link patio.Dataset#qualifyTo}
      263. 
+
    263.           *
      264. 
+
    264.           * @example
      265. 
+
    265.           *
      266. 
+
    266.           * DB.from("items").filter({id : 1}).qualifyToFirstSource();
      267. 
+
    267.           *      //=> SELECT items.* FROM items WHERE (items.id = 1)
      268. 
+
    268.           *
      269. 
+
    269.           * @return {patio.Dataset} a cloned dataset that is qualified with the first source.
      270. 
+
    270.           * */
      271. 
+
    271.          qualifyToFirstSource: function () {
      272. 
+
    272. 18            return this.qualifyTo(this.firstSourceAlias);
      273. 
 
    273.          },
      274. 
 
    274.  
      275. 
-
    275.          isNeq:function neq(val, opts) {
      276. 
-
    276. 2            return this.__addAction(function (col) {
      277. 
-
    277. 8                return !combDeepEqual(col, val);
      278. 
-
    278.              }, merge({message:"{col} must !== " + val + "."}, opts));
      279. 
+
    279.          /**
      280. 
+
    280.           * Return a copy of the dataset with unqualified identifiers in the
      281. 
+
    281.           * SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
      282. 
+
    282.           * given table. If no columns are currently selected, select all
      283. 
+
    283.           * columns of the given table.
      284. 
+
    284.           *
      285. 
+
    285.           * @example
      286. 
+
    286.           *   DB.from("items").filter({id : 1}).qualifyTo("i");
      287. 
+
    287.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      288. 
+
    288.           *
      289. 
+
    289.           * @param {String} table the name to qualify identifier to.
      290. 
+
    290.           *
      291. 
+
    291.           * @return {patio.Dataset} a cloned dataset with unqualified identifiers qualified.
      292. 
+
    292.           */
      293. 
+
    293.          qualifyTo: function (table) {
      294. 
+
    294. 40            var o = this.__opts;
      295. 
+
    295. 40            if (o.sql) {
      296. 
+
    296. 2                return this.mergeOptions();
      297. 
+
    297.              }
      298. 
+
    298. 38            var h = {};
      299. 
+
    299. 38            array.intersect(Object.keys(o), this._static.QUALIFY_KEYS).forEach(function (k) {
      300. 
+
    300. 65                h[k] = this._qualifiedExpression(o[k], table);
      301. 
+
    301.              }, this);
      302. 
+
    302. 38            if (!o.select || isEmpty(o.select)) {
      303. 
+
    303. 14                h.select = [new ColumnAll(table)];
      304. 
+
    304.              }
      305. 
+
    305. 38            return this.mergeOptions(h);
      306. 
 
    306.          },
      307. 
 
    307.  
      308. 
-
    308.          isLike:function like(val, opts) {
      309. 
-
    309. 3            return this.__addAction(function (col) {
      310. 
-
    310. 14                return !!col.match(val);
      311. 
-
    311.              }, merge({message:"{col} must be like " + val + " got {val}."}, opts));
      312. 
+
    312.          /**
      313. 
+
    313.           * Same as {@link patio.Dataset@qualifyTo} except that it forces qualification on methods called
      314. 
+
    314.           * after it has been called.
      315. 
+
    315.           *
      316. 
+
    316.           * @example
      317. 
+
    317.           *
      318. 
+
    318.           * //qualfyTo would generate
      319. 
+
    319.           * DB.from("items").qualifyTo("i").filter({id : 1});
      320. 
+
    320.           *      //=> SELECT i.* FROM items WHERE (id = 1)
      321. 
+
    321.           *
      322. 
+
    322.           * //alwaysQualify qualifies filter also.
      323. 
+
    323.           * DB.from("items").alwaysQualify("i").filter({id : 1});
      324. 
+
    324.           *      //=> SELECT i.* FROM items WHERE (i.id = 1)
      325. 
+
    325.           *
      326. 
+
    326.           *
      327. 
+
    327.           * @param {String|patio.sql.Identifier} [table=this.firstSourceAlias] the table to qualify to.
      328. 
+
    328.           * @return {patio.Dataset} a cloned dataset that will always qualify.
      329. 
+
    329.           */
      330. 
+
    330.          alwaysQualify: function (table) {
      331. 
+
    331. 3            return this.mergeOptions({alwaysQualify: table || this.firstSourceAlias});
      332. 
 
    332.          },
      333. 
 
    333.  
      334. 
-
    334.          isNotLike:function notLike(val, opts) {
      335. 
-
    335. 2            return this.__addAction(function (col) {
      336. 
-
    336. 6                return !(!!col.match(val));
      337. 
-
    337.              }, merge({message:"{col} must not be like " + val + "."}, opts));
      338. 
-
    338.          },
      339. 
 
    339.  
      340. 
-
    340.          isLt:function lt(num, opts) {
      341. 
-
    341. 1            return this.__addAction(function (col) {
      342. 
-
    342. 3                return col < num;
      343. 
-
    343.              }, merge({message:"{col} must be < " + num + " got {val}."}, opts));
      344. 
+
    344.          /**
      345. 
+
    345.           * Returns a copy of the dataset with the order reversed. If no order is
      346. 
+
    346.           * given, the existing order is inverted.
      347. 
+
    347.           *
      348. 
+
    348.           * @example
      349. 
+
    349.           * DB.from("items").reverse("id");
      350. 
+
    350.           *      //=> SELECT * FROM items ORDER BY id DESC
      351. 
+
    351.           *
      352. 
+
    352.           * DB.from("items").order("id").reverse();
      353. 
+
    353.           *      //=> SELECT * FROM items ORDER BY id DESC
      354. 
+
    354.           *
      355. 
+
    355.           * DB.from("items").order("id").reverse(sql.identifier("name").asc);
      356. 
+
    356.           *      //=> SELECT * FROM items ORDER BY name ASC
      357. 
+
    357.           *
      358. 
+
    358.           * @param {String|patio.sql.Identifier|Function} args variable number of columns add to order before reversing.
      359. 
+
    359.           *
      360. 
+
    360.           * @return {patio.Dataset} a cloned dataset with the order reversed.
      361. 
+
    361.           *
      362. 
+
    362.           **/
      363. 
+
    363.          reverse: function (args) {
      364. 
+
    364. 46            args = argsToArray(arguments);
      365. 
+
    365. 46            return this.order.apply(this, this._invertOrder(args.length ? args : this.__opts.order));
      366. 
 
    366.          },
      367. 
 
    367.  
      368. 
-
    368.          isGt:function gt(num, opts) {
      369. 
-
    369. 1            return this.__addAction(function (col) {
      370. 
-
    370. 3                return col > num;
      371. 
-
    371.              }, merge({message:"{col} must be > " + num + " got {val}."}, opts));
      372. 
+
    372.          /**
      373. 
+
    373.           * @see patio.Dataset#reverse
      374. 
+
    374.           */
      375. 
+
    375.          reverseOrder: function () {
      376. 
+
    376. 16            return this.reverse.apply(this, arguments);
      377. 
 
    377.          },
      378. 
 
    378.  
      379. 
-
    379.          isLte:function lte(num, opts) {
      380. 
-
    380. 1            return this.__addAction(function (col) {
      381. 
-
    381. 3                return col <= num;
      382. 
-
    382.              }, merge({message:"{col} must be <= " + num + " got {val}."}, opts));
      383. 
-
    383.          },
      384. 
+
    384.          /**
      385. 
+
    385.           * Returns a copy of the dataset with the columns selected changed
      386. 
+
    386.           * to the given columns. This also takes a function similar to {@link patio.Dataset#filter}
      387. 
+
    387.           *
      388. 
+
    388.           * @example
      389. 
+
    389.           *   DB.from("items").select("a");
      390. 
+
    390.           *      //=> SELECT a FROM items
      391. 
+
    391.           *
      392. 
+
    392.           *   DB.from("items").select("a", "b");
      393. 
+
    393.           *      //=> SELECT a, b FROM items
      394. 
+
    394.           *
      395. 
+
    395.           *   DB.from("items").select("a", function(){
      396. 
+
    396.           *          return this.sum("b")
      397. 
+
    397.           *   }).sql;  //=> SELECT a, sum(b) FROM items
      398. 
+
    398.           *
      399. 
+
    399.           *  @param {String|patio.sql.Identifier|Function} args variable number of colums to select
      400. 
+
    400.           *  @return {patio.Dataset} a cloned dataset with the columns selected changed.
      401. 
+
    401.           */
      402. 
+
    402.          select: function (args) {
      403. 
+
    403. 663            args = flatten(argsToArray(arguments));
      404. 
+
    404. 663            var columns = [];
      405. 
+
    405. 663            args.forEach(function (c) {
      406. 
+
    406. 1043                if (isFunction(c)) {
      407. 
+
    407. 23                    var res = c.apply(sql, [sql]);
      408. 
+
    408. 23                    columns = columns.concat(isArray(res) ? res : [res]);
      409. 
+
    409.                  } else {
      410. 
+
    410. 1020                    columns.push(c);
      411. 
+
    411.                  }
      412. 
+
    412.              });
      413. 
+
    413. 663            var select = [];
      414. 
+
    414. 663            columns.forEach(function (c) {
      415. 
+
    415. 1046                if (isHash(c)) {
      416. 
+
    416. 3                    for (var i in c) {
      417. 
+
    417. 4                        select.push(new AliasedExpression(new Identifier(i), c[i]));
      418. 
+
    418.                      }
      419. 
+
    419. 1043                } else if (isString(c)) {
      420. 
+
    420. 344                    select.push(this.stringToIdentifier(c));
      421. 
+
    421.                  } else {
      422. 
+
    422. 699                    select.push(c);
      423. 
+
    423.                  }
      424. 
+
    424.              }, this);
      425. 
+
    425. 663            return this.mergeOptions({select: select});
      426. 
 
    426.  
      427. 
-
    427.          isGte:function gte(num, opts) {
      428. 
-
    428. 1            return this.__addAction(function (col) {
      429. 
-
    429. 3                return col >= num;
      430. 
-
    430.              }, merge({message:"{col} must be >= " + num + " got {val}."}, opts));
      431. 
 
    431.          },
      432. 
 
    432.  
      433. 
-
    433.          isIn:function isIn(arr, opts) {
      434. 
-
    434. 2            if (!isArray(arr)) {
      435. 
-
    435. 1                throw new Error("isIn requires an array of values");
      436. 
-
    436.              }
      437. 
-
    437. 1            return this.__addAction(function (col) {
      438. 
-
    438. 3                return arr.indexOf(col) !== -1;
      439. 
-
    439.              }, merge({message:"{col} must be in " + arr.join(",") + " got {val}."}, opts));
      440. 
+
    440.          /**
      441. 
+
    441.           * Returns a cloned dataset that selects *.
      442. 
+
    442.           *
      443. 
+
    443.           * @return {patio.Dataset}  a cloned dataset that selects *.
      444. 
+
    444.           */
      445. 
+
    445.          selectAll: function () {
      446. 
+
    446. 6            return this.mergeOptions({select: null});
      447. 
 
    447.          },
      448. 
 
    448.  
      449. 
-
    449.          isNotIn:function notIn(arr, opts) {
      450. 
-
    450. 2            if (!isArray(arr)) {
      451. 
-
    451. 1                throw new Error("notIn requires an array of values");
      452. 
+
    452.          /**
      453. 
+
    453.           * Selects the columns if only if there is not already select sources.
      454. 
+
    454.           *
      455. 
+
    455.           * @example
      456. 
+
    456.           *
      457. 
+
    457.           * var ds = DB.from("items"); //SELECT * FROM items
      458. 
+
    458.           *
      459. 
+
    459.           * ds.select("a"); //SELECT a FROM items;
      460. 
+
    460.           * ds.select("a").selectIfNoSource("a", "b"). //SELECT a FROM items;
      461. 
+
    461.           * ds.selectIfNoSource("a", "b"). //SELECT a, b FROM items;
      462. 
+
    462.           *
      463. 
+
    463.           * @param cols columns to select if there is not already select sources.
      464. 
+
    464.           * @return {patio.Dataset} a cloned dataset with the appropriate select sources.
      465. 
+
    465.           */
      466. 
+
    466.          selectIfNoSource: function (cols) {
      467. 
+
    467. 0            var ret;
      468. 
+
    468. 0            if (!this.hasSelectSource) {
      469. 
+
    469. 0                ret = this.select.apply(this, arguments);
      470. 
+
    470.              } else {
      471. 
+
    471. 0                ret = this.mergeOptions();
      472. 
 
    472.              }
      473. 
-
    473. 1            return this.__addAction(function (col) {
      474. 
-
    474. 3                return arr.indexOf(col) === -1;
      475. 
-
    475.              }, merge({message:"{col} cannot be in " + arr.join(",") + " got {val}."}, opts));
      476. 
-
    476.          },
      477. 
-
    477.  
      478. 
-
    478.          isMacAddress:function isMaxAddress(opts) {
      479. 
-
    479. 1            return this.__addAction(function (col) {
      480. 
-
    480. 4                return !!col.match(/^([0-9A-F]{2}[:\-]){5}([0-9A-F]{2})$/);
      481. 
-
    481.              }, merge({message:"{col} must be a valid MAC address got {val}."}, opts));
      482. 
-
    482.          },
      483. 
-
    483.  
      484. 
-
    484.          isIPAddress:function isIpAddress(opts) {
      485. 
-
    485. 1            return this.__addAction(function (col) {
      486. 
-
    486. 4                return !!isIP(col);
      487. 
-
    487.              }, merge({message:"{col} must be a valid IPv4 or IPv6 address got {val}."}, opts));
      488. 
-
    488.          },
      489. 
-
    489.  
      490. 
-
    490.          isIPv4Address:function isIpAddress(opts) {
      491. 
-
    491. 1            return this.__addAction(function (col) {
      492. 
-
    492. 3                return isIPv4(col);
      493. 
-
    493.              }, merge({message:"{col} must be a valid IPv4 address got {val}."}, opts));
      494. 
-
    494.          },
      495. 
-
    495.  
      496. 
-
    496.          isIPv6Address:function isIpAddress(opts) {
      497. 
-
    497. 1            return this.__addAction(function (col) {
      498. 
-
    498. 3                return isIPv6(col);
      499. 
-
    499.              }, merge({message:"{col} must be a valid IPv6 address got {val}."}, opts));
      500. 
+
    500. 0            return ret;
      501. 
 
    501.          },
      502. 
 
    502.  
      503. 
-
    503.          isUUID:function isUUID(opts) {
      504. 
-
    504. 1            return this.__addAction(function (col) {
      505. 
-
    505. 3                return !!col.match(/^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$/);
      506. 
-
    506.              }, merge({message:"{col} must be a valid UUID got {val}"}, opts));
      507. 
+
    507.          /**
      508. 
+
    508.           * Returns a copy of the dataset with the given columns added
      509. 
+
    509.           * to the existing selected columns. If no columns are currently selected,
      510. 
+
    510.           * it will select the columns given in addition to *.
      511. 
+
    511.           *
      512. 
+
    512.           * @example
      513. 
+
    513.           *   DB.from("items").select("a").selectAppend("b").sql;
      514. 
+
    514.           *      //=> SELECT b FROM items
      515. 
+
    515.           *
      516. 
+
    516.           *   DB.from("items").select("a").selectAppend("b", "c", "d").sql
      517. 
+
    517.           *      //=> SELECT a, b, c, d FROM items
      518. 
+
    518.           *
      519. 
+
    519.           *   DB.from("items").selectAppend("b").sql
      520. 
+
    520.           *      //=> SELECT *, b FROM items
      521. 
+
    521.           *
      522. 
+
    522.           * @param [...] cols variable number of columns to add to the select statement
      523. 
+
    523.           *
      524. 
+
    524.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      525. 
+
    525.           */
      526. 
+
    526.          selectAppend: function (cols) {
      527. 
+
    527. 7            cols = argsToArray(arguments);
      528. 
+
    528. 7            var currentSelect = this.__opts.select;
      529. 
+
    529. 7            if (!currentSelect || !currentSelect.length) {
      530. 
+
    530. 3                currentSelect = [this._static.WILDCARD];
      531. 
+
    531.              }
      532. 
+
    532. 7            return this.select.apply(this, currentSelect.concat(cols));
      533. 
 
    533.          },
      534. 
 
    534.  
      535. 
-
    535.          isEmail:function isEmail(opts) {
      536. 
-
    536. 1            return this.__addAction(function (col) {
      537. 
-
    537. 3                return validatorCheck(col).isEmail();
      538. 
-
    538.              }, merge({message:"{col} must be a valid Email Address got {val}"}, opts));
      539. 
+
    539.          /**
      540. 
+
    540.           * Returns a copy of the dataset with the given columns added
      541. 
+
    541.           * to the existing selected columns. If no columns are currently selected
      542. 
+
    542.           * it will just select the columns given.
      543. 
+
    543.           *
      544. 
+
    544.           * @example
      545. 
+
    545.           *   DB.from("items").select("a").select("b").sql;
      546. 
+
    546.           *      //=> SELECT b FROM items
      547. 
+
    547.           *
      548. 
+
    548.           *   DB.from("items").select("a").selectMore("b", "c", "d").sql
      549. 
+
    549.           *      //=> SELECT a, b, c, d FROM items
      550. 
+
    550.           *
      551. 
+
    551.           *   DB.from("items").selectMore("b").sql
      552. 
+
    552.           *      //=> SELECT b FROM items
      553. 
+
    553.           *
      554. 
+
    554.           * @param [...] cols variable number of columns to add to the select statement
      555. 
+
    555.           *
      556. 
+
    556.           * @return {patio.Dataset} returns a cloned dataset with the new select columns appended.
      557. 
+
    557.           */
      558. 
+
    558.          selectMore: function (cols) {
      559. 
+
    559. 10            cols = argsToArray(arguments);
      560. 
+
    560. 10            var currentSelect = this.__opts.select;
      561. 
+
    561. 10            return this.select.apply(this, (currentSelect || []).concat(cols));
      562. 
 
    562.          },
      563. 
 
    563.  
      564. 
-
    564.          isUrl:function isUrl(opts) {
      565. 
-
    565. 1            return this.__addAction(function (col) {
      566. 
-
    566. 3                return validatorCheck(col).isUrl();
      567. 
-
    567.              }, merge({message:"{col} must be a valid url got {val}"}, opts));
      568. 
+
    568.          /**
      569. 
+
    569.           * Set the default values for insert and update statements.  The values hash passed
      570. 
+
    570.           * to insert or update are merged into this hash, so any values in the hash passed
      571. 
+
    571.           * to insert or update will override values passed to this method.
      572. 
+
    572.           *
      573. 
+
    573.           *  @example
      574. 
+
    574.           *   DB.from("items").setDefaults({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      575. 
+
    575.           *      //=> INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
      576. 
+
    576.           *
      577. 
+
    577.           * @param {Object} hash object with key value pairs to use as override values
      578. 
+
    578.           *
      579. 
+
    579.           * @return {patio.Dataset} a cloned dataset with the defaults added to the current datasets defaults.
      580. 
+
    580.           */
      581. 
+
    581.          setDefaults: function (hash) {
      582. 
+
    582. 5            return this.mergeOptions({defaults: merge({}, this.__opts.defaults || {}, hash)});
      583. 
 
    583.          },
      584. 
 
    584.  
      585. 
-
    585.          isAlpha:function isAlpha(opts) {
      586. 
-
    586. 2            return this.__addAction(function (col) {
      587. 
-
    587. 11                return validatorCheck(col).isAlpha();
      588. 
-
    588.              }, merge({message:"{col} must be a only letters got {val}"}, opts));
      589. 
+
    589.          /**
      590. 
+
    590.           * Set values that override hash arguments given to insert and update statements.
      591. 
+
    591.           * This hash is merged into the hash provided to insert or update, so values
      592. 
+
    592.           * will override any values given in the insert/update hashes.
      593. 
+
    593.           *
      594. 
+
    594.           * @example
      595. 
+
    595.           *   DB.from("items").setOverrides({a : 'a', c : 'c'}).insert({a : 'd', b : 'b'}).insertSql();
      596. 
+
    596.           *      //=> INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
      597. 
+
    597.           *
      598. 
+
    598.           * @param {Object} hash object with key value pairs to use as override values
      599. 
+
    599.           *
      600. 
+
    600.           * @return {patio.Dataset} a cloned dataset with the overrides added to the current datasets overrides.
      601. 
+
    601.           */
      602. 
+
    602.          setOverrides: function (hash) {
      603. 
+
    603. 5            return this.mergeOptions({overrides: merge({}, this.__opts.overrides || {}, hash)});
      604. 
 
    604.          },
      605. 
 
    605.  
      606. 
-
    606.          isAlphaNumeric:function isAlphaNumeric(opts) {
      607. 
-
    607. 1            return this.__addAction(function (col) {
      608. 
-
    608. 3                return validatorCheck(col).isAlphanumeric();
      609. 
-
    609.              }, merge({message:"{col} must be a alphanumeric got {val}"}, opts));
      610. 
+
    610.          /**
      611. 
+
    611.           * Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
      612. 
+
    612.           * @example
      613. 
+
    613.           *  DB.from("items").group("a").having({a : 1}).where("b").unfiltered().sql;
      614. 
+
    614.           *      //=> SELECT * FROM items GROUP BY a
      615. 
+
    615.           *
      616. 
+
    616.           * @return {patio.Dataset} a cloned dataset with no HAVING or WHERE clause.
      617. 
+
    617.           */
      618. 
+
    618.          unfiltered: function () {
      619. 
+
    619. 14            return this.mergeOptions({where: null, having: null});
      620. 
 
    620.          },
      621. 
 
    621.  
      622. 
-
    622.          hasLength:function hasLength(min, max, opts) {
      623. 
-
    623. 2            return this.__addAction(function (col) {
      624. 
-
    624. 6                return validatorCheck(col).len(min, max);
      625. 
-
    625.              }, merge({message:"{col} must have a length between " + min + (max ? " and " + max : "") + "."}, opts));
      626. 
+
    626.          /**
      627. 
+
    627.           * Returns a copy of the dataset with no GROUP or HAVING clause.
      628. 
+
    628.           *
      629. 
+
    629.           * @example
      630. 
+
    630.           *  DB.from("t").group("a").having({a : 1}).where("b").ungrouped().sql;
      631. 
+
    631.           *      //=> SELECT * FROM t WHERE b
      632. 
+
    632.           *
      633. 
+
    633.           * @return {patio.Dataset} a cloned dataset with no GROUP or HAVING clause.
      634. 
+
    634.           */
      635. 
+
    635.          ungrouped: function () {
      636. 
+
    636. 1            return this.mergeOptions({group: null, having: null});
      637. 
 
    637.          },
      638. 
 
    638.  
      639. 
-
    639.          isLowercase:function isLowercase(opts) {
      640. 
-
    640. 1            return this.__addAction(function (col) {
      641. 
-
    641. 3                return validatorCheck(col).isLowercase();
      642. 
-
    642.              }, merge({message:"{col} must be lowercase got {val}."}, opts));
      643. 
+
    643.          /**
      644. 
+
    644.           * Adds a UNION clause using a second dataset object.
      645. 
+
    645.           * A UNION compound dataset returns all rows in either the current dataset
      646. 
+
    646.           * or the given dataset.
      647. 
+
    647.           * Options:
      648. 
+
    648.           * :alias :: Use the given value as the from_self alias
      649. 
+
    649.           * :all :: Set to true to use UNION ALL instead of UNION, so duplicate rows can occur
      650. 
+
    650.           * :from_self :: Set to false to not wrap the returned dataset in a from_self, use with care.
      651. 
+
    651.           *
      652. 
+
    652.           * @example
      653. 
+
    653.           * DB.from("items").union(DB.from("otherItems")).sql;
      654. 
+
    654.           *      //=> SELECT * FROM items UNION SELECT * FROM other_items
      655. 
+
    655.           *
      656. 
+
    656.           * DB.from("items").union(DB.from("otherItems"), {all : true, fromSelf : false}).sql;
      657. 
+
    657.           *      //=> SELECT * FROM items UNION ALL SELECT * FROM other_items
      658. 
+
    658.           *
      659. 
+
    659.           * DB.from("items").union(DB.from("otherItems"), {alias : "i"})
      660. 
+
    660.           *      //=> SELECT * FROM (SELECT * FROM items UNION SELECT * FROM other_items) AS i
      661. 
+
    661.           *
      662. 
+
    662.           * @param {patio.Dataset} dataset dataset to union with
      663. 
+
    663.           * @param {Object} opts addional options
      664. 
+
    664.           * @param {String|patio.sql.Identifier} [opts.alias] Alias to use as the fromSelf alias.
      665. 
+
    665.           * @param {Boolean} [opt.all=false] Set to true to use UNION ALL instead of UNION so duplicate rows can occur
      666. 
+
    666.           * @param {Boolean} [opts.fromSelf=true] Set to false to not wrap the returned dataset in a fromSelf.
      667. 
+
    667.           *
      668. 
+
    668.           * @return {patio.Dataset} a cloned dataset with the union.
      669. 
+
    669.           *
      670. 
+
    670.           */
      671. 
+
    671.          union: function (dataset, opts) {
      672. 
+
    672. 21            opts = isUndefined(opts) ? {} : opts;
      673. 
+
    673. 21            if (!isHash(opts)) {
      674. 
+
    674. 3                opts = {all: opts};
      675. 
+
    675.              }
      676. 
+
    676. 21            return this.compoundClone("union", dataset, opts);
      677. 
 
    677.          },
      678. 
 
    678.  
      679. 
-
    679.          isUppercase:function isUppercase(opts) {
      680. 
-
    680. 1            return this.__addAction(function (col) {
      681. 
-
    681. 3                return validatorCheck(col).isUppercase();
      682. 
-
    682.              }, merge({message:"{col} must be uppercase got {val}."}, opts));
      683. 
+
    683.          /**
      684. 
+
    684.           * Returns a copy of the dataset with no limit or offset.
      685. 
+
    685.           *
      686. 
+
    686.           * @example
      687. 
+
    687.           *  DB.from("t").limit(10, 20).unlimited().sql;
      688. 
+
    688.           *      //=> SELECT * FROM t
      689. 
+
    689.           *
      690. 
+
    690.           * @return {patio.Dataset} a cloned dataset with no limit or offset.
      691. 
+
    691.           */
      692. 
+
    692.          unlimited: function () {
      693. 
+
    693. 1            return this.mergeOptions({limit: null, offset: null});
      694. 
 
    694.          },
      695. 
 
    695.  
      696. 
-
    696.          isEmpty:function isEmpty(opts) {
      697. 
-
    697. 1            return this.__addAction(function (col) {
      698. 
-
    698. 3                try {
      699. 
-
    699. 3                    validatorCheck(col).notEmpty();
      700. 
-
    700. 2                    return false;
      701. 
-
    701.                  } catch (e) {
      702. 
-
    702. 1                    return true;
      703. 
-
    703.                  }
      704. 
-
    704.              }, merge({message:"{col} must be empty got {val}."}, opts));
      705. 
+
    705.          /**
      706. 
+
    706.           * Returns a copy of the dataset with no order.
      707. 
+
    707.           *
      708. 
+
    708.           * @example
      709. 
+
    709.           *  DB.from("t").order("a", sql.identifier("b").desc()).unordered().sql;
      710. 
+
    710.           *      //=> SELECT * FROM t
      711. 
+
    711.           *
      712. 
+
    712.           * @return {patio.Dataset} a cloned dataset with no order.
      713. 
+
    713.           */
      714. 
+
    714.          unordered: function () {
      715. 
+
    715. 115            return this.order(null);
      716. 
 
    716.          },
      717. 
 
    717.  
      718. 
-
    718.          isNotEmpty:function isNotEmpty(opts) {
      719. 
-
    719. 2            return this.__addAction(function (col) {
      720. 
-
    720. 11                return validatorCheck(col).notEmpty();
      721. 
-
    721.              }, merge({message:"{col} must not be empty."}, opts));
      722. 
+
    722.          /**
      723. 
+
    723.           * Add a condition to the WHERE clause.  See {@link patio.Dataset#filter} for argument types.
      724. 
+
    724.           *
      725. 
+
    725.           * @example
      726. 
+
    726.           *   DB.from("test").where('price < ? AND id in ?', 100, [1, 2, 3]).sql;
      727. 
+
    727.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
      728. 
+
    728.           *   DB.from("test").where('price < {price} AND id in {ids}', {price:100, ids:[1, 2, 3]}).sql;
      729. 
+
    729.           *      //=> "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))")
      730. 
+
    730.           *
      731. 
+
    731.           */
      732. 
+
    732.          where: function () {
      733. 
+
    733. 252            return this._filter.apply(this, ["where"].concat(argsToArray(arguments)));
      734. 
 
    734.          },
      735. 
 
    735.  
      736. 
-
    736.          isCreditCard:function isCreditCard(opts) {
      737. 
-
    737. 0            return this.__addAction(function (col) {
      738. 
-
    738. 0                return validatorCheck(col).isCreditCard();
      739. 
-
    739.              }, merge({message:"{col} is an invalid credit card"}, opts));
      740. 
+
    740.          /**
      741. 
+
    741.           * Add a common table expression (CTE) with the given name and a dataset that defines the CTE.
      742. 
+
    742.           * A common table expression acts as an inline view for the query.
      743. 
+
    743.           *
      744. 
+
    744.           * @name with
      745. 
+
    745.           * @example
      746. 
+
    746.           *
      747. 
+
    747.           * DB.from("t")["with"]("t", db.from("x"))["with"]("j", db.from("y")).sql;
      748. 
+
    748.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y) SELECT * FROM t'
      749. 
+
    749.           *
      750. 
+
    750.           * DB.from("t")["with"]("t", db.from("x")).withRecursive("j", db.from("y"), db.from("j")).sql;
      751. 
+
    751.           *      //=> 'WITH t AS (SELECT * FROM x), j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t'
      752. 
+
    752.           *
      753. 
+
    753.           * DB.from("t")["with"]("t", db.from("x"), {args:["b"]}).sql;
      754. 
+
    754.           *      //=> 'WITH t(b) AS (SELECT * FROM x) SELECT * FROM t'
      755. 
+
    755.           *
      756. 
+
    756.           * @param {String} name the name of the to assign to the CTE.
      757. 
+
    757.           * @param {patio.Dataset} dataset the dataset to use for the CTE.
      758. 
+
    758.           * @param {Object} opts extra options.
      759. 
+
    759.           * @param {String[]} [opts.args] colums/args for the CTE.
      760. 
+
    760.           * @param {Boolean} [opts.recursive] set to true that the CTE is recursive.
      761. 
+
    761.           *
      762. 
+
    762.           * @return {patio.Dataset} a cloned dataset with the CTE.
      763. 
+
    763.           */
      764. 
+
    764.          "with": function (name, dataset, opts) {
      765. 
+
    765. 6            if (!this.supportsCte) {
      766. 
+
    766. 1                throw new QueryError("this dataset does not support common table expressions");
      767. 
+
    767.              }
      768. 
+
    768. 5            return this.mergeOptions({
      769. 
+
    769.                  "with": (this.__opts["with"] || []).concat([merge(opts || {}, {name: this.stringToIdentifier(name), dataset: dataset})])
      770. 
+
    770.              });
      771. 
 
    771.          },
      772. 
 
    772.  
      773. 
-
    773.          check:function (fun, opts) {
      774. 
-
    774. 4            return this.__addAction(fun, opts);
      775. 
+
    775.          /**
      776. 
+
    776.           * Add a recursive common table expression (CTE) with the given name, a dataset that
      777. 
+
    777.           * defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
      778. 
+
    778.           * of the CTE.
      779. 
+
    779.           *
      780. 
+
    780.           *  @example
      781. 
+
    781.           *
      782. 
+
    782.           * //Sing withRecursive call.
      783. 
+
    783.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t")).sql;
      784. 
+
    784.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      785. 
+
    785.           *
      786. 
+
    786.           * //Multiple withRecursive calls.
      787. 
+
    787.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"))
      788. 
+
    788.           *    .withRecursive("j", db.from("y"), db.from("j")).sql;
      789. 
+
    789.           *          //=> 'WITH t AS (SELECT * FROM x UNION ALL SELECT * FROM t),
      790. 
+
    790.           *                     j AS (SELECT * FROM y UNION ALL SELECT * FROM j) SELECT * FROM t';
      791. 
+
    791.           *
      792. 
+
    792.           * //Adding args
      793. 
+
    793.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {args:["b", "c"]}).sql;
      794. 
+
    794.           *          //=> 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
      795. 
+
    795.           *
      796. 
+
    796.           * //Setting union all to false
      797. 
+
    797.           * DB.from("t").withRecursive("t", db.from("x"), db.from("t"), {unionAll:false}).sql;
      798. 
+
    798.           *          //=> 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t');
      799. 
+
    799.           *
      800. 
+
    800.           * @param {String} name the name to assign to the CTE
      801. 
+
    801.           * @param {patio.Dataset} nonRecursive the non-recursive part of the CTE
      802. 
+
    802.           * @param {patio.Dataset} recursive the recursive part of the CTE
      803. 
+
    803.           * @param {Object} [opts={}] extra options
      804. 
+
    804.           * @param {String[]} [opts.args] columns to include with the CTE
      805. 
+
    805.           * @param {Boolena} [opts.unionAll] set to false to use UNION instead of UNION ALL when combining non recursive
      806. 
+
    806.           *                                with recursive.
      807. 
+
    807.           *
      808. 
+
    808.           * @return {patio.Dataset} a cloned dataset with the CTE.
      809. 
+
    809.           */
      810. 
+
    810.          withRecursive: function (name, nonRecursive, recursive, opts) {
      811. 
+
    811. 7            if (!this.supportsCte) {
      812. 
+
    812. 1                throw new QueryError("This dataset does not support common table expressions");
      813. 
+
    813.              }
      814. 
+
    814. 6            opts = opts || {};
      815. 
+
    815. 6            var wit = (this.__opts["with"] || []).concat([merge(opts, {recursive: true, name: this.stringToIdentifier(name), dataset: nonRecursive.union(recursive, {all: opts.unionAll != false, fromSelf: false})})]);
      816. 
+
    816. 6            return this.mergeOptions({"with": wit});
      817. 
 
    817.          },
      818. 
 
    818.  
      819. 
-
    819.          validate:function validate(value) {
      820. 
-
    820. 218            var errOpts = {col:this.col, val:value};
      821. 
-
    821. 218            return compact(this.__actions.map(function (action) {
      822. 
-
    822. 248                var actionOpts = action.opts;
      823. 
-
    823. 248                if (!actionOpts.onlyDefined || (combIsDefined(value) &&
      824. 
-
    824.                      (!actionOpts.onlyNotNull || !combIsNull(value)) )) {
      825. 
-
    825. 186                    var ret = null;
      826. 
-
    826. 186                    try {
      827. 
-
    827. 186                        if (!action.action(value)) {
      828. 
-
    828. 69                            ret = format(actionOpts.message, errOpts);
      829. 
-
    829.                          }
      830. 
-
    830.                      } catch (e) {
      831. 
-
    831. 28                        ret = format(actionOpts.message, errOpts);
      832. 
-
    832.                      }
      833. 
-
    833. 186                    return ret;
      834. 
-
    834.                  }
      835. 
-
    835.              }, this));
      836. 
-
    836.          }
      837. 
-
    837.  
      838. 
-
    838.      }
      839. 
-
    839.  });
      840. 
-
    840.  
      841. 
-
    841. 1function shouldValidate(opts, def) {
      842. 
-
    842. 115    opts = opts || {};
      843. 
-
    843. 115    return combIsBoolean(opts.validate) ? opts.validate : def;
      844. 
-
    844.  }
      845. 
-
    845.  
      846. 
-
    846. 1function validateHook(prop, next, opts) {
      847. 
-
    847. 115    if (shouldValidate(opts, prop) && !this.isValid()) {
      848. 
-
    848. 45        next(flatten(toArray(this.errors).map(function (entry) {
      849. 
-
    849. 64            return entry[1].map(function (err) {
      850. 
-
    850. 48                return new Error(err);
      851. 
-
    851.              });
      852. 
-
    852.          })));
      853. 
-
    853.      } else {
      854. 
-
    854. 70        next();
      855. 
-
    855.      }
      856. 
-
    856.  }
      857. 
-
    857.  
      858. 
-
    858. 1define(null, {
      859. 
+
    859.          /**
      860. 
+
    860.           * Returns a copy of the dataset with the static SQL used.  This is useful if you want
      861. 
+
    861.           * to keep the same {@link patio.Dataset#rowCb}/{@link patio.Dataset#graph},
      862. 
+
    862.           *  but change the SQL used to custom SQL.
      863. 
+
    863.           *
      864. 
+
    864.           * @example
      865. 
+
    865.           *  DB.from("items").withSql('SELECT * FROM foo')
      866. 
+
    866.           *          //=> SELECT * FROM foo
      867. 
+
    867.           *
      868. 
+
    868.           *  @param {String} sql sql for the dataset to use.
      869. 
+
    869.           *
      870. 
+
    870.           *  @return {patio.Dataset} a cloned dataset with the static sql set.
      871. 
+
    871.           */
      872. 
+
    872.          withSql: function (sql) {
      873. 
+
    873. 46            var args = argsToArray(arguments).slice(1);
      874. 
+
    874. 46            if (args.length) {
      875. 
+
    875. 23                sql = new PlaceHolderLiteralString(sql, args)
      876. 
+
    876.              }
      877. 
+
    877. 46            return this.mergeOptions({sql: sql});
      878. 
+
    878.          },
      879. 
 
    879.  
      880. 
-
    880.      instance:{
      881. 
 
    881.  
      882. 
 
    882.          /**
      883. 
-
    883.           * A validation plugin for patio models. This plugin adds a <code>validate</code> method to each {@link patio.Model}
      884. 
-
    884.           * class that adds it as a plugin. This plugin does not include most typecast checks as <code>patio</code> already checks
      885. 
-
    885.           * types upon column assignment.
      886. 
+
    886.           * Add the dataset to the list of compounds
      887. 
 
    887.           *
      888. 
-
    888.           * To do single col validation
      889. 
-
    889.           * {@code
      890. 
+
    890.           * @param {String} type the type of compound (i.e. "union", "intersect")
      891. 
+
    891.           * @param {patio.Dataset} dataset the dataset to add to
      892. 
+
    892.           * @param [Object] [options={}] compound option to use (i.e {all : true})
      893. 
 
    893.           *
      894. 
-
    894.           * var Model = patio.addModel("validator", {
      895. 
-
    895.           *      plugins:[ValidatorPlugin]
      896. 
-
    896.           * });
      897. 
-
    897.           * //this ensures column assignment
      898. 
-
    898.           * Model.validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
      899. 
-
    899.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
      900. 
-
    900.           * Model.validate("col2").like(/hello/ig);
      901. 
-
    901.           * //Ensures that the emailAddress column is a valid email address.
      902. 
-
    902.           * Model.validate("emailAddress").isEmailAddress();
      903. 
-
    903.           * }
      904. 
+
    904.           * @return {patio.Dataset} ds with the dataset added to the compounds.
      905. 
+
    905.           */
      906. 
+
    906.          compoundClone: function (type, dataset, options) {
      907. 
+
    907. 51            var ds = this._compoundFromSelf().mergeOptions({compounds: (array.toArray(this.__opts.compounds || [])).concat([
      908. 
+
    908.                  [type, dataset._compoundFromSelf(), options.all]
      909. 
+
    909.              ])});
      910. 
+
    910. 51            return options.fromSelf === false ? ds : ds.fromSelf(options);
      911. 
+
    911.          },
      912. 
+
    912.  
      913. 
+
    913.          /**
      914. 
+
    914.           * Returns the a cloned dataset with out the {@link patio.Dataset#rowCb}
      915. 
 
    915.           *
      916. 
-
    916.           * Or you can do a mass validation through a callback.
      917. 
-
    917.           * {@code
      918. 
+
    918.           * @example
      919. 
+
    919.           * var ds = DB.from("test");
      920. 
+
    920.           * ds.rowCb = function(r){
      921. 
+
    921.           *     r.a = r.a * 2;
      922. 
+
    922.           * }
      923. 
 
    923.           *
      924. 
-
    924.           * var Model = patio.addModel("validator", {
      925. 
-
    925.           *      plugins:[ValidatorPlugin]
      926. 
+
    926.           * ds.all().then(function(ret){
      927. 
+
    927.           *      //ret === [{a : 4}, {a : 6}]
      928. 
 
    928.           * });
      929. 
-
    929.           * Model.validate(function(validate){
      930. 
-
    930.           *      //this ensures column assignment
      931. 
-
    931.           *      validate("col1").isNotNull().isAlphaNumeric().hasLength(1, 10);
      932. 
-
    932.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
      933. 
-
    933.           *      validate("col2").isLike(/hello/ig);
      934. 
-
    934.           *      //Ensures that the emailAddress column is a valid email address.
      935. 
-
    935.           *      validate("emailAddress").isEmail();
      936. 
+
    936.           * ds.naked().all().then(function(ret){
      937. 
+
    937.           *      //ret ===  [{a : 2}, {a : 3}];
      938. 
 
    938.           * });
      939. 
-
    939.           * }
      940. 
 
    940.           *
      941. 
-
    941.           * To check if a {@link patio.Model} is valid you can run the <code>isValid</code> method.
      942. 
+
    942.           * @return {patio.Dataset} a cloned dataset with out the {@link patio.Dataset#rowCb}
      943. 
+
    943.           */
      944. 
+
    944.          naked: function () {
      945. 
+
    945. 2266            var ds = this.mergeOptions({});
      946. 
+
    946. 2266            ds.rowCb = null;
      947. 
+
    947. 2266            return ds;
      948. 
+
    948.          },
      949. 
+
    949.  
      950. 
+
    950.          /**
      951. 
+
    951.           * @private
      952. 
 
    952.           *
      953. 
-
    953.           * {@code
      954. 
-
    954.           * var model1 = new Model({col2 : 'grape', emailAddress : "test"}),
      955. 
-
    955.           *     model2 = new Model({col1 : "grape", col2 : "hello", emailAddress : "test@test.com"});
      956. 
+
    956.           * Adds a group of conditions joined by the second arg, wrapped in parens, connected to an existing where/having
      957. 
+
    957.           * clause by the first arg.
      958. 
+
    958.           * If the where/having clause doesn't yet exist, a where clause is created with the group.
      959. 
 
    959.           *
      960. 
-
    960.           * model1.isValid() //false
      961. 
-
    961.           * model2.isValid() //true
      962. 
-
    962.           * }
      963. 
+
    963.           * @example
      964. 
 
    964.           *
      965. 
-
    965.           * To get the errors associated with an invalid model you can access the errors property
      966. 
+
    966.           * DB.from("items").filter({id, [1,2,3]})._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
      967. 
+
    967.           *      //=> SELECT
      968. 
+
    968.           *               *
      969. 
+
    969.           *           FROM
      970. 
+
    970.           *               items
      971. 
+
    971.           *           WHERE
      972. 
+
    972.           *               ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
      973. 
 
    973.           *
      974. 
-
    974.           * {@code
      975. 
-
    975.           * model1.errors; //{ col1: [ 'col1 must be defined.' ],
      976. 
-
    976.           *                //  col2: [ 'col2 must be like /hello/gi got grape.' ],
      977. 
-
    977.           *                //  emailAddress: [ 'emailAddress must be a valid Email Address got test' ] }
      978. 
-
    978.           * }
      979. 
+
    979.           * DB.from("items")._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
      980. 
+
    980.           *      //=> SELECT
      981. 
+
    981.           *               *
      982. 
+
    982.           *           FROM
      983. 
+
    983.           *               items
      984. 
+
    984.           *           WHERE
      985. 
+
    985.           *               ((price < 0) OR (price > 10))
      986. 
 
    986.           *
      987. 
-
    987.           * Validation is also run pre save and pre update. To prevent this you can specify the <code>validate</code> option
      988. 
+
    988.           * @param {String} If there is an existing where/having clause, this arg will join the new condition group to it. "AND" if undef. Should be "AND" or "OR"
      989. 
+
    989.           * @param {String} The conditions will be joined this. Same expectations as the first param.
      990. 
+
    990.           * @param See {@link patio.Dataset#filter}.
      991. 
 
    991.           *
      992. 
-
    992.           * {@code
      993. 
-
    993.           * model1.save(null, {validate : false});
      994. 
-
    994.           * model2.save(null, {validate : false});
      995. 
-
    995.           * }
      996. 
+
    996.           * @return {patio.Dataset} a cloned dataset with the condition group added to the WHERE/HAVING clause.
      997. 
+
    997.           */
      998. 
+
    998.          _addGroupedCondition: function (addedByBool, groupedByBool) {
      999. 
+
    999. 6            groupedByBool = isUndefined(groupedByBool) ? "AND" : groupedByBool;
      1000. 
+
    1000. 6            var tOpts = this.__opts,
      1001. 
+
    1001.                  clause = (tOpts.having ? "having" : "where"),
      1002. 
+
    1002.                  clauseObj = tOpts[clause];
      1003. 
+
    1003. 6            var args = argsToArray(arguments, 2);
      1004. 
+
    1004. 6            args = args.length == 1 ? args[0] : args;
      1005. 
+
    1005. 6            var opts = {};
      1006. 
+
    1006. 6            if (clauseObj) {
      1007. 
+
    1007. 3                addedByBool = isUndefined(addedByBool) ? "AND" : addedByBool;
      1008. 
+
    1008. 3                opts[clause] = new BooleanExpression(addedByBool, clauseObj, this._filterExpr(args, null, groupedByBool));
      1009. 
+
    1009.              } else {
      1010. 
+
    1010. 3                opts[clause] = this._filterExpr(args, null, groupedByBool);
      1011. 
+
    1011.              }
      1012. 
+
    1012. 6            return this.mergeOptions(opts);
      1013. 
+
    1013.          },
      1014. 
+
    1014.  
      1015. 
+
    1015.          /**
      1016. 
+
    1016.           * @private
      1017. 
+
    1017.           * Protected
      1018. 
 
    1018.           *
      1019. 
-
    1019.           * Or you can specify the class level properties <code>validateOnSave</code> and <code>validateOnUpdate</code>
      1020. 
-
    1020.           * to false respectively
      1021. 
-
    1021.           * {@code
      1022. 
-
    1022.           * Model.validateOnSave = false;
      1023. 
-
    1023.           * Model.validateOnUpdate = false;
      1024. 
-
    1024.           * }
      1025. 
+
    1025.           * Internal filter method so it works on either the having or where clauses.
      1026. 
+
    1026.           */
      1027. 
+
    1027.          _filter: function (clause) {
      1028. 
+
    1028. 3765            var cond = argsToArray(arguments).slice(1), cb;
      1029. 
+
    1029. 3765            if (cond.length && isFunction(cond[cond.length - 1])) {
      1030. 
+
    1030. 59                cb = cond.pop();
      1031. 
+
    1031.              }
      1032. 
+
    1032. 3765            cond = cond.length == 1 ? cond[0] : cond
      1033. 
+
    1033. 3765            if ((cond == null || cond == undefined || cond === "") || (isArray(cond) && cond.length == 0 && !cb) || (isObject(cond) && isEmpty(cond) && !cb)) {
      1034. 
+
    1034. 293                return this.mergeOptions();
      1035. 
+
    1035.              } else {
      1036. 
+
    1036. 3472                cond = this._filterExpr(cond, cb);
      1037. 
+
    1037. 3469                var cl = this.__opts[clause];
      1038. 
+
    1038. 3469                cl && (cond = new BooleanExpression("AND", cl, cond));
      1039. 
+
    1039. 3469                var opts = {};
      1040. 
+
    1040. 3469                opts[clause] = cond;
      1041. 
+
    1041. 3469                return this.mergeOptions(opts);
      1042. 
+
    1042.              }
      1043. 
+
    1043.          },
      1044. 
+
    1044.  
      1045. 
+
    1045.          /**
      1046. 
+
    1046.           * Splits a possible implicit alias, handling both {@link patio.sql.AliasedExpression}s
      1047. 
+
    1047.           * and strings.  Returns an array of two elements, with the first being the
      1048. 
+
    1048.           * main expression, and the second being the alias. Alias may be null if it is a
      1049. 
+
    1049.           * string that does not contain an alias {table}___{alias}.
      1050. 
+
    1050.           */
      1051. 
+
    1051.          _splitAlias: function (c) {
      1052. 
+
    1052. 619            var ret;
      1053. 
+
    1053. 619            if (isInstanceOf(c, AliasedExpression)) {
      1054. 
+
    1054. 5                ret = [c.expression, c.alias];
      1055. 
+
    1055. 614            } else if (isString(c)) {
      1056. 
+
    1056. 0                var parts = this._splitString(c), cTable = parts[0], column = parts[1], alias = parts[2];
      1057. 
+
    1057. 0                if (alias) {
      1058. 
+
    1058. 0                    ret = [cTable ? new QualifiedIdentifier(cTable, column) : column, alias];
      1059. 
+
    1059.                  } else {
      1060. 
+
    1060. 0                    ret = [c, null];
      1061. 
+
    1061.                  }
      1062. 
+
    1062.              } else {
      1063. 
+
    1063. 614                ret = [c, null];
      1064. 
+
    1064.              }
      1065. 
+
    1065. 619            return ret;
      1066. 
+
    1066.          },
      1067. 
+
    1067.  
      1068. 
+
    1068.  
      1069. 
+
    1069.          /**
      1070. 
+
    1070.           * @private
      1071. 
+
    1071.           * Inverts the given order by breaking it into a list of column references
      1072. 
+
    1072.           * and inverting them.
      1073. 
 
    1073.           *
      1074. 
-
    1074.           * Avaiable validation methods are.
      1075. 
+
    1075.           *   ds.invertOrder([sql.identifier("id").desc()]]) //=> [id]
      1076. 
+
    1076.           *   ds.invertOrder("category", sql.identifier("price").desc()]) #=> [category.desc(), price]
      1077. 
+
    1077.           */
      1078. 
+
    1078.  
      1079. 
+
    1079.          _invertOrder: function (order) {
      1080. 
+
    1080. 46            var ret = order;
      1081. 
+
    1081. 46            if (order) {
      1082. 
+
    1082. 45                ret = order.map(function (o) {
      1083. 
+
    1083. 57                    if (isInstanceOf(o, OrderedExpression)) {
      1084. 
+
    1084. 17                        return o.invert();
      1085. 
+
    1085.                      } else {
      1086. 
+
    1086. 40                        return new OrderedExpression(isString(o) ? new Identifier(o) : o);
      1087. 
+
    1087.                      }
      1088. 
+
    1088.                  }, this);
      1089. 
+
    1089.              }
      1090. 
+
    1090. 46            return ret;
      1091. 
+
    1091.          },
      1092. 
+
    1092.  
      1093. 
+
    1093.          /**
      1094. 
+
    1094.           * Creates a boolean expression that each key is compared to its value using the provided operator.
      1095. 
 
    1095.           *
      1096. 
-
    1096.           * <ul>
      1097. 
-
    1097.           *  <li><code>isAfter</code> : check that a date is after a specified date</li>
      1098. 
-
    1098.           *  <li><code>isBefore</code> : check that a date is after before a specified date </li>
      1099. 
-
    1099.           *  <li><code>isDefined</code> : ensure that a column is defined</li>
      1100. 
-
    1100.           *  <li><code>isNotDefined</code> : ensure that a column is not defined</li>
      1101. 
-
    1101.           *  <li><code>isNotNull</code> : ensure that a column is defined and not null</li>
      1102. 
-
    1102.           *  <li><code>isNull</code> : ensure that a column is not defined or null</li>
      1103. 
-
    1103.           *  <li><code>isEq</code> : ensure that a column equals a value <b>this uses deep equal</b></li>
      1104. 
-
    1104.           *  <li><code>isNeq</code> : ensure that a column does not equal a value <b>this uses deep equal</b></li>
      1105. 
-
    1105.           *  <li><code>isLike</code> : ensure that a column is like a value, can be a regexp or string</li>
      1106. 
-
    1106.           *  <li><code>isNotLike</code> : ensure that a column is not like a value, can be a regexp or string</li>
      1107. 
-
    1107.           *  <li><code>isLt</code> : ensure that a column is less than a value</li>
      1108. 
-
    1108.           *  <li><code>isGt</code> : ensure that a column is greater than a value</li>
      1109. 
-
    1109.           *  <li><code>isLte</code> : ensure that a column is less than or equal to a value</li>
      1110. 
-
    1110.           *  <li><code>isGte</code> : ensure that a column is greater than or equal to a value</li>
      1111. 
-
    1111.           *  <li><code>isIn</code> : ensure that a column is contained in an array of values</li>
      1112. 
-
    1112.           *  <li><code>isNotIn</code> : ensure that a column is not contained in an array of values</li>
      1113. 
-
    1113.           *  <li><code>isMacAddress</code> : ensure that a column is a valid MAC address</li>
      1114. 
-
    1114.           *  <li><code>isIPAddress</code> : ensure that a column is a valid IPv4 or IPv6 address</li>
      1115. 
-
    1115.           *  <li><code>isIPv4Address</code> : ensure that a column is a valid IPv4 address</li>
      1116. 
-
    1116.           *  <li><code>isIPv6Address</code> : ensure that a column is a valid IPv6 address</li>
      1117. 
-
    1117.           *  <li><code>isUUID</code> : ensure that a column is a valid UUID</li>
      1118. 
-
    1118.           *  <li><code>isEmail</code> : ensure that a column is a valid email address</li>
      1119. 
-
    1119.           *  <li><code>isUrl</code> : ensure than a column is a valid URL</li>
      1120. 
-
    1120.           *  <li><code>isAlpha</code> : ensure than a column is all letters</li>
      1121. 
-
    1121.           *  <li><code>isAlphaNumeric</code> : ensure than a column is all letters or numbers</li>
      1122. 
-
    1122.           *  <li><code>hasLength</code> : ensure than a column is fits within the specified length accepts a min and optional max value</li>
      1123. 
-
    1123.           *  <li><code>isLowercase</code> : ensure than a column is lowercase</li>
      1124. 
-
    1124.           *  <li><code>isUppercase</code> : ensure than a column is uppercase</li>
      1125. 
-
    1125.           *  <li><code>isEmpty</code> : ensure than a column empty (i.e. a blank string)</li>
      1126. 
-
    1126.           *  <li><code>isNotEmpty</code> : ensure than a column not empty (i.e. not a blank string)</li>
      1127. 
-
    1127.           *  <li><code>isCreditCard</code> : ensure than a is a valid credit card number</li>
      1128. 
-
    1128.           *  <li><code>check</code> : accepts a function to perform validation</li>
      1129. 
-
    1129.           * </ul>
      1130. 
+
    1130.           * @example
      1131. 
+
    1131.           *
      1132. 
+
    1132.           * ds.__createBoolExpression("gt", {x : 1, y:2, z : 5}) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1133. 
+
    1133.           * ds.__createBoolExpression("gt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
      1134. 
+
    1134.           * ds.__createBoolExpression("lt", {x : 1, y:2, z : 5}) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1135. 
+
    1135.           * ds.__createBoolExpression("lt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
      1136. 
+
    1136.           *
      1137. 
+
    1137.           * @param {String} op valid boolean expression operator to capare each K,V pair with
      1138. 
+
    1138.           * @param {Object| Array } obj object or two dimensional array containing key value pairs
      1139. 
+
    1139.           *
      1140. 
+
    1140.           * @return {patio.sql.BooleanExpression} boolean expression joined by a AND of each key value pair compared by the op
      1141. 
+
    1141.           */
      1142. 
+
    1142.          __createBoolExpression: function (op, obj) {
      1143. 
+
    1143. 32            var pairs = [];
      1144. 
+
    1144. 32            if (Expression.isConditionSpecifier(obj)) {
      1145. 
+
    1145. 32                if (isHash(obj)) {
      1146. 
+
    1146. 18                    obj = array.toArray(obj);
      1147. 
+
    1147.                  }
      1148. 
+
    1148. 32                obj.forEach(function (pair) {
      1149. 
+
    1149. 42                    pairs.push(new BooleanExpression(op, new Identifier(pair[0]), pair[1]));
      1150. 
+
    1150.                  });
      1151. 
+
    1151.              }
      1152. 
+
    1152. 32            return pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
      1153. 
+
    1153.          },
      1154. 
+
    1154.  
      1155. 
+
    1155.          /**
      1156. 
+
    1156.           * @private
      1157. 
 
    1157.           *
      1158. 
-
    1158.           * All of the validation methods are chainable, and accept an options argument.
      1159. 
+
    1159.           * Creates a boolean expression where the key is '>=' value 1 and '<=' value two.
      1160. 
 
    1160.           *
      1161. 
-
    1161.           * The options include
      1162. 
-
    1162.           * <ul>
      1163. 
-
    1163.           *     <li><code>message</code> : a message to return if a column fails validation. The message can include <code>{val}</code> and <code>{col}</code>
      1164. 
-
    1164.           *     replacements which will insert the invalid value and the column name.
      1165. 
-
    1165.           *     </li>
      1166. 
-
    1166.           *     <li><code>[onlyDefined=true]</code> : set to false to run the method even if the column value is not defined.</li>
      1167. 
-
    1167.           *     <li><code>[onlyNotNull=true]</code> : set to false to run the method even if the column value is null.</li>
      1168. 
-
    1168.           * </ul>
      1169. 
+
    1169.           * @example
      1170. 
 
    1170.           *
      1171. 
+
    1171.           * ds.__createBetweenExpression({x : [1,2]}) => //=> WHERE ((x >= 1) AND (x <= 10))
      1172. 
+
    1172.           * ds.__createBetweenExpression({x : [1,2]}, true) => //=> WHERE ((x < 1) OR (x > 10))
      1173. 
 
    1173.           *
      1174. 
-
    1174.           * @constructs
      1175. 
-
    1175.           * @name ValidatorPlugin
      1176. 
-
    1176.           * @memberOf patio.plugins
      1177. 
-
    1177.           * @property {Object} [errors={}] the validation errors for this model.
      1178. 
+
    1178.           * @param {Object} obj object where the keys are columns and the values are two element arrays.
      1179. 
+
    1179.           * @param {Boolean} [invert] if set to true it inverts the between to make it not between the two values
      1180. 
 
    1180.           *
      1181. 
+
    1181.           * @return {patio.sql.BooleanExpression} a boolean expression containing the between expression.
      1182. 
 
    1182.           */
      1183. 
-
    1183.          constructor:function () {
      1184. 
-
    1184. 114            this._super(arguments);
      1185. 
-
    1185. 114            this.errors = {};
      1186. 
+
    1186.          __createBetweenExpression: function (obj, invert) {
      1187. 
+
    1187. 4            var pairs = [];
      1188. 
+
    1188. 4            for (var i in obj) {
      1189. 
+
    1189. 4                var v = obj[i];
      1190. 
+
    1190. 4                if (isArray(v) && v.length) {
      1191. 
+
    1191. 2                    var ident = this.stringToIdentifier(i);
      1192. 
+
    1192. 2                    pairs.push(new BooleanExpression("AND", new BooleanExpression("gte", ident, v[0]), new BooleanExpression("lte", ident, v[1])));
      1193. 
+
    1193.                  } else {
      1194. 
+
    1194. 2                    throw new QueryError("Between requires an array for the value");
      1195. 
+
    1195.                  }
      1196. 
+
    1196.              }
      1197. 
+
    1197. 2            var ret = pairs.length == 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs))
      1198. 
+
    1198. 2            return invert ? BooleanExpression.invert(ret) : ret;
      1199. 
 
    1199.          },
      1200. 
 
    1200.  
      1201. 
+
    1201.  
      1202. 
 
    1202.          /**
      1203. 
-
    1203.           * Validates a model, returning an array of error messages for each invalid property.
      1204. 
-
    1204.           * @return {String[]} an array of error messages for each invalid property.
      1205. 
+
    1205.           * @private
      1206. 
+
    1206.           * Converts an array to a two dimensional array where the first element
      1207. 
+
    1207.           * is the identifier and the second argument is the value that the value should equal
      1208. 
+
    1208.           * used by is{Null|NotNull|True|NotTrue|False|notFalse} functions to join all the values passed in.
      1209. 
+
    1209.           * @param {String[]|patio.sql.Identifier} arr array of elements to make a condition specifier out of
      1210. 
+
    1210.           * @param defaultOp the value to assign a value if one is not provided.
      1211. 
+
    1211.           *
      1212. 
+
    1212.           * @return { [[]] } an array of two element arrays.
      1213. 
 
    1213.           */
      1214. 
-
    1214.          validate:function () {
      1215. 
-
    1215. 159            this.errors = {};
      1216. 
-
    1216. 159            return flatten(this._static.validators.map(function runValidator(validator) {
      1217. 
-
    1217. 218                var col = validator.col, val = this.__values[validator.col], ret = validator.validate(val);
      1218. 
-
    1218. 218                this.errors[col] = ret;
      1219. 
-
    1219. 218                return ret;
      1220. 
-
    1220.              }, this));
      1221. 
+
    1221.          __arrayToConditionSpecifier: function (arr, defaultOp) {
      1222. 
+
    1222. 22            var ret = [];
      1223. 
+
    1223. 22            arr.forEach(function (a) {
      1224. 
+
    1224. 28                if (isString(a)) {
      1225. 
+
    1225. 18                    a = this.stringToIdentifier(a);
      1226. 
+
    1226.                  }
      1227. 
+
    1227. 28                if (isInstanceOf(a, Identifier)) {
      1228. 
+
    1228. 18                    ret.push([a, defaultOp]);
      1229. 
+
    1229. 10                } else if (isHash(a)) {
      1230. 
+
    1230. 4                    ret = ret.concat(array.toArray(a));
      1231. 
+
    1231.                  } else {
      1232. 
+
    1232. 6                    throw new QueryError("Invalid condition specifier " + a);
      1233. 
+
    1233.                  }
      1234. 
+
    1234.              }, this);
      1235. 
+
    1235. 16            return ret;
      1236. 
 
    1236.          },
      1237. 
 
    1237.  
      1238. 
 
    1238.          /**
      1239. 
-
    1239.           * Returns if this model passes validation.
      1240. 
+
    1240.           * @private
      1241. 
 
    1241.           *
      1242. 
-
    1242.           * @return {Boolean}
      1243. 
+
    1243.           * SQL expression object based on the expr type.  See {@link patio.Dataset#filter}
      1244. 
 
    1244.           */
      1245. 
-
    1245.          isValid:function () {
      1246. 
-
    1246. 159            return this.validate().length === 0;
      1247. 
+
    1247.          _filterExpr: function (expr, cb, joinCond) {
      1248. 
+
    1248. 4295            expr = (isUndefined(expr) || isNull(expr) || (isArray(expr) && !expr.length)) ? null : expr;
      1249. 
+
    1249. 4295            if (expr && cb) {
      1250. 
+
    1250. 1                return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond))
      1251. 
+
    1251. 4294            } else if (cb) {
      1252. 
+
    1252. 58                expr = cb
      1253. 
+
    1253.              }
      1254. 
+
    1254. 4294            if (isInstanceOf(expr, Expression)) {
      1255. 
+
    1255. 459                if (isInstanceOf(expr, NumericExpression, StringExpression)) {
      1256. 
+
    1256. 2                    throw new QueryError("Invalid SQL Expression type : " + expr);
      1257. 
+
    1257.                  }
      1258. 
+
    1258. 457                return expr;
      1259. 
+
    1259. 3835            } else if (isArray(expr)) {
      1260. 
+
    1260. 744                if (expr.length) {
      1261. 
+
    1261. 744                    var first = expr[0];
      1262. 
+
    1262. 744                    if (isString(first)) {
      1263. 
+
    1263. 25                        return new PlaceHolderLiteralString(first, expr.slice(1), true);
      1264. 
+
    1264. 719                    } else if (Expression.isConditionSpecifier(expr)) {
      1265. 
+
    1265. 708                        return BooleanExpression.fromValuePairs(expr, joinCond)
      1266. 
+
    1266.                      } else {
      1267. 
+
    1267. 11                        return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
      1268. 
+
    1268. 23                            return this._filterExpr(e, null, joinCond);
      1269. 
+
    1269.                          }, this)));
      1270. 
+
    1270.                      }
      1271. 
+
    1271.                  }
      1272. 
+
    1272. 3091            } else if (isFunction(expr)) {
      1273. 
+
    1273. 59                return this._filterExpr(expr.call(sql, sql), null, joinCond);
      1274. 
+
    1274. 3032            } else if (isBoolean(expr)) {
      1275. 
+
    1275. 7                return new BooleanExpression("NOOP", expr);
      1276. 
+
    1276. 3025            } else if (isString(expr)) {
      1277. 
+
    1277. 1                return this.stringToIdentifier(expr);
      1278. 
+
    1278. 3024            } else if (isInstanceOf(expr, LiteralString)) {
      1279. 
+
    1279. 16                return new LiteralString("(" + expr + ")");
      1280. 
+
    1280. 3008            } else if (isHash(expr)) {
      1281. 
+
    1281. 3007                return BooleanExpression.fromValuePairs(expr, joinCond);
      1282. 
+
    1282.              } else {
      1283. 
+
    1283. 1                throw new QueryError("Invalid filter argument");
      1284. 
+
    1284.              }
      1285. 
+
    1285.          },
      1286. 
+
    1286.  
      1287. 
+
    1287.  
      1288. 
+
    1288.          /**@ignore*/
      1289. 
+
    1289.          getters: {
      1290. 
+
    1290.  
      1291. 
+
    1291.              /**
      1292. 
+
    1292.               * @ignore
      1293. 
+
    1293.               * Returns true if this dataset is a simple SELECT * FROM {table}, otherwise false.
      1294. 
+
    1294.               */
      1295. 
+
    1295.              isSimpleSelectAll: function () {
      1296. 
+
    1296. 33                var o = {}, opts = this.__opts, count = 0;
      1297. 
+
    1297. 33                for (var i in opts) {
      1298. 
+
    1298. 70                    if (opts[i] != null && this._static.NON_SQL_OPTIONS.indexOf(i) == -1) {
      1299. 
+
    1299. 37                        o[i] = opts[i];
      1300. 
+
    1300. 37                        count++;
      1301. 
+
    1301.                      }
      1302. 
+
    1302.                  }
      1303. 
+
    1303. 33                var f = o.from
      1304. 
+
    1304. 33                return count == 1 && f.length == 1 && (isString(f[0]) || isInstanceOf(f[0], AliasedExpression, Identifier));
      1305. 
+
    1305.              }
      1306. 
 
    1306.          }
      1307. 
 
    1307.      },
      1308. 
 
    1308.  
      1309. 
-
    1309.      "static":{
      1310. 
-
    1310.          /**@lends patio.plugins.ValidatorPlugin*/
      1311. 
+
    1311.      static: {
      1312. 
+
    1312.          /**@lends patio.Dataset*/
      1313. 
 
    1313.  
      1314. 
 
    1314.          /**
      1315. 
-
    1315.           * Set to false to prevent model validation when saving.
      1316. 
-
    1316.           * @default true
      1317. 
-
    1317.           */
      1318. 
-
    1318.          validateOnSave:true,
      1319. 
+
    1319.           * These strings have {name}Join methods created (e.g. {@link patio.Dataset#innerJoin}) that
      1320. 
+
    1320.           * call {@link patio.Dataset#joinTable} with the string, passing along the arguments and
      1321. 
+
    1321.           * block from the method call.
      1322. 
+
    1322.           **/
      1323. 
+
    1323.          CONDITIONED_JOIN_TYPES: ["inner", "fullOuter", "rightOuter", "leftOuter", "full", "right", "left"],
      1324. 
 
    1324.  
      1325. 
 
    1325.          /**
      1326. 
-
    1326.           * Set to false to prevent model validation when updating.
      1327. 
-
    1327.           * @default true
      1328. 
+
    1328.           *
      1329. 
+
    1329.           * These strings have {name}Join methods created (e.g. naturalJoin) that
      1330. 
+
    1330.           * call {@link patio.Dataset#joinTable}.  They only accept a single table
      1331. 
+
    1331.           * argument which is passed to {@link patio.Dataset#joinTable}, and they throw an error
      1332. 
+
    1332.           * if called with a block.
      1333. 
+
    1333.           **/
      1334. 
+
    1334.          UNCONDITIONED_JOIN_TYPES: ["natural", "naturalLeft", "naturalRight", "naturalFull", "cross"],
      1335. 
+
    1335.  
      1336. 
+
    1336.          /**
      1337. 
+
    1337.           *  The dataset options that require the removal of cached columns
      1338. 
+
    1338.           *  if changed.
      1339. 
 
    1339.           */
      1340. 
-
    1340.          validateOnUpdate:true,
      1341. 
+
    1341.          COLUMN_CHANGE_OPTS: ["select", "sql", "from", "join"],
      1342. 
 
    1342.  
      1343. 
-
    1343.          init:function () {
      1344. 
-
    1344. 35            this._super(arguments);
      1345. 
-
    1345.          },
      1346. 
+
    1346.          /**
      1347. 
+
    1347.           * Which options don't affect the SQL generation.  Used by {@link patio.Dataset#simpleSelectAll}
      1348. 
+
    1348.           * to determine if this is a simple SELECT * FROM table.
      1349. 
+
    1349.           */
      1350. 
+
    1350.          NON_SQL_OPTIONS: ["server", "defaults", "overrides", "graph", "eagerGraph", "graphAliases"],
      1351. 
 
    1351.  
      1352. 
-
    1352.          __initValidation:function () {
      1353. 
-
    1353. 43            if (!this.__isValidationInited) {
      1354. 
-
    1354. 34                this.validators = [];
      1355. 
-
    1355. 34                this.pre("save", function preSaveValidate(next, opts) {
      1356. 
-
    1356. 114                    validateHook.call(this, this._static.validateOnSave, next, opts);
      1357. 
-
    1357.                  });
      1358. 
-
    1358. 34                this.pre("update", function preUpdateValidate(next, opts) {
      1359. 
-
    1359. 1                    validateHook.call(this, this._static.validateOnSave, next, opts);
      1360. 
-
    1360.                  });
      1361. 
-
    1361. 34                this.__isValidationInited = true;
      1362. 
-
    1362.              }
      1363. 
-
    1363.          },
      1364. 
 
    1364.  
      1365. 
-
    1365.          __getValidator:function validator(name) {
      1366. 
-
    1366. 44            var ret = new Validator(name);
      1367. 
-
    1367. 44            this.validators.push(ret);
      1368. 
-
    1368. 44            return ret;
      1369. 
-
    1369.          },
      1370. 
+
    1370.          /**
      1371. 
+
    1371.           *  All methods that return modified datasets with a joined table added.
      1372. 
+
    1372.           */
      1373. 
+
    1373.          JOIN_METHODS: ["join", "joinTable"],
      1374. 
 
    1374.  
      1375. 
 
    1375.          /**
      1376. 
-
    1376.           * Sets up validation for a model.
      1377. 
-
    1377.           *
      1378. 
-
    1378.           * To do single col validation
      1379. 
-
    1379.           * {@code
      1380. 
-
    1380.           *
      1381. 
-
    1381.           * var Model = patio.addModel("validator", {
      1382. 
-
    1382.           *      plugins:[ValidatorPlugin]
      1383. 
-
    1383.           * });
      1384. 
-
    1384.           * //this ensures column assignment
      1385. 
-
    1385.           * Model.validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
      1386. 
-
    1386.           * //col2 does not have to be assigned but if it is it must match /hello/ig.
      1387. 
-
    1387.           * Model.validate("col2").like(/hello/ig);
      1388. 
-
    1388.           * //Ensures that the emailAddress column is a valid email address.
      1389. 
-
    1389.           * Model.validate("emailAddress").isEmailAddress();
      1390. 
-
    1390.           * }
      1391. 
-
    1391.           *
      1392. 
-
    1392.           * Or you can do a mass validation through a callback.
      1393. 
-
    1393.           * {@code
      1394. 
-
    1394.           *
      1395. 
-
    1395.           * var Model = patio.addModel("validator", {
      1396. 
-
    1396.           *      plugins:[ValidatorPlugin]
      1397. 
-
    1397.           * });
      1398. 
-
    1398.           * Model.validate(function(validate){
      1399. 
-
    1399.           *      //this ensures column assignment
      1400. 
-
    1400.           *      validate("col1").isDefined().isAlphaNumeric().hasLength(1, 10);
      1401. 
-
    1401.           *      //col2 does not have to be assigned but if it is it must match /hello/ig.
      1402. 
-
    1402.           *      validate("col2").isLike(/hello/ig);
      1403. 
-
    1403.           *      //Ensures that the emailAddress column is a valid email address.
      1404. 
-
    1404.           *      validate("emailAddress").isEmail();
      1405. 
-
    1405.           * });
      1406. 
-
    1406.           * }
      1407. 
-
    1407.           *
      1408. 
-
    1408.           *
      1409. 
-
    1409.           * @param {String|Function} name the name of the column, or a callback that accepts a function to create validators.
      1410. 
-
    1410.           *
      1411. 
-
    1411.           * @throws {patio.ModelError} if name is not a function or string.
      1412. 
-
    1412.           * @return {patio.Model|Validator} returns a validator if name is a string, other wise returns this for chaining.
      1413. 
+
    1413.           * Methods that return modified datasets
      1414. 
 
    1414.           */
      1415. 
-
    1415.          validate:function (name) {
      1416. 
-
    1416. 43            this.__initValidation();
      1417. 
-
    1417. 43            var ret;
      1418. 
-
    1418. 43            if (isFunction(name)) {
      1419. 
-
    1419. 1                name.apply(this, [this.__getValidator.bind(this)]);
      1420. 
-
    1420. 1                ret = this;
      1421. 
-
    1421. 42            } else if (isString(name)) {
      1422. 
-
    1422. 42                ret = this.__getValidator(name);
      1423. 
-
    1423.              } else {
      1424. 
-
    1424. 0                throw new ModelError("name is must be a string or function when validating");
      1425. 
-
    1425.              }
      1426. 
-
    1426. 43            return ret;
      1427. 
+
    1427.          QUERY_METHODS: ['addGraphAliases', "and", "distinct", "except", "exclude", "filter", "find", "is", "isNot",
      1428. 
+
    1428.              "eq", "neq", "lt", "lte", "gt", "gte", "forUpdate", "from", "fromSelf", "graph", "grep", "group",
      1429. 
+
    1429.              "groupAndCount", "groupBy", "having", "intersect", "invert", "limit", "lockStyle", "naked", "or", "order",
      1430. 
+
    1430.              "orderAppend", "orderBy", "orderMore", "orderPrepend", "qualify", "reverse",
      1431. 
+
    1431.              "reverseOrder", "select", "selectAll", "selectAppend", "selectMore", "setDefaults",
      1432. 
+
    1432.              "setGraphAliases", "setOverrides", "unfiltered", "ungraphed", "ungrouped", "union", "unlimited",
      1433. 
+
    1433.              "unordered", "where", "with", "withRecursive", "withSql"],
      1434. 
+
    1434.  
      1435. 
+
    1435.          init: function () {
      1436. 
+
    1436. 35            this._super(arguments);
      1437. 
+
    1437.              //initialize our join methods array
      1438. 
+
    1438. 35            var joinMethods = this.JOIN_METHODS;
      1439. 
+
    1439. 35            var queryMethods = this.QUERY_METHODS;
      1440. 
+
    1440. 35            this.UNCONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      1441. 
+
    1441. 175                var m = joinType + "Join";
      1442. 
+
    1442. 175                joinMethods.push(m);
      1443. 
+
    1443. 175                queryMethods.push(m);
      1444. 
+
    1444.              });
      1445. 
+
    1445. 35            this.CONDITIONED_JOIN_TYPES.forEach(function (joinType) {
      1446. 
+
    1446. 245                var m = joinType + "Join";
      1447. 
+
    1447. 245                joinMethods.push(m);
      1448. 
+
    1448. 245                queryMethods.push(m);
      1449. 
+
    1449.              });
      1450. 
+
    1450. 35            this.QUERY_METHODS = queryMethods.concat(joinMethods);
      1451. 
 
    1451.          }
      1452. 
 
    1452.      }
      1453. 
-
    1453.  
      1454. 
-
    1454.  }).as(module);
      1455. 
-
    1455.
    +
  • }).
    • +
  • as(module);
    • @@ -21056,8 +21113,8 @@
  • * @ignore
  • */
  • constructor:function () {
    • -
  • 25725 !Dataset && (Dataset = require("../index").Dataset);
    • -
  • 25725 this._super(arguments);
    • +
  • 25745 !Dataset && (Dataset = require("../index").Dataset);
    • +
  • 25745 this._super(arguments);
  • },
  • /**
    • @@ -21736,7 +21793,7 @@
  • // Whether this dataset quotes identifiers.
  • /**@ignore*/
  • quoteIdentifiers:function(){
    • -
  • 42250 return this.__quoteIdentifiers;
    • +
  • 42266 return this.__quoteIdentifiers;
  • },
  • // Whether this dataset will provide accurate number of rows matched for
    • @@ -21744,80 +21801,80 @@
  • // rows matched by the dataset's filter.
  • /**@ignore*/
  • providesAccurateRowsMatched:function(){
    • -
  • 13414 return this.__providesAccurateRowsMatched;
    • +
  • 13418 return this.__providesAccurateRowsMatched;
  • },
  • //Whether the dataset requires SQL standard datetimes (false by default,
  • // as most allow strings with ISO 8601 format).
  • /**@ignore*/
  • requiresSqlStandardDateTimes:function(){
    • -
  • 13421 return this.__requiresSqlStandardDateTimes;
    • +
  • 13425 return this.__requiresSqlStandardDateTimes;
  • },
  • // Whether the dataset supports common table expressions (the WITH clause).
  • /**@ignore*/
  • supportsCte:function(){
    • -
  • 13427 return this.__supportsCte;
    • +
  • 13431 return this.__supportsCte;
  • },
  • // Whether the dataset supports the DISTINCT ON clause, false by default.
  • /**@ignore*/
  • supportsDistinctOn:function(){
    • -
  • 2291 return this.__supportsDistinctOn;
    • +
  • 2295 return this.__supportsDistinctOn;
  • },
  • //Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExcept:function(){
    • -
  • 13450 return this.__supportsIntersectExcept;
    • +
  • 13454 return this.__supportsIntersectExcept;
  • },
  • //Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExceptAll:function(){
    • -
  • 13426 return this.__supportsIntersectExceptAll;
    • +
  • 13430 return this.__supportsIntersectExceptAll;
  • },
  • //Whether the dataset supports the IS TRUE syntax.
  • /**@ignore*/
  • supportsIsTrue:function(){
    • -
  • 13623 return this.__supportsIsTrue;
    • +
  • 13627 return this.__supportsIsTrue;
  • },
  • //Whether the dataset supports the JOIN table USING (column1, ...) syntax.
  • /**@ignore*/
  • supportsJoinUsing:function(){
    • -
  • 13425 return this.__supportsJoinUsing;
    • +
  • 13429 return this.__supportsJoinUsing;
  • },
  • //Whether modifying joined datasets is supported.
  • /**@ignore*/
  • supportsModifyingJoins:function(){
    • -
  • 2531 return this.__supportsModifyingJoins;
    • +
  • 2535 return this.__supportsModifyingJoins;
  • },
  • //Whether the IN/NOT IN operators support multiple columns when an
  • /**@ignore*/
  • supportsMultipleColumnIn:function(){
    • -
  • 13418 return this.__supportsMultipleColumnIn;
    • +
  • 13422 return this.__supportsMultipleColumnIn;
  • },
  • //Whether the dataset supports timezones in literal timestamps
  • /**@ignore*/
  • supportsTimestampTimezones:function(){
    • -
  • 2288 return this.__supportsTimestampTimezones;
    • +
  • 2292 return this.__supportsTimestampTimezones;
  • },
  • //Whether the dataset supports fractional seconds in literal timestamps
  • /**@ignore*/
  • supportsTimestampUsecs:function(){
    • -
  • 13414 return this.__supportsTimestampUsecs;
    • +
  • 13418 return this.__supportsTimestampUsecs;
  • },
  • //Whether the dataset supports window functions.
  • /**@ignore*/
  • supportsWindowFunctions:function(){
    • -
  • 13414 return this.__supportsWindowFunctions;
    • +
  • 13418 return this.__supportsWindowFunctions;
  • }
  • },
    • @@ -21828,7 +21885,7 @@
  • // Whether this dataset quotes identifiers.
  • /**@ignore*/
  • quoteIdentifiers:function(val){
    • -
  • 13426 this.__quoteIdentifiers = val;
    • +
  • 13430 this.__quoteIdentifiers = val;
  • },
  • // Whether this dataset will provide accurate number of rows matched for
    • @@ -21836,80 +21893,80 @@
  • // rows matched by the dataset's filter.
  • /**@ignore*/
  • providesAccurateRowsMatched:function(val){
    • -
  • 13414 this.__providesAccurateRowsMatched = val;
    • +
  • 13418 this.__providesAccurateRowsMatched = val;
  • },
  • //Whether the dataset requires SQL standard datetimes (false by default,
  • // as most allow strings with ISO 8601 format).
  • /**@ignore*/
  • requiresSqlStandardDateTimes:function(val){
    • -
  • 13414 this.__requiresSqlStandardDateTimes = val;
    • +
  • 13418 this.__requiresSqlStandardDateTimes = val;
  • },
  • // Whether the dataset supports common table expressions (the WITH clause).
  • /**@ignore*/
  • supportsCte:function(val){
    • -
  • 13415 this.__supportsCte = val;
    • +
  • 13419 this.__supportsCte = val;
  • },
  • // Whether the dataset supports the DISTINCT ON clause, false by default.
  • /**@ignore*/
  • supportsDistinctOn:function(val){
    • -
  • 2289 this.__supportsDistinctOn = val;
    • +
  • 2293 this.__supportsDistinctOn = val;
  • },
  • //Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExcept:function(val){
    • -
  • 13416 this.__supportsIntersectExcept = val;
    • +
  • 13420 this.__supportsIntersectExcept = val;
  • },
  • //Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
  • /**@ignore*/
  • supportsIntersectExceptAll:function(val){
    • -
  • 13416 this.__supportsIntersectExceptAll = val;
    • +
  • 13420 this.__supportsIntersectExceptAll = val;
  • },
  • //Whether the dataset supports the IS TRUE syntax.
  • /**@ignore*/
  • supportsIsTrue:function(val){
    • -
  • 13414 this.__supportsIsTrue = val;
    • +
  • 13418 this.__supportsIsTrue = val;
  • },
  • //Whether the dataset supports the JOIN table USING (column1, ...) syntax.
  • /**@ignore*/
  • supportsJoinUsing:function(val){
    • -
  • 13416 this.__supportsJoinUsing = val;
    • +
  • 13420 this.__supportsJoinUsing = val;
  • },
  • //Whether modifying joined datasets is supported.
  • /**@ignore*/
  • supportsModifyingJoins:function(val){
    • -
  • 2289 this.__supportsModifyingJoins = val;
    • +
  • 2293 this.__supportsModifyingJoins = val;
  • },
  • //Whether the IN/NOT IN operators support multiple columns when an
  • /**@ignore*/
  • supportsMultipleColumnIn:function(val){
    • -
  • 13414 this.__supportsMultipleColumnIn = val;
    • +
  • 13418 this.__supportsMultipleColumnIn = val;
  • },
  • //Whether the dataset supports timezones in literal timestamps
  • /**@ignore*/
  • supportsTimestampTimezones:function(val){
    • -
  • 2288 this.__supportsTimestampTimezones = val;
    • +
  • 2292 this.__supportsTimestampTimezones = val;
  • },
  • //Whether the dataset supports fractional seconds in literal timestamps
  • /**@ignore*/
  • supportsTimestampUsecs:function(val){
    • -
  • 13414 this.__supportsTimestampUsecs = val;
    • +
  • 13418 this.__supportsTimestampUsecs = val;
  • },
  • //Whether the dataset supports window functions.
  • /**@ignore*/
  • supportsWindowFunctions:function(val){
    • -
  • 13414 this.__supportsWindowFunctions = val;
    • +
  • 13418 this.__supportsWindowFunctions = val;
  • }
  • }
    • diff --git a/package.json b/package.json index cf5d4c9a..65be47f7 100755 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "patio", "description": "Patio query engine and ORM", - "version": "0.2.10", + "version": "0.2.11", "keywords": [ "ORM", "object relation mapper",