1var comb = require("comb-proxy"),
     define = comb.define,
     isUndefined = comb.isUndefined,
     isUndefinedOrNull = comb.isUndefinedOrNull,
     isFunction = comb.isFunction,
     isInstanceOf = comb.isInstanceOf,
     sql = require("../sql").sql,
     array = comb.array,
     isBoolean = comb.isBoolean,
     when = comb.when,
     zip = array.zip,
     Promise = comb.Promise,
     PromiseList = comb.PromiseList,
     OneToMany = require("./oneToMany"),
     pluralize = comb.pluralize,
     AssociationError = require("../errors").AssociationError;
 
1var LOGGER = comb.logger("comb.associations.ManyToMany");
 /**
  * @class Class to define a manyToMany association.
  *
  * </br>
  * <b>NOT to be instantiated directly</b>
  * Its just documented for reference.
  *
  * @name ManyToMany
  * @augments patio.associations.OneToMany
  * @memberOf patio.associations
  *
  * @param {String} options.joinTable the joinTable of the association.
  *
  *
  * @property {String} joinTable the join table used in the relation.
  * */
1module.exports = define(OneToMany, {
     instance: {
         /**@lends patio.associations.ManyToMany.prototype*/
         type: "manyToMany",
 
         _fetchMethod: "all",
 
         supportsStringKey: false,
 
         supportsCompositeKey: false,
 
 
         _filter: function (parent) {
205            var keys = this._getAssociationKey(parent), options = this.__opts || {}, ds, self = this;
205            if (!isUndefined((ds = options.dataset)) && isFunction(ds)) {
0                ds = ds.apply(parent, [parent]);
             }
205            if (!ds) {
205                ds = this.model.dataset.select(sql.identifier(this.model.__tableName).all()).naked().innerJoin(this.joinTableName, zip(keys[1], this.modelPrimaryKey.map(function (k) {
205                    return sql.stringToIdentifier(k);
                 })).concat(zip(keys[0], this.parentPrimaryKey.map(function (k) {
205                        return parent[k];
                     }))));
205                var recip = this.model._findAssociation(this);
205                if (recip) {
205                    recip = recip[1];
                 }
205                ds.rowCb = function (item) {
200                    var model = self._toModel(item, true);
200                    if (recip) {
200                        recip.__setValue(model, parent);
                     }
                     //call hook to finish other model associations
200                    return model._hook("post", "load").chain(function () {
200                        return model;
                     });
                 };
 
0            } else if (!ds.rowCb && this.model) {
0                ds.rowCb = function (item) {
0                    var model = self._toModel(item, true);
                     //call hook to finish other model associations
0                    return model._hook("post", "load").chain(function () {
0                        return model;
                     });
                 };
             }
 
205            return this._setDatasetOptions(ds);
         },
 
         _setAssociationKeys: function (parent, model, val) {
349            var keys = this._getAssociationKey(parent),
                 leftKey = keys[0],
                 parentPk = this.parentPrimaryKey;
349            if (!(leftKey && leftKey.length === parentPk.length)) {
0                throw new AssociationError("Invalid leftKey for " + this.name + " : " + leftKey);
             }
349            for (var i = 0; i < leftKey.length; i++) {
349                model[leftKey[i]] = !isUndefined(val) ? val : parent[parentPk[i]];
             }
         },
 
 
         __createJoinTableInsertRemoveQuery: function (model, item) {
82            var q = {};
82            var keys = this._getAssociationKey(model),
                 leftKey = keys[0],
                 rightKey = keys[1],
                 parentPk = this.parentPrimaryKey,
                 modelPk = this.modelPrimaryKey;
82            if (!(leftKey && leftKey.length === parentPk.length)) {
0                throw new AssociationError("Invalid leftKey for " + this.name + " : " + leftKey);
             }
82            if (!(rightKey && rightKey.length === modelPk.length)) {
0                throw new AssociationError("Invalid rightKey for " + this.name + " : " + rightKey);
             }
82            for (var i = 0; i < leftKey.length; i++) {
82                q[leftKey[i]] = model[parentPk[i]];
             }
82            for (i = 0; i < rightKey.length; i++) {
82                q[rightKey[i]] = item[modelPk[i]];
             }
82            return q;
         },
 
         _preRemove: function (next, model) {
145            if (this.isOwner && !this.isCascading) {
145                var q = {};
145                this._setAssociationKeys(model, q);
145                this.joinTable.where(q).remove().classic(next);
             } else {
0                next();
             }
         },
 
 
         addAssociation: function (item, model, reload) {
114            reload = isBoolean(reload) ? reload : false;
114            var ret = new Promise().callback(model);
114            if (!isUndefinedOrNull(item)) {
114                if (!model.isNew) {
70                    item = this._toModel(item);
70                    var loaded = this.associationLoaded(model);
70                    var recip = this.model._findAssociation(this), save = item.isNew, self = this;
70                    ret = model._checkTransaction(function () {
70                        var joinTable = self.joinTable;
70                        return when(save ? item.save() : null)
                             .chain(function () {
70                                return joinTable.insert(self.__createJoinTableInsertRemoveQuery(model, item));
                             })
                             .chain(function () {
70                                if (recip) {
70                                    recip[1].__setValue(item, [model]);
                                 }
                             })
                             .chain(function () {
70                                if (loaded && reload) {
2                                    return self.parent._reloadAssociationsForType(self.type, self.model, model);
                                 } else {
68                                    return model;
                                 }
                             })
                             .chain(function () {
70                                return model;
                             });
                     });
                 } else {
44                    item = this._toModel(item);
44                    var items = this.getAssociation(model);
44                    if (isUndefinedOrNull(items)) {
15                        this.__setValue(model, [item]);
                     } else {
29                        items.push(item);
                     }
                 }
             }
114            return ret.promise();
         },
 
         removeItem: function (item, model, remove, reload) {
24            reload = isBoolean(reload) ? reload : false;
24            remove = isBoolean(remove) ? remove : false;
24            if (!isUndefinedOrNull(item)) {
24                if (!model.isNew) {
24                    if (isInstanceOf(item, this.model) && !item.isNew) {
24                        var loaded = this.associationLoaded(model), self = this;
24                        remove = remove && !item.isNew;
24                        return model
                             ._checkTransaction(function () {
24                                return remove ? item.remove() : self.joinTable.where(self.__createJoinTableInsertRemoveQuery(model, item)).remove();
                             }).chain(function () {
24                                if (loaded && reload) {
10                                    return self.parent._reloadAssociationsForType(self.type, self.model, model);
                                 }
                             }).chain(function () {
24                                return model;
                             });
                     }
                 } else {
0                    item = this._toModel(item);
0                    var items = this.getAssociation(model), index;
0                    if (!isUndefinedOrNull(items) && (index = items.indexOf(item)) !== -1) {
0                        items.splice(index, 1);
                     }
0                    return when(model);
                 }
             }
         },
 
         removeAllItems: function (model, remove) {
0            remove = isBoolean(remove) ? remove : false;
0            var ret;
0            if (!model.isNew) {
0                var q = {}, removeQ = {};
0                this._setAssociationKeys(model, q);
0                this._setAssociationKeys(model, removeQ, null);
0                var loaded = this.associationLoaded(model), self = this;
0                ret = model._checkTransaction(function () {
0                    return when(
                         remove ? self._filter(model).forEach(function (m) {
0                            return m.remove();
                         }) : self.joinTable.filter(q).update(removeQ)
                     ).chain(function () {
0                            if (loaded) {
0                                return self.parent._reloadAssociationsForType(self.type, self.model, model)
                                     .chain(function () {
0                                        return model;
                                     });
                             } else {
0                                return model;
                             }
                         });
                 });
             } else {
                 //todo we may want to check if any of the items were previously saved items;
0                this._clearAssociations(model);
0                ret = new Promise().callback(model);
             }
0            return ret;
         },
 
 
         getters: {
 
             select: function () {
205                return this.__select;
             },
 
             defaultLeftKey: function () {
1021                return this.__opts.leftKey || this.parent.tableName + "Id";
             },
 
             defaultRightKey: function () {
1021                return this.__opts.rightKey || this.model.tableName + "Id";
             },
 
             parentPrimaryKey: function () {
636                return this.__opts.leftPrimaryKey || this.parent.primaryKey;
             },
 
             modelPrimaryKey: function () {
287                return this.__opts.rightPrimaryKey || this.model.primaryKey;
             },
 
             joinTableName: function () {
217                if (!this._joinTable) {
12                    var options = this.__opts;
12                    var joinTable = options.joinTable;
12                    if (isUndefined(joinTable)) {
10                        var defaultJoinTable = this.defaultJoinTable;
10                        if (isUndefined(defaultJoinTable)) {
0                            throw new AssociationError("Unable to determine jointable for " + this.name);
                         } else {
10                            this._joinTable = defaultJoinTable;
                         }
                     } else {
2                        this._joinTable = joinTable;
                     }
                 }
217                return this._joinTable;
             },
 
             //returns our join table model
             joinTable: function () {
227                if (!this.__joinTableDataset) {
12                    var ds = this.__joinTableDataset = this.model.dataset.db.from(this.joinTableName), model = this.model, options = this.__opts;
12                    var identifierInputMethod = isUndefined(options.identifierInputMethod) ? model.identifierInputMethod : options.identifierInputMethod,
                         identifierOutputMethod = isUndefined(options.identifierOutputMethod) ? model.identifierOutputMethod : options.identifierOutputMethod;
12                    if (identifierInputMethod) {
6                        ds.identifierInputMethod = identifierInputMethod;
                     }
12                    if (identifierOutputMethod) {
6                        ds.identifierOutputMethod = identifierOutputMethod;
                     }
                 }
227                return this.__joinTableDataset;
             },
 
             defaultJoinTable: function () {
10                var ret;
10                var recip = this.model._findAssociation(this);
10                if (recip && recip.length) {
10                    var names = [pluralize(this._model), pluralize(recip[1]._model)].sort();
10                    names[1] = names[1].charAt(0).toUpperCase() + names[1].substr(1);
10                    ret = names.join("");
                 }
10                return ret;
             }
         }
     }
 });
 

1var pg = require("pg"),
     PgTypes = require("pg-types"),
     QueryStream = require('pg-query-stream'),
     comb = require("comb"),
     asyncArray = comb.async.array,
     string = comb.string,
     isHash = comb.isHash,
     argsToArray = comb.argsToArray,
     pad = string.pad,
     format = string.format,
     when = comb.when,
     array = comb.array,
     toArray = array.toArray,
     zip = array.zip,
     flatten = array.flatten,
     Promise = comb.Promise,
     isUndefinedOrNull = comb.isUndefinedOrNull,
     isString = comb.isString,
     isArray = comb.isArray,
     isEmpty = comb.isEmpty,
     isBoolean = comb.isBoolean,
     isObject = comb.isObject,
     isFunction = comb.isFunction,
     define = comb.define,
     merge = comb.merge,
     isDefined = comb.isDefined,
     isInstanceOf = comb.isInstanceOf,
     QueryError = require("../errors").QueryError,
     Dataset = require("../dataset"),
     Database = require("../database"),
     sql = require("../sql").sql,
     stringToIdentifier = sql.stringToIdentifier,
     DateTime = sql.DateTime,
     Time = sql.Time,
     Year = sql.Year,
     literal = sql.literal,
     StringExpression = sql.StringExpression,
     identifier = sql.identifier,
     BooleanExpression = sql.BooleanExpression,
     LiteralString = sql.LiteralString,
     Subscript = sql.Subscript,
     patio, DS,
     stream = require("stream"),
     PassThroughStream = stream.PassThrough,
     pipeAll = require("../utils").pipeAll,
     hashPick = comb.hash.pick;
 
1var getPatio = function () {
898    return patio || (patio = require("../index.js"));
 };
 
1var isBlank = function (obj) {
768    var ret = false;
768    if (isUndefinedOrNull(obj)) {
679        ret = true;
89    } else if (isString(obj) || isArray(obj)) {
89        ret = obj.length === 0;
0    } else if (isBoolean(obj) && !obj) {
0        ret = true;
0    } else if (isObject(obj) && isEmpty(obj)) {
0        ret = true;
     }
768    return ret;
 };
 
1var byteaParser = function (val) {
12    if (val.toString().indexOf("\\x") === 0) {
12        val = val.toString().replace(/^\\x/, "");
12        return new Buffer(val, "hex");
     } else {
0        val = val.toString().replace(/\\([0-7]{3})/g, function (fullMatch, code) {
0            return String.fromCharCode(parseInt(code, 8));
         }).replace(/\\\\/g, "\\");
0        return new Buffer(val, "binary");
     }
 };
 
1PgTypes.setTypeParser(17, "text", byteaParser);
1var timestampOrig = PgTypes.getTypeParser(1114, "text");
 //PgTypes.setTypeParser(25, "text", byteaParser);
1PgTypes.setTypeParser(1114, "text", function (val) {
38    val = String(val);
38    if (!val.match(/\.(\d{0,3})/)) {
0        val += ".000";
     } else {
38        val = val.replace(/\.(\d{0,3})$/, function (m, m1) {
38            return "." + pad(m1, 3, "0", true);
         });
     }
38    return getPatio().stringToTimeStamp(val.toString(), DS.TIMESTAMP_FORMAT).date;
 });
1PgTypes.setTypeParser(1184, "text", function (val) {
0    return getPatio().stringToDate(val.toString());
 });
 
1PgTypes.setTypeParser(1082, "text", function (val) {
4    return getPatio().stringToDate(val.toString());
 });
 
1PgTypes.setTypeParser(1083, "text", function (val) {
2    val = String(val);
2    if (!val.match(/\.(\d{0,3})/)) {
0        val += ".000";
     } else {
2        val = val.replace(/\.(\d{0,3})$/, function (m, m1) {
2            return "." + pad(m1, 3, "0", true);
         });
     }
2    return getPatio().stringToTime(val.toString(), DS.TIME_FORMAT);
 });
 
1PgTypes.setTypeParser(1700, "text", parseFloat);
 
1PgTypes.setTypeParser(114, "text", function (data) {
854    return getPatio().sql.json(JSON.parse(data));
 });
 
 
1var Connection = define(null, {
     instance: {
 
         connection: null,
 
         errored: false,
 
         closed: false,
 
 
         constructor: function (conn) {
64            this.connection = conn;
         },
 
         closeConnection: function () {
63            this.closed = true;
63            this.connection.end();
63            return new Promise().callback().promise();
         },
 
         stream: function (query, opts) {
3            var ret;
3            if (!this.closed) {
3                try {
3                    opts = hashPick(opts || {}, ["batchSize", "highWaterMark"]);
3                    this.connection.setMaxListeners(0);
3                    var fields = [];
3                    query = new QueryStream(query, null, opts);
3                    ret = this.connection.query(query);
3                    var orig = ret.handleRowDescription;
3                    ret.handleRowDescription = function (msg) {
2                        ret.emit("fields", msg.fields);
2                        ret.handleRowDescription = orig;
2                        return orig.apply(ret, arguments);
                     };
                 } catch (e) {
0                    ret = new PassThroughStream();
0                    setImmediate(function () {
0                        ret.emit("error", e);
                     });
                 }
             } else {
0                ret = new PassThroughStream();
0                setImmediate(function () {
0                    ret.emit("error", new Error("Connection already closed"));
                 });
             }
3            return ret;
         },
 
         query: function (query) {
6493            var ret = new Promise();
6493            if (!this.closed) {
6493                try {
6493                    this.connection.setMaxListeners(0);
6493                    var fields = [], rows = [];
6493                    var q = this.connection.query(query)
                         .on("error", ret.errback)
                         .on("row", function(row){
4777                            rows.push(row);
                         })
                         .on("end", function(){
6425                        ret.callback(rows, fields);
                     });
6493                    var orig = q.handleRowDescription;
6493                    q.handleRowDescription = function (msg) {
3800                        fields = msg.fields;
3800                        q.handleRowDescription = orig;
3800                        return orig.apply(q, arguments);
                     };
                 } catch (e) {
0                    ret.errback(e);
                 }
             } else {
0                ret.errback(new Error("Connection already closed"));
             }
6493            return ret.promise();
         }
     }
 });
 
1function colCallback(o) {
29633    return o;
 }
 
1DS = define(Dataset, {
     instance: {
 
         complexExpressionSql: function (op, args) {
5608            var ret = "";
5608            if (op === "^") {
0                var j = this._static.XOR_OP, c = false;
0                args.forEach(function (a) {
0                    if (c) {
0                        ret += j;
                     }
0                    ret += this.literal(a);
0                    c = true;
                 }, true);
             } else {
5608                return this._super(arguments);
             }
0            return ret;
         },
 
         forShare: function () {
0            return this.lockStyle("share");
         },
 
         fullTextSearch: function (cols, terms, opts) {
3            opts = opts || {};
3            var lang = opts.language || 'simple';
3            if (Array.isArray(terms)) {
1                terms = terms.join(' | ');
             }
3            return this.filter("to_tsvector(?, ?) @@ to_tsquery(?, ?)", lang, this.__fullTextStringJoin(toArray(cols).map(function (c) {
4                return stringToIdentifier(c);
             })), lang, terms);
         },
 
         /**
          * Lock all tables in the datasets from clause (but not in JOINs), in the specified mode. If
          * a function is passed in as the last argument
          * @para {String} mode the lock mode (e.g. 'EXCLUSIVE').
          * @param {Object} [opts] see {@link patio.Database#transaction} for options.
          * @param {Function} [cb] of provided then a new {@link patio.Database} transaction is started.
          *
          */
         lock: function (mode, opts, cb) {
3            if (isFunction(opts)) {
1                cb = opts;
1                opts = null;
             } else {
2                opts = opts || {};
             }
3            if (isFunction(cb)) {
1                var self = this;
1                return this.db.transaction(opts, function () {
1                    return self.lock(mode, opts)
                         .chain(function () {
1                            return cb.call(self);
                         });
                 });
             } else {
2                return this.db.execute(format(this._static.LOCK, [this._sourceList(this.__opts.from), mode]), opts);
             }
         },
 
         multiInsertSql: function (columns, values) {
1            var ret = literal('VALUES ');
1            ret += this.__expressionList(values.map(function (r) {
2                return toArray(r);
             }));
1            return [this.insertSql(columns.map(function (c) {
2                return stringToIdentifier(c);
             }), literal(ret))];
         },
 
         _literalString: function (v) {
5369            return "'" + v.replace(/'/g, "''") + "'";
         },
 
         _literalJson: function (v) {
504            return "'" + JSON.stringify(v).replace(/'/g, "''") + "'";
         },
 
         _deleteFromSql: function () {
730            var self = this._static, space = self.SPACE;
730            return [space, self.FROM, space, this._sourceList(this.__opts.from[0])].join("");
         },
 
 
         _deleteUsingSql: function () {
730            return this._joinFromSql("USING");
         },
 
         _joinFromSql: function (type) {
932            var from = this.__opts.from.slice(1), join = this.__opts.join, ret = "";
932            if (!from.length) {
932                if (!isEmpty(join)) {
0                    throw new QueryError("Need multiple FROM tables if updating/deleteing a dataset with joins");
                 }
             } else {
0                var space = this._static.SPACE;
0                ret = [space, type.toString(), space, this._sourceList(from), this._selectJoinSql()].join("");
             }
932            return ret;
         },
 
         _selectLockSql: function () {
2712            if (this.__opts.lock === "share") {
0                return this._static.FOR_SHARE;
             } else {
2712                return this._super(arguments);
             }
         },
 
         _selectWithSql: function () {
4764            var optsWith = this.__opts["with"];
4764            if (!isEmpty(optsWith) && optsWith.some(function (w) {
0                    return w.recursive;
                 })) {
0                return this._static.SQL_WITH_RECURSIVE;
             } else {
4764                return this._super(arguments);
             }
         },
 
         _updateFromSql: function () {
202            return this._joinFromSql("FROM");
         },
 
         _updateTableSql: function () {
202            return [this._static.SPACE, this._sourceList(this.__opts.from.slice(0, 1))].join("");
         },
 
         _quotedIdentifier: function (c) {
25184            return format('"%s"', c);
         },
 
         __fullTextStringJoin: function (cols) {
5            var EMPTY_STRING = this._static.EMPTY_STRING;
5            cols = toArray(cols).map(function (x) {
7                return sql.COALESCE(x, EMPTY_STRING);
             });
5            cols = flatten(zip(cols, array.multiply([this._static.SPACE], cols.length)));
5            cols.pop();
5            return StringExpression.fromArgs(['||'].concat(cols));
         },
 
         insert: function () {
2226            var args = arguments;
2226            if (this.__opts.returning) {
1113                return this._super(arguments);
             } else {
1113                var self = this;
1113                return this.primaryKey(this.__opts.from).chain(function (res) {
1113                    var pks = res.map(function (r) {
1024                        return r.name;
                     });
1113                    var ds = self.returning.apply(self, pks);
1113                    var dsPromise = ds.insert.apply(ds, args), l = res.length;
1113                    if (l) {
1024                        return dsPromise.chain(function (insertRes) {
1024                            if (l === 1) {
1024                                return insertRes.map(function (i) {
1024                                    return i[pks[0]];
                                 }).pop();
                             } else {
0                                return insertRes.pop();
                             }
                         });
                     } else {
89                        return dsPromise;
                     }
                 });
             }
         },
 
         primaryKey: function () {
1113            return this.db.primaryKey(this.__opts.from[0]);
         },
 
         __processFields: function (fields) {
2689            var col, colOutputIdentifier, i = -1, l, cols = [],
                 outputIdentifier = this.outputIdentifier,
                 selfCols = ( this.__columns = []);
2689            if (fields && fields.length) {
2689                l = fields.length;
2689                while (++i < l) {
21240                    colOutputIdentifier = outputIdentifier(col = fields[i].name);
21240                    selfCols[i] = colOutputIdentifier;
21240                    cols[i] = [colOutputIdentifier, colCallback, col];
                 }
             }
2689            return cols;
         },
 
         _literalTimestamp: function (v) {
28            return this.literal(literal("TIMESTAMP " + this._super(arguments) + ""));
         },
 
         _literalBuffer: function (b) {
8            return this.literal(literal("decode('" + b.toString("hex") + "', 'hex')"));
         },
 
         getters: {
 
             columns: function () {
6                var ret;
6                if (this.__columns) {
0                    ret = when(this.__columns);
                 } else {
6                    var self = this;
6                    ret = this.db.schema(this.firstSourceTable).chain(function (schema) {
6                        var columns = (schema ? Object.keys(schema) : []);
6                        self.__columns = columns;
6                        return columns;
                     });
                 }
6                return ret.promise();
             },
 
             supportsCteInSubqueries: function () {
0                return true;
             },
 
             supportsDistinctOn: function () {
11576                return true;
             },
 
             supportsModifyingJoins: function () {
13652                return true;
             },
 
             supportsTimestampTimezones: function () {
11574                return true;
             }
         }
 
 
     },
     "static": {
         ACCESS_SHARE: 'ACCESS SHARE',
         ACCESS_EXCLUSIVE: 'ACCESS EXCLUSIVE',
         BOOL_FALSE: 'false',
         BOOL_TRUE: 'true',
         COMMA_SEPARATOR: ', ',
         DELETE_CLAUSE_METHODS: Dataset.clauseMethods("delete", 'qualify with from using where returning'),
         EXCLUSIVE: 'EXCLUSIVE',
         EXPLAIN: 'EXPLAIN ',
         EXPLAIN_ANALYZE: 'EXPLAIN ANALYZE ',
         FOR_SHARE: ' FOR SHARE',
         INSERT_CLAUSE_METHODS: Dataset.clauseMethods("insert", 'with into columns values returning'),
         LOCK: 'LOCK TABLE %s IN %s MODE',
         NULL: literal('NULL'),
         QUERY_PLAN: 'QUERY PLAN',
         ROW_EXCLUSIVE: 'ROW EXCLUSIVE',
         ROW_SHARE: 'ROW SHARE',
         SELECT_CLAUSE_METHODS: Dataset.clauseMethods("select", '' +
         'qualify with distinct columns from join where group having compounds order limit lock'),
         SHARE: 'SHARE',
         SHARE_ROW_EXCLUSIVE: 'SHARE ROW EXCLUSIVE',
         SHARE_UPDATE_EXCLUSIVE: 'SHARE UPDATE EXCLUSIVE',
         SQL_WITH_RECURSIVE: "WITH RECURSIVE ",
         TIMESTAMP_FORMAT: "yyyy-MM-dd HH:mm:ss.SSS",
         TIME_FORMAT: "HH:mm:ss.SSS",
         UPDATE_CLAUSE_METHODS: Dataset.clauseMethods("update", 'with table set from where returning'),
         XOR_OP: ' # ',
         CRLF: "\r\n",
         BLOB_RE: /[\000-\037\047\134\177-\377]/,
         WINDOW: " WINDOW ",
         EMPTY_STRING: literal("''")
 
 
     }
 }).as(exports, "PostgresDataset");
 
1var DB = define(Database, {
     instance: {
 
         EXCLUDE_SCHEMAS: /pg_*|information_schema/i,
         PREPARED_ARG_PLACEHOLDER: new LiteralString('$'),
         RE_CURRVAL_ERROR: /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/,
         SYSTEM_TABLE_REGEXP: /^pg|sql/,
 
         type: "postgres",
 
         constructor: function () {
31            this._super(arguments);
31            this.__primaryKeys = {};
31            this.__listeners = {};
         },
 
         createConnection: function (opts) {
64            delete opts.query;
64            var self = this, ret;
64            var conn = new pg.Client(merge({}, opts, {typeCast: false}));
64            conn.on("error", function (err) {
0                self.logWarn("Connection from " + self.uri + " errored removing from pool and reconnecting");
0                self.logWarn(err.stack);
0                ret.errored = true;
0                self.pool.removeConnection(ret);
             });
64            conn.on("end", function () {
63                if (!ret.closed) {
0                    self.logWarn("Connection from " + self.uri + " unexpectedly ended");
0                    self.pool.removeConnection(ret);
0                    ret.closed = true;
                 }
             });
64            conn.connect();
64            ret = new Connection(conn);
64            return ret;
         },
 
         closeConnection: function (conn) {
63            return conn.closeConnection();
         },
 
         validate: function (conn) {
1945            return new Promise().callback(!(conn.errored)).promise();
         },
 
         listen: function (channel, cb, opts) {
3            opts = opts || {};
3            channel = this.__quoteSchemaTable(channel);
3            var listeningChannel = channel.toLowerCase();
3            var timeout = opts.timeout || 30000,
                 ret,
                 connected = true, errored = false;
3            var self = this;
3            if (this.quoteIdentifiers) {
0                listeningChannel = listeningChannel.replace(/^"|"$/g, "");
             }
3            var connectionTimeout = setTimeout(function () {
0                if (!connected) {
0                    errored = true;
0                    ret.errback(new Error("Listen: Unable to connect to " + channel));
                 }
             }, timeout);
3            ret = this._getConnection().chain(function (conn) {
3                function __listener(message) {
8                    if (message.channel === listeningChannel) {
8                        cb(JSON.parse(message.payload));
                     }
                 }
 
3                if (!errored) {
3                    connected = true;
3                    clearTimeout(connectionTimeout);
 
3                    conn.connection.on('notification', __listener);
3                    var listeners = conn.__listeners;
3                    if (!listeners) {
2                        listeners = conn.__listeners = {};
                     }
3                    listeners[channel] = __listener;
3                    var sql = self.__listenSql(channel);
3                    return self.__logAndExecute(sql, function () {
3                        return conn.query(sql);
                     }).chain(function () {
3                        self.__listeners[channel] = conn;
                     });
                 }
             });
3            return ret;
         },
 
         listenOnce: function (channel, cb, opts) {
2            var self = this;
2            var ret = new Promise(), called = false;
2            this.listen(channel, function (payload) {
                 //ensure we are not called twice
7                if (!called) {
2                    called = true;
2                    self.unListen(channel).chain(function () {
2                        ret.callback(payload);
2                        self = ret = null;
                     }).addErrback(ret);
                 }
             }, opts).addErrback(ret);
2            return ret.promise();
         },
 
         unListen: function (channel) {
4            var ret = new Promise().callback(), conn;
4            channel = this.__quoteSchemaTable(channel);
4            if (channel in this.__listeners && (conn = this.__listeners[channel])) {
2                var sql = this.__unListenSql(channel), self = this;
2                return this.__logAndExecute(sql, sql, function () {
2                    return conn.query(sql);
                 }).chain(function () {
2                    delete self.__listeners[channel];
2                    conn.connection.removeListener('notification', conn.__listeners[channel]);
2                    return self._returnConnection(conn);
                 });
             }
2            return ret.promise();
         },
 
         notify: function (channel, payload) {
7            return this.executeDdl(this.__notifySql(this.__quoteSchemaTable(channel), payload));
         },
 
         // Use the pg_* system tables to determine indexes on a table
         indexes: function (table, opts) {
0            opts = opts || {};
0            var m = this.outputIdentifierFunc;
0            var im = this.inputIdentifierFunc;
0            var parts = this.__schemaAndTable(table), schema = parts[0];
0            table = parts[1];
0            return this.serverVersion().chain(function (version) {
0                var attNums;
0                if (version >= 80100) {
0                    attNums = sql.ANY("ind__indkey");
                 } else {
0                    attNums = [];
0                    for (var i = 0; i < 32; i++) {
0                        attNums.push(new Subscript("ind__indkey", [i]));
                     }
                 }
0                var orderRange = [];
0                for (var j = 0; j < 32; j++) {
0                    orderRange.push(new Subscript("ind__indkey", [j]));
                 }
0                orderRange = sql["case"](orderRange, 32, "att__attnum");
0                var ds = this.metadataDataset.from("pg_class___tab")
                     .join("pg_index___ind", [
                         [identifier("indrelid"), identifier("oid")],
                         [im(table), "relname"]
                     ])
                     .join("pg_class___indc", [
                         [identifier("oid"), identifier("indexrelid")]
                     ])
                     .join("pg_attribute___att", [
                         [identifier("attrelid"), identifier("tab__oid")],
                         [identifier("attnum"), attNums]
                     ])
                     .filter({"indc__relkind": 'i', "ind__indisprimary": false, indexprs: null, indpred: null})
                     .order("indc__relname", orderRange)
                     .select("indc__relname___name", "ind__indisunique___unique", "att__attname___column");
 
0                if (schema) {
0                    ds = ds.join("pg_namespace___nsp", {oid: identifier("tab__relnamespace"), nspname: schema.toString()});
                 }
0                if (version >= 80200) {
0                    ds = ds.filter({indisvalid: true});
                 }
0                if (version >= 80300) {
0                    ds = ds.filter({indisready: true, indcheckxmin: false});
                 }
0                var indexes = {};
0                return ds.forEach(function (r) {
0                    var ident = m(r.name), i = indexes[ident];
0                    if (!i) {
0                        i = indexes[ident] = {columns: [], unique: r.unique};
                     }
0                    i.columns.push(r.column);
                 }).chain(function () {
0                    return indexes;
                 });
             });
         },
 
         locks: function () {
2            return this.dataset.from("pg_class").join("pg_locks", {relation: identifier("relfilenode")}).select("pg_class__relname", identifier("pg_locks").all());
         },
 
         // Get version of postgres server, used for determined capabilities.
         serverVersion: function () {
95            if (!this.__serverVersion) {
30                var self = this;
30                this.__serverVersion = this.get(identifier("version").sqlFunction).chain(function (version) {
30                    var m = version.match(/PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/);
30                    version = (parseInt(m[1], 10) * 10000) + (parseInt(m[2], 10) * 100) + parseInt(m[3], 10);
30                    self._serverVersion = version;
30                    return version;
                 });
             }
95            return this.__serverVersion.promise();
         },
 
         /**
          * Return an array of table names in the current database.
          * The dataset used is passed to the block if one is provided,
          * otherwise, an a promise resolved with an array of table names.
          *
          * Options:
          * @param {Object} [opts = {}] options
          * @param {String|patio.sql.Identifier} [opts.schema] The schema to search (default_schema by default)
          * @param {Function} [cb = null] an optional callback that is invoked with the dataset to retrieve tables.
          * @return {Promise} a promise resolved with the table names or the result of the cb if one is provided.
          */
         tables: function (opts, cb) {
0            return this.__pgClassRelname('r', opts, cb);
         },
 
         /**
          * Return an array of view names in the current database.
          *
          * Options:
          * @param {Object} [opts = {}] options
          * @param {String|patio.sql.Identifier} [opts.schema] The schema to search (default_schema by default)
          * @return {Promise} a promise resolved with the view names.
          */
         views: function (opts) {
0            return this.__pgClassRelname('v', opts);
         },
 
         primaryKey: function (table, opts) {
1113            var ret, quotedTable = this.__quoteSchemaTable(table).toString(), pks = this.__primaryKeys;
1113            if (pks.hasOwnProperty(quotedTable.toString())) {
1052                ret = pks[quotedTable];
             } else {
61                ret = (pks[quotedTable] = this.__primarykey(table));
             }
1113            return ret.promise();
         },
 
         createMaterializedView: function (name, query, opts) {
1            opts = opts || {};
1            opts.materialized = true;
1            return this.createView(name, query, opts);
         },
 
         dropMaterializedView: function (names, opts) {
1            var args = argsToArray(arguments);
1            if (isHash(args[args.length - 1])) {
0                opts = args.pop();
             } else {
1                opts = {};
             }
1            opts.materialized = true;
1            return this.dropView(args, opts);
         },
 
         refreshMaterializedView: function (names, opts) {
4            if (isArray(names)) {
2                var self = this, withNoData = opts.noData;
2                return asyncArray(names).forEach(function (name) {
2                    var sql = "REFRESH MATERIALIZED VIEW %s";
2                    withNoData && (sql += " WITH NO DATA");
2                    return self.executeDdl(format(sql, self.__quoteSchemaTable(name)));
                 }, null, 1);
             } else {
2                var args = argsToArray(arguments);
2                opts = isHash(args[args.length - 1]) ? args.pop() : {};
2                return this.refreshMaterializedView(args, opts);
             }
         },
 
         __primarykey: function (table) {
61            var parts = this.__schemaAndTable(table);
61            var m2 = this.inputIdentifierFunc;
61            var schema = parts[0];
61            table = parts[1];
61            var ds = this.from(table)
                 .select("pg_attribute__attname___name")
                 .from("pg_index", "pg_class", "pg_attribute", "pg_namespace")
                 .where([
                     [identifier("pg_class__oid"), identifier("pg_attribute__attrelid")],
                     [identifier("pg_class__relnamespace"), identifier("pg_namespace__oid")],
                     [identifier("pg_class__oid"), identifier("pg_index__indrelid")],
                     [identifier("pg_index__indkey").sqlSubscript(0), identifier("pg_attribute__attnum")],
                     [identifier("indisprimary"), true],
                     [identifier("pg_class__relname"), m2(table.toString())]
                 ]);
61            if (schema) {
0                ds.filter({"pg_namespace__nspname": m2(schema)});
             }
61            return ds.all();
 
         },
 
         _indKeySql: function (key, version) {
93            var ret = sql.identifier(key);
93            if (version < 90000) {
0                ret = sql.literal("string_to_array(textin(int2vectorout(?)), ' ')", ret);
             }
93            return ret;
         },
 
 
         schemaParseTable: function (tableName, opts) {
93            var self = this,
                 m = this.outputIdentifierFunc,
                 m2 = this.inputIdentifierFunc;
93            return this.serverVersion().chain(function (serverVersion) {
93                var ds = self.metadataDataset
                     .select(
                     "pg_attribute__attname___name",
                     sql["format_type"]("pg_type__oid", "pg_attribute__atttypmod").as("dbtype"),
                     sql["pg_get_expr"]("pg_attrdef__adbin", "pg_class__oid").as(literal('"default"')),
                     sql.NOT("pg_attribute__attnotnull").as("allownull"),
                     sql.COALESCE(BooleanExpression.fromValuePairs({"pg_attribute__attnum": sql.ANY(self._indKeySql("pg_index__indkey", serverVersion))}), false).as("primarykey"),
                     "pg_namespace__nspname"
                 ).from("pg_class")
                     .join("pg_attribute", {attrelid: identifier("oid")})
                     .join("pg_type", {oid: identifier("atttypid")})
                     .join("pg_namespace", {oid: identifier("pg_class__relnamespace")})
                     .leftOuterJoin("pg_attrdef", {adrelid: identifier("pg_class__oid"), adnum: identifier("pg_attribute__attnum")})
                     .leftOuterJoin("pg_index", {indrelid: identifier("pg_class__oid"), indisprimary: true})
                     .filter({"pg_attribute__attisdropped": false})
                     .filter({"pg_attribute__attnum": {gt: 0}})
                     .filter({"pg_class__relname": m2(tableName)})
                     .order("pg_attribute__attnum");
93                ds = self.__filterSchema(ds, opts);
93                var currentSchema = null;
93                return ds.map(function (row) {
768                    row.allowNull = row.allownull;
768                    delete row.allownull;
768                    row.primaryKey = row.primarykey;
768                    delete row.primarykey;
768                    row.dbType = row.dbtype;
768                    delete row.dbtype;
768                    var sch = row.nspname;
768                    delete row.nspname;
768                    if (currentSchema) {
675                        if (sch !== currentSchema) {
0                            var error = new Error("columns from two tables were returned please specify a schema");
0                            self.logError(error);
                         }
                     } else {
93                        currentSchema = sch;
                     }
768                    if (isBlank(row["default"])) {
679                        row["default"] = null;
                     }
768                    row.type = self.schemaColumnType(row.dbType);
768                    var fieldName = m(row.name);
768                    delete row.name;
768                    return [fieldName, row];
                 });
             });
 
         },
 
         __commitTransaction: function (conn, opts) {
744            opts = opts || {};
744            var s = opts.prepare;
744            if (s && this.__transactionDepth <= 1) {
0                return this.__logConnectionExecute(conn, ["PREPARE TRANSACTION ", this.literal(s)].join(""));
             } else {
744                return this._super(arguments);
             }
         },
 
         //Backbone of the tables and views support.
         __pgClassRelname: function (type, opts, cb) {
0            var ret;
0            var ds = this.metadataDataset.from("pg_class")
                 .filter({relkind: type}).select("relname")
                 .exclude({relname: {like: this.SYSTEM_TABLE_REGEXP}})
                 .join("pg_namespace", {oid: identifier("relnamespace")});
0            ds = this.__filterSchema(ds, opts);
0            var m = this.outputIdentifierFunc;
0            if (cb) {
0                ret = when(cb(ds));
             } else {
0                ret = ds.map(function (r) {
0                    return m(r.relname);
                 });
             }
0            return ret.promise();
         },
 
         //If opts includes a :schema option, or a default schema is used, restrict the dataset to
         // that schema.  Otherwise, just exclude the default PostgreSQL schemas except for public.
         __filterSchema: function (ds, opts) {
93            opts = opts || {};
93            var schema = opts.schema, ret = ds;
93            if (schema) {
0                ds = ds.filter({"pg_namespace__nspname": schema});
             } else {
93                ds = ds.exclude({"pg_namespace__nspname": this.EXCLUDE_SCHEMAS});
             }
93            return ds;
         },
 
         __notifySql: function (channel, payload) {
7            return format("NOTIFY %s %s", channel, payload ? ", " + this.literal(JSON.stringify(payload)) : "");
         },
 
         __listenSql: function (channel) {
3            return format("LISTEN %s", channel);
         },
 
         __unListenSql: function (channel) {
2            return format("UNLISTEN %s", channel);
         },
 
         __dropViewSql: function (name, opts) {
1            var sql = "DROP";
1            if (opts.materialized) {
1                sql += " MATERIALIZED";
             }
1            sql += " VIEW";
1            if (opts.ifExists) {
0                sql += " IF EXISTS";
             }
1            sql += " %s";
1            if (opts.cascade) {
0                sql += " CASCADE";
             }
1            return format(sql, this.__quoteSchemaTable(name));
         },
 
         __createViewSql: function (name, source, opts) {
1            var sql = "CREATE";
1            opts = opts || {};
1            if (opts.replace) {
0                sql += " OR REPLACE";
             }
1            if (opts.materialized) {
1                sql += " MATERIALIZED";
0            } else if (opts.recursize) {
0                sql += " RECURSIVE";
0            } else if (opts.temporary || opts.temp) {
0                sql += " TEMPORARY";
             }
1            sql += " VIEW %s AS %s";
1            return format(sql, this.__quoteSchemaTable(name), source);
         },
 
         __indexDefinitionSql: function (tableName, index) {
9            tableName = stringToIdentifier(tableName);
9            var cols = index.columns.map(function (col) {
10                    return stringToIdentifier(col);
                 }),
                 indexName = index.name || this.__defaultIndexName(tableName, cols),
                 o = index.opclass,
                 indexType = index.type,
                 unique = index.unique ? "UNIQUE" : "",
                 filter = index.where || index.filter,
                 expr;
9            filter = filter ? ["WHERE ", this.__filterExpr(filter)].join("") : "";
9            if (isDefined(o)) {
1                expr = ["(", cols.map(function (c) {
1                    return [this.literal(c), o].join(" ");
                 }, this).join(", "), ")"].join("");
             } else {
8                expr = this.literal(toArray(cols));
             }
9            switch (indexType) {
             case "fullText":
2                expr = ["(to_tsvector(", this.literal(index.language || "simple"), ", ", this.literal(this.dataset.__fullTextStringJoin(cols)), "))"].join("");
2                indexType = "gin";
2                break;
             case "spatial" :
1                indexType = "gist";
1                break;
             }
9            return ["CREATE", unique, "INDEX", this.__quoteIdentifier(indexName), "ON", this.__quoteSchemaTable(tableName), indexType ? "USING " + indexType : "", expr, filter].join(" ");
 
         },
         /*
          todo might need this?
          __insertResult:function (conn, table, values) {
          },
          */
 
         __renameTableSql: function (name, newName) {
1            return ["ALTER TABLE ", this.__quoteSchemaTable(name), " RENAME TO ", this.__quoteIdentifier(this.__schemaAndTable(newName).pop())].join("");
         },
 
         __schemaAutoincrementingPrimaryKey: function (schema) {
0            return this._super(arguments) && schema.dbType.match(/^(?:integer|bigint)$/i) && schema["default"].match(/^nextval/i);
         },
 
         __typeLiteralGenericNumeric: function (column) {
2            return column.size ? format("numeric(%s)", array.toArray(column.size).join(', ')) : column.isInt ? "integer" : column.isDouble ? "double precision" : "numeric";
         },
 
         __typeLiteralGenericDateTime: function (column) {
6            return "timestamp";
         },
 
         //handle bigserial
         __typeLiteralGenericBigint: function (column) {
1            return column.serial ? "bigserial" : this.__typeLiteralSpecific(column);
         },
 
         __typeLiteralGenericBlob: function (column) {
8            return "bytea";
         },
 
         //handle serial type
         __typeLiteralGenericInteger: function (column) {
124            return column.serial ? "serial" : this.__typeLiteralSpecific(column);
         },
 
         // PostgreSQL prefers the text datatype.  If a fixed size is requested,
         // the char type is used.  If the text type is specifically
         // disallowed or there is a size specified, use the varchar type.
         // Otherwise use the type type.
         __typeLiteralGenericString: function (column) {
143            if (column.fixed) {
0                return ["char(", column.size || 255, ")"].join("");
143            } else if (column.text === false || column.size) {
119                return ["varchar(", column.size || 255, ")"].join("");
             } else {
24                return 'text';
             }
 
         },
 
 
         getters: {
 
             connectionExecuteMethod: function () {
1488                return "query";
             },
 
             dataset: function () {
804                return new DS(this);
             },
 
             serialPrimaryKeyOptions: function () {
62                return {primaryKey: true, serial: true, type: "integer"};
             },
 
             supportsSavepoints: function () {
8497                return true;
             },
 
             supportsTransactionIsolationLevels: function () {
744                return true;
             },
 
             identifierInputMethodDefault: function () {
0                return null;
             },
 
             identifierOutputMethodDefault: function () {
0                return null;
             }
         }
     },
 
     "static": {
 
         init: function () {
1            this.setAdapterType("pg");
         }
 
     }
 }).as(exports, "PostgresDatabase");

1var mysql = require("mysql"),
     comb = require("comb"),
     hitch = comb.hitch,
     asyncArray = comb.async.array,
     define = comb.define,
     merge = comb.merge,
     string = comb.string,
     argsToArray = comb.argsToArray,
     format = string.format,
     Promise = comb.Promise,
     isString = comb.isString,
     array = comb.array,
     toArray = array.toArray,
     isArray = comb.isArray,
     isHash = comb.isHash,
     when = comb.when,
     isInstanceOf = comb.isInstanceOf,
     isFunction = comb.isFunction,
     isUndefinedOrNull = comb.isUndefinedOrNull,
     isUndefined = comb.isUndefined,
     isEmpty = comb.isEmpty,
     QueryError = require("../errors").QueryError,
     Dataset = require("../dataset"),
     Database = require("../database"),
     sql = require("../sql").sql,
     DateTime = sql.DateTime,
     Time = sql.Time,
     Year = sql.Year,
     Double = sql.Double,
     stream = require("stream"),
     PassThroughStream = stream.PassThrough,
     pipeAll = require("../utils").pipeAll,
     patio, DB;
 
1var convertDate = function (v, m, convertDateTime) {
15    v = ("" + v);
15    try {
15        return patio[m](v);
     } catch (e) {
15        if (convertDateTime === null) {
3            return null;
12        } else if (convertDateTime === String || (isString(convertDateTime) && convertDateTime.match(/string/i))) {
9            return v;
         } else {
3            throw e;
         }
     }
 };
 
1var Connection = define(null, {
     instance: {
 
         connection: null,
 
         errored: false,
 
         closed: false,
 
 
         constructor: function (conn) {
4            this.connection = conn;
         },
 
         closeConnection: function () {
3            var ret = new Promise();
3            this.closed = true;
3            this.connection.end(hitch(ret, ret.resolve));
3            return ret.promise();
         },
 
 
         stream: function (query) {
2            var ret;
2            if (!this.closed) {
2                try {
2                    ret = this.connection.query(query).stream();
                 } catch (e) {
0                    patio.logError(e);
                 }
             } else {
0                ret = new PassThroughStream();
0                setImmediate(function () {
0                    ret.emit("error", new Error("Connection already closed"));
                 });
             }
2            return ret;
         },
 
 
         query: function (query) {
295            var ret = new Promise();
295            if (!this.closed) {
295                try {
295                    this.connection.setMaxListeners(0);
295                    this.connection.query(query, hitch(ret, ret.resolve));
                 } catch (e) {
0                    patio.logError(e);
0                    ret.errback(e);
                 }
             } else {
0                ret.errback(new Error("Connection already closed"));
             }
295            return ret.promise();
         }
     }
 });
 
1var DS = define(Dataset, {
 
     instance: {
 
         __providesAccurateRowsMatched: false,
 
         __supportsDistinctOn: true,
 
         __supportsIntersectExcept: false,
 
         __supportsModifyingJoins: true,
 
         __supportsTimestampUsecs: false,
 
 
         // MySQL specific syntax for LIKE/REGEXP searches, as well as
         // string concatenation.
         complexExpressionSql: function (op, args) {
24            var likeOps = ["~", "~*", "LIKE", "ILIKE"];
24            var notLikeOps = ["!~", "!~*", "NOT LIKE", "NOT ILIKE"];
24            var regExpOps = ["~", "!~", "~*", "!~*"];
24            var binaryOps = ["~", "!~", "LIKE", "NOT LIKE"];
24            if (likeOps.indexOf(op) !== -1 || notLikeOps.indexOf(op) !== -1) {
10                return format("(%s%s %s%s %s)", this.literal(args[0]), notLikeOps.indexOf(op) !== -1 ? " NOT" : "",
                     regExpOps.indexOf(op) !== -1 ? "REGEXP" : "LIKE", binaryOps.indexOf(op) !== -1 ? " BINARY" : "",
                     this.literal(args[1]));
14            } else if (op === "||") {
5                if (args.length > 1) {
3                    return format("CONCAT(%s)", args.map(this.literal, this).join(", "));
                 } else {
2                    return this.literal(args[0]);
                 }
9            } else if (op === "B~") {
0                return format("CAST(~%s AS SIGNED INTEGER)", this.literal(args[0]));
             } else {
9                return this._super(arguments);
             }
         },
 
         // Use GROUP BY instead of DISTINCT ON if arguments are provided.
         distinct: function (args) {
2            args = argsToArray(arguments);
2            return !args.length ? this._super(arguments) : this.group.apply(this, args);
         },
 
         //Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
         forShare: function () {
1            return this.lockStyle("share");
         },
 
         //Adds full text filter
         fullTextSearch: function (cols, terms, opts) {
3            opts = opts || {};
3            cols = toArray(cols).map(this.stringToIdentifier, this);
3            return this.filter(sql.literal(this.fullTextSql(cols, terms, opts)));
         },
 
         //MySQL specific full text search syntax.
         fullTextSql: function (cols, term, opts) {
3            opts = opts || {};
3            return format("MATCH %s AGAINST (%s%s)", this.literal(toArray(cols)),
                 this.literal(toArray(term).join(" ")), opts.boolean ? " IN BOOLEAN MODE" : "");
         },
 
         //MySQL allows HAVING clause on ungrouped datasets.
         having: function (cond, cb) {
3            var args = argsToArray(arguments);
3            return this._filter.apply(this, ["having"].concat(args));
         },
 
         // Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
         //Raises an error on use of :full_outer type, since MySQL doesn't support it.
         joinTable: function (type, table, expr, tableAlias) {
12            tableAlias = tableAlias || {};
12            if (type === "cross" && !isUndefinedOrNull(expr)) {
1                type = "inner";
             }
12            if (type === "fullOuter") {
1                throw new QueryError("MySQL does not support FULL OUTER JOIN");
             }
11            return this._super(arguments, [type, table, expr, tableAlias]);
         },
 
         // Transforms :natural_inner to NATURAL LEFT JOIN and straight to
         //STRAIGHT_JOIN.
         _joinTypeSql: function (joinType) {
11            if (joinType === "straight") {
2                return "STRAIGHT_JOIN";
9            } else if (joinType === "naturalInner") {
1                return "NATURAL LEFT JOIN";
             } else {
8                return this._super(arguments);
             }
         },
 
         insertIgnore: function () {
2            return this.mergeOptions({insertIgnore: true});
         },
 
 
         onDuplicateKeyUpdate: function (args) {
3            args = argsToArray(arguments).map(function (c) {
5                return isString(c) ? this.stringToIdentifier(c) : c;
             }, this);
3            return this.mergeOptions({onDuplicateKeyUpdate: args});
         },
 
         // MySQL specific syntax for inserting multiple values at once.
         multiInsertSql: function (columns, values) {
8            return [this.insertSql(columns, sql.literal('VALUES ' + values.map(
                 function (r) {
16                    return this.literal(toArray(r));
                 }, this).join(this._static.COMMA_SEPARATOR)))];
         },
 
         //MySQL uses the nonstandard ` (backtick) for quoting identifiers.
         _quotedIdentifier: function (c) {
51            return format("`%s`", c);
         },
 
         // MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
         //insert if it doesn't).
         replaceSql: function (values) {
9            var ds = this.mergeOptions({replace: true});
9            return ds.insertSql.apply(ds, argsToArray(arguments));
         },
 
         //If this is an replace instead of an insert, use replace instead
         _insertSql: function () {
55            return this.__opts.replace ? this._clauseSql("replace") : this._super(arguments);
         },
 
         //Consider the first table in the joined dataset is the table to delete
         //from, but include the others for the purposes of selecting rows.
         _deleteFromSql: function (sql) {
12            if (this._joinedDataset) {
0                return format(" %s FROM %s%s", this._sourceList(this.__opts.from[0]), this._sourceList(this.__opts.from), this._selectJoinSql());
             } else {
12                return this._super(arguments);
             }
         },
 
         //alias replace_clause_methods insert_clause_methods
         //MySQL doesn't use the standard DEFAULT VALUES for empty values.
         _insertColumnsSql: function (sql) {
55            var values = this.__opts.values;
55            if (isArray(values) && !values.length) {
9                return " ()";
             } else {
46                return this._super(arguments);
             }
         },
 
         //MySQL supports INSERT IGNORE INTO
         _insertIgnoreSql: function (sql) {
55            return this.__opts.insertIgnore ? " IGNORE" : "";
         },
 
         //MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
         _insertOnDuplicateKeyUpdateSql: function (sql) {
55            return this.__opts.onDuplicateKeyUpdate ? this.onDuplicateKeyUpdateSql() : "";
         },
 
         //MySQL doesn't use the standard DEFAULT VALUES for empty values.
         _insertValuesSql: function (sql) {
55            var values = this.__opts.values;
55            if (isArray(values) && !values.length) {
9                return " VALUES ()";
             } else {
46                return this._super(arguments);
             }
         },
 
         //MySQL allows a LIMIT in DELETE and UPDATE statements.
         limitSql: function (sql) {
14            return this.__opts.limit ? format(" LIMIT %s", this.__opts.limit) : "";
         },
 
         _deleteLimitSql: function () {
12            return this.limitSql.apply(this, arguments);
         },
 
         _updateLimitSql: function () {
2            return this.limitSql.apply(this, arguments);
         },
 
 
         //MySQL specific syntax for ON DUPLICATE KEY UPDATE
         onDuplicateKeyUpdateSql: function () {
3            var ret = "";
3            var updateCols = this.__opts.onDuplicateKeyUpdate;
3            if (updateCols) {
3                var updateVals = null, l, last;
3                if ((l = updateCols.length) > 0 && isHash((last = updateCols[l - 1]))) {
2                    updateVals = last;
2                    updateCols = l === 2 ? [updateCols[0]] : updateCols.slice(0, l - 2);
                 }
3                var updating = updateCols.map(function (c) {
3                    var quoted = this.quoteIdentifier(c);
3                    return format("%s=VALUES(%s)", quoted, quoted);
                 }, this);
3                for (var i in updateVals) {
2                    if (i in updateVals) {
2                        updating.push(format("%s=%s", this.quoteIdentifier(i), this.literal(updateVals[i])));
                     }
                 }
3                if (updating || updateVals) {
3                    ret =
                         format(" ON DUPLICATE KEY UPDATE %s", updating.join(this._static.COMMA_SEPARATOR));
                 }
             }
3            return ret;
         },
 
         //Support FOR SHARE locking when using the :share lock style.
         _selectLockSql: function (sql) {
88            return this.__opts.lock === "share" ? this._static.FOR_SHARE : this._super(arguments);
         },
 
         // Delete rows matching this dataset
         remove: function () {
12            return this.executeDui(this.deleteSql).chain(function (c, info) {
12                return c.affectedRows;
             });
         },
 
         __processFields: function (fields) {
88            var cols = [], i = -1, l = fields.length, col, fieldName, type, length, colIdentifier,
                 outputIdentifier = this.outputIdentifier,
                 selfCols = ( this.__columns = []);
88            while (++i < l) {
308                col = fields[i];
308                fieldName = col.name;
308                type = col.type;
308                length = col.fieldLength;
308                colIdentifier = outputIdentifier(fieldName);
308                selfCols[i] = colIdentifier;
308                cols[i] = [colIdentifier, DB.convertMysqlType(type === 1 && length !== 1 ? 2 : type), fieldName];
             }
88            return cols;
         },
 
         //Don't allow graphing a dataset that splits multiple statements
         graph: function () {
0            if (this.__opts.splitMultipleResultSels) {
0                throw new QueryError("Can't graph a dataset that splits multiple result sets");
             }
0            this._super(arguments);
         },
 
         //Insert a new value into this dataset
         insert: function () {
36            return this.executeDui(this.insertSql.apply(this, arguments)).chain(function (c, info) {
36                return c.insertId;
             });
         },
 
         // Replace (update or insert) the matching row.
         replace: function () {
9            return this.executeDui(this.replaceSql.apply(this, arguments)).chain(function (c, info) {
9                return c.insertId;
             });
         },
 
         splitMultipleResultSets: function () {
0            if (this.__opts.graph) {
0                throw new QueryError("Can't split multiple statements on a graphed dataset");
             }
0            var ds = this.mergeOptions({splitMultipleResultSets: true});
0            var rowCb = this.rowCb;
0            if (rowCb) {
0                ds.rowCb = function (x) {
0                    return x.map(rowCb, this);
                 };
             }
0            return ds;
         },
 
         //Update the matching rows.
         update: function () {
0            return this.executeDui(this.updateSql.apply(this, arguments)).chain(function (c, info) {
0                return c.affectedRows;
             });
         },
 
         //Set the :type option to select if it hasn't been set.
         execute: function (sql, opts) {
89            opts = opts || {};
89            return this._super([sql, merge({type: "select"}, opts)]);
         },
 
         //Set the :type option to :select if it hasn't been set.
         executeDui: function (sql, opts) {
65            opts = opts || {};
65            return this._super([sql, merge({type: "dui"}, opts)]);
         },
 
         _literalString: function (v) {
64            return "'" + v.replace(/[\0\n\r\t\\\'\"\x1a]/g, function (s) {
1                    switch (s) {
                     case "0":
0                        return "\\0";
                     case "\n":
0                        return "\\n";
                     case "\r":
0                        return "\\r";
                     case "\b":
0                        return "\\b";
                     case "\t":
0                        return "\\t";
                     case "\x1a":
0                        return "\\Z";
                     default:
1                        return "\\" + s;
                     }
                 }) + "'";
         }
     },
 
     "static": {
         BOOL_TRUE: '1',
         BOOL_FALSE: '0',
         COMMA_SEPARATOR: ', ',
         FOR_SHARE: ' LOCK IN SHARE MODE',
         DELETE_CLAUSE_METHODS: Dataset.clauseMethods("delete", "qualify from where order limit"),
         INSERT_CLAUSE_METHODS: Dataset.clauseMethods("insert", "ignore into columns values onDuplicateKeyUpdate"),
         REPLACE_CLAUSE_METHODS: Dataset.clauseMethods("insert", "ignore into columns values onDuplicateKeyUpdate"),
         SELECT_CLAUSE_METHODS: Dataset.clauseMethods("select", "qualify distinct columns from join where group having compounds order limit lock"),
         UPDATE_CLAUSE_METHODS: Dataset.clauseMethods("update", "table set where order limit")
     }
 
 });
 
1DB = define(Database, {
     instance: {
 
         PRIMARY: 'PRIMARY',
 
         type: "mysql",
 
         __supportsSavePoints: true,
 
         __supportsTransactionIsolationLevels: true,
 
         createConnection: function (opts) {
4            delete opts.query;
4            var self = this, ret;
4            var conn = mysql.createConnection(merge({}, opts, {typeCast: false}));
4            conn.on("error", function (err) {
0                self.logWarn("Connection from " + self.uri + " errored removing from pool and reconnecting");
0                self.logWarn(err.stack);
0                ret.errored = true;
0                self.pool.removeConnection(ret);
             });
4            conn.connect();
4            ret = new Connection(conn);
4            return ret;
         },
 
         closeConnection: function (conn) {
3            return conn.closeConnection();
         },
 
         validate: function (conn) {
279            return new Promise().callback(!(conn.errored)).promise();
         },
 
         // MySQL's cast rules are restrictive in that you can't just cast to any possible
         // database type.
         castTypeLiteral: function (type) {
0            var ret = null, meth;
0            if (isString(type)) {
0                ret = this._static.CAST_TYPES[type] || this._super(arguments);
0            } else if (type === String) {
0                meth += "CHAR";
0            } else if (type === Number) {
0                meth += "DECIMAL";
0            } else if (type === DateTime) {
0                meth += "DATETIME";
0            } else if (type === Year) {
0                meth += "Year";
0            } else if (type === Time) {
0                meth += "DATETIME";
0            } else if (type === Double) {
0                meth += "DECIMAL";
             } else {
0                ret = this._super(arguments);
             }
0            return ret;
         },
 
         // Use SHOW INDEX FROM to get the index information for the table.
         indexes: function (table, opts) {
3            var indexes = {};
3            var removeIndexes = [];
3            var m = this.outputIdentifierFunc;
3            var im = this.inputIdentifierFunc;
3            return this.metadataDataset.withSql("SHOW INDEX FROM ?", isInstanceOf(table, sql.Identifier) ? table : sql.identifier(im(table)))
                 .forEach(function (r) {
2                    var name = r[m("Key_name")];
2                    if (name !== "PRIMARY") {
2                        name = m(name);
2                        if (r[m("Sub_part")]) {
1                            removeIndexes.push(name);
                         }
2                        var i = indexes[name] || (indexes[name] = {columns: [], unique: r[m("Non_unique")] !== 1});
2                        i.columns.push(m(r[m("Column_name")]));
                     }
                 }).chain(function () {
3                    var r = {};
3                    for (var i in indexes) {
2                        if (removeIndexes.indexOf(i) === -1) {
1                            r[i] = indexes[i];
                         }
                     }
3                    return r;
                 });
 
         },
 
         // Get version of MySQL server, used for determined capabilities.
         serverVersion: function () {
1            var ret;
1            if (!this.__serverVersion) {
1                var self = this;
1                ret = this.get(sql.version().sqlFunction).chain(function (version) {
1                    var m = version.match(/(\d+)\.(\d+)\.(\d+)/);
1                    return (self._serverVersion = (parseInt(m[1], 10) * 10000) + (parseInt(m[2], 10) * 100) + parseInt(m[3], 10));
                 });
             } else {
0                ret = new Promise().callback(this._serverVersion);
             }
1            return ret.promise();
         },
 
         //Return an array of strings specifying table names in the current database.
         tables: function (opts) {
0            var m = this.outputIdentifierFunc;
0            return this.metadataDataset.withSql('SHOW TABLES').map(function (r) {
0                return m(r[Object.keys(r)[0]]);
             });
         },
 
 
         use: function (dbName) {
0            var self = this;
0            return this.disconnect().chain(function () {
0                return self.run("USE " + dbName).chain(function () {
0                    self.opts.database = dbName;
0                    self.schemas = {};
0                    return self;
                 });
             });
         },
 
         //Use MySQL specific syntax for rename column, set column type, and
         // drop index cases.
         __alterTableSql: function (table, op) {
21            var ret = new Promise(), self = this;
21            if (op.op === "addColumn") {
7                var related = op.table;
7                if (related) {
2                    delete op.table;
2                    ret = this._super(arguments).chain(function (sql) {
2                        op.table = related;
2                        return [sql, format("ALTER TABLE %s ADD FOREIGN KEY (%s)%s",
                             self.__quoteSchemaTable(table), self.__quoteIdentifier(op.name),
                             self.__columnReferencesSql(op))];
                     });
                 } else {
5                    ret = this._super(arguments);
                 }
14            } else if (['renameColumn', "setColumnType", "setColumnNull", "setColumnDefault"].indexOf(op.op) !== -1) {
11                ret = this.schema(table).chain(function (schema) {
11                    var name = op.name;
11                    var opts = schema[Object.keys(schema).filter(function (i) {
28                        return i === name;
                     })[0]];
11                    opts = merge({}, opts || {});
11                    opts.name = op.newName || name;
11                    opts.type = op.type || opts.dbType;
11                    opts.allowNull = isUndefined(op["null"]) ? opts.allowNull : op["null"];
11                    opts["default"] = op["default"] || opts.jsDefault;
11                    if (isUndefinedOrNull(opts["default"])) {
5                        delete opts["default"];
                     }
11                    return format("ALTER TABLE %s CHANGE COLUMN %s %s", self.__quoteSchemaTable(table),
                         self.__quoteIdentifier(op.name), self.__columnDefinitionSql(merge(op, opts)));
                 });
3            } else if (op.op === "dropIndex") {
0                ret = when(format("%s ON %s", this.__dropIndexSql(table, op), this.__quoteSchemaTable(table)));
             } else {
3                ret = this._super(arguments);
             }
21            return ret.promise();
         },
 
         //MySQL needs to set transaction isolation before beginning a transaction
         __beginNewTransaction: function (conn, opts) {
9            var self = this;
9            return this.__setTransactionIsolation(conn, opts).chain(function () {
9                return self.__logConnectionExecute(conn, self.beginTransactionSql);
             });
         },
 
         // Use XA START to start a new prepared transaction if the :prepare
         //option is given.
         __beginTransaction: function (conn, opts) {
9            opts = opts || {};
9            var s;
9            if ((s = opts.prepare)) {
0                return this.__logConnectionExecute(conn, comb("XA START %s").format(this.literal(s)));
             } else {
9                return this._super(arguments);
             }
         },
 
         // MySQL doesn't allow default values on text columns, so ignore if it the
         // generic text type is used
         __columnDefinitionSql: function (column) {
132            if (isString(column.type) && column.type.match(/string/i) && column.text) {
1                delete column["default"];
             }
132            return this._super(arguments, [column]);
         },
 
         // Prepare the XA transaction for a two-phase commit if the
         // prepare option is given.
         __commitTransaction: function (conn, opts) {
9            opts = opts || {};
9            var s = opts.prepare, self = this;
9            if (s) {
0                return this.__logConnectionExecute(conn, comb("XA END %s").format(this.literal(s))).chain(function () {
0                    return self.__logConnectionExecute(comb("XA PREPARE %s").format(self.literal(s)));
                 });
             } else {
9                return this._super(arguments);
             }
         },
 
         //Use MySQL specific syntax for engine type and character encoding
         __createTableSql: function (name, generator, options) {
45            options = options || {};
45            var engine = options.engine, charset = options.charset, collate = options.collate;
45            if (isUndefined(engine)) {
37                engine = this._static.defaultEngine;
             }
45            if (isUndefined(charset)) {
40                charset = this._static.defaultCharset;
             }
45            if (isUndefined(collate)) {
43                collate = this._static.defaultCollate;
             }
45            generator.columns.forEach(function (c) {
114                var t = c.table;
114                if (t) {
2                    delete c.table;
2                    generator.foreignKey([c.name], t, merge({}, c, {name: null, type: "foreignKey"}));
                 }
             });
45            return format(" %s%s%s%s", this._super(arguments), engine ? " ENGINE=" + engine : "",
                 charset ? " DEFAULT CHARSET=" + charset : "", collate ? " DEFAULT COLLATE=" + collate : "");
         },
 
         //Handle MySQL specific index SQL syntax
         __indexDefinitionSql: function (tableName, index) {
7            var indexName = this.__quoteIdentifier(index.name || this.__defaultIndexName(tableName,
                 index.columns)), t = index.type, using = "";
7            var indexType = "";
7            if (t === "fullText") {
2                indexType = "FULLTEXT ";
5            } else if (t === "spatial") {
1                indexType = "SPATIAL ";
             } else {
4                indexType = index.unique ? "UNIQUE " : "";
4                using = t ? " USING " + t : "";
             }
7            return format("CREATE %sINDEX %s%s ON %s %s", indexType, indexName, using,
                 this.__quoteSchemaTable(tableName), this.literal(index.columns.map(function (c) {
8                    return isString(c) ? sql.identifier(c) : c;
                 })));
         },
 
         // Rollback the currently open XA transaction
         __rollbackTransaction: function (conn, opts) {
0            opts = opts || {};
0            var s = opts.prepare;
0            var logConnectionExecute = comb("__logConnectionExecute");
0            if (s) {
0                s = this.literal(s);
0                var self = this;
0                return this.__logConnectionExecute(conn, "XA END " + s)
                     .chain(function () {
0                        return self.__logConnectionExecute(conn, "XA PREPARE " + s);
                     })
                     .chain(function () {
0                        return self.__logConnectionExecute(conn, "XA ROLLBACK " + s);
                     });
             } else {
0                return this._super(arguments);
             }
         },
 
         // MySQL treats integer primary keys as autoincrementing.
         _schemaAutoincrementingPrimaryKey: function (schema) {
0            return this._super(arguments) && schema.dbType.match(/int/i);
         },
 
         //Use the MySQL specific DESCRIBE syntax to get a table description.
         schemaParseTable: function (tableName, opts) {
15            var m = this.outputIdentifierFunc, im = this.inputIdentifierFunc, self = this;
15            return this.metadataDataset.withSql("DESCRIBE ?", sql.identifier(im(tableName))).map(function (row) {
39                var ret = {};
39                var e = row[m("Extra")];
39                var allowNull = row[m("Null")];
39                var key = row[m("Key")];
39                ret.autoIncrement = e.match(/auto_increment/i) !== null;
39                ret.allowNull = allowNull.match(/Yes/i) !== null;
39                ret.primaryKey = key.match(/PRI/i) !== null;
39                var defaultValue = row[m("Default")];
39                ret["default"] = Buffer.isBuffer(defaultValue) ? defaultValue.toString() : defaultValue;
39                if (isEmpty(row["default"])) {
39                    row["default"] = null;
                 }
39                ret.dbType = row[m("Type")];
39                if (Buffer.isBuffer(ret.dbType)) {
                     //handle case for field type being returned at 252  (i.e. BLOB)
39                    ret.dbType = ret.dbType.toString();
                 }
39                ret.type = self.schemaColumnType(ret.dbType.toString("utf8"));
39                var fieldName = m(row[m("Field")]);
39                return [fieldName, ret];
             });
         },
 
         //Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
         schemaColumnType: function (dbType) {
39            return this._static.convertTinyintToBool && dbType === 'tinyint(1)' ? "boolean" : this._super(arguments);
         },
 
 
         //MySQL doesn't have a true boolean class, so it uses tinyint(1)
         __typeLiteralGenericBoolean: function (column) {
2            return 'tinyint(1)';
         },
 
         getters: {
 
             identifierInputMethodDefault: function () {
1                return null;
             },
 
             identifierOutputMethodDefault: function () {
1                return null;
             },
 
             connectionExecuteMethod: function () {
18                return "query";
             },
 
             dataset: function () {
141                return new DS(this);
             }
         }
     },
 
     "static": {
         __convertTinyintToBool: true,
 
         __convertInvalidDateTime: false,
 
         CAST_TYPES: {string: "CHAR", integer: "SIGNED", time: "DATETIME", datetime: "DATETIME", numeric: "DECIMAL"},
 
         AUTOINCREMENT: 'AUTO_INCREMENT',
 
         init: function () {
1            this.setAdapterType("mysql");
         },
 
         FIELD_TYPES: {
             FIELD_TYPE_DECIMAL: 0x00,
             FIELD_TYPE_TINY: 0x01,
             FIELD_TYPE_SHORT: 0x02,
             FIELD_TYPE_LONG: 0x03,
             FIELD_TYPE_FLOAT: 0x04,
             FIELD_TYPE_DOUBLE: 0x05,
             FIELD_TYPE_NULL: 0x06,
             FIELD_TYPE_TIMESTAMP: 0x07,
             FIELD_TYPE_LONGLONG: 0x08,
             FIELD_TYPE_INT24: 0x09,
             FIELD_TYPE_DATE: 0x0a,
             FIELD_TYPE_TIME: 0x0b,
             FIELD_TYPE_DATETIME: 0x0c,
             FIELD_TYPE_YEAR: 0x0d,
             FIELD_TYPE_NEWDATE: 0x0e,
             FIELD_TYPE_VARCHAR: 0x0f,
             FIELD_TYPE_BIT: 0x10,
             FIELD_TYPE_NEWDECIMAL: 0xf6,
             FIELD_TYPE_ENUM: 0xf7,
             FIELD_TYPE_SET: 0xf8,
             FIELD_TYPE_TINY_BLOB: 0xf9,
             FIELD_TYPE_MEDIUM_BLOB: 0xfa,
             FIELD_TYPE_LONG_BLOB: 0xfb,
             FIELD_TYPE_BLOB: 0xfc,
             FIELD_TYPE_VAR_STRING: 0xfd,
             FIELD_TYPE_STRING: 0xfe,
             FIELD_TYPE_GEOMETRY: 0xff
 
         },
 
         convertMysqlType: function (type) {
308            var convert = this.convertTinyintToBool, convertDateTime = this.__convertInvalidDateTime, types = this.FIELD_TYPES;
308            if (!patio) {
1                patio = require("../index");
             }
308            return function (o) {
476                var ret = o;
476                if (o !== null) {
353                    switch (type) {
                     case types.FIELD_TYPE_TIMESTAMP:
                     case types.FIELD_TYPE_DATETIME:
5                        ret = convertDate(o, "stringToDateTime", convertDateTime);
4                        break;
                     case types.FIELD_TYPE_DATE:
                     case types.FIELD_TYPE_NEWDATE:
5                        ret = convertDate(o, "stringToDate", convertDateTime);
4                        break;
                     case types.FIELD_TYPE_TIME:
5                        ret = convertDate(o, "stringToTime", convertDateTime);
4                        break;
                     case types.FIELD_TYPE_TINY:
0                        ret = convert ? parseInt(o, 10) === 1 : parseInt(o, 10);
0                        break;
                     case types.FIELD_TYPE_YEAR:
0                        ret = convertDate(o, "stringToYear", convertDateTime);
0                        break;
                     case types.FIELD_TYPE_SHORT:
                     case types.FIELD_TYPE_LONG:
                     case types.FIELD_TYPE_LONGLONG:
                     case types.FIELD_TYPE_INT24:
71                        ret = parseInt(o, 10);
71                        break;
                     case types.FIELD_TYPE_FLOAT:
                     case types.FIELD_TYPE_DOUBLE:
                     case types.FIELD_TYPE_DECIMAL:
                         // decimal types cannot be parsed as floats because
                         // V8 Numbers have less precision than some MySQL Decimals
1                        ret = parseFloat(o);
1                        break;
                     case types.FIELD_TYPE_TINY_BLOB:
                     case types.FIELD_TYPE_MEDIUM_BLOB:
                     case types.FIELD_TYPE_LONG_BLOB:
                     case types.FIELD_TYPE_BLOB:
68                        ret = new Buffer(o);
68                        break;
                     }
                 }
473                return ret;
             };
         },
 
         getters: {
             convertTinyintToBool: function () {
347                return this.__convertTinyintToBool;
             },
 
             convertInvalidDateTime: function () {
0                return this.__convertInvalidDateTime;
             }
 
         },
 
         setters: {
             convertTinyintToBool: function (convert) {
0                this.__convertTinyintToBool = convert;
             },
 
             convertInvalidDateTime: function (convert) {
8                this.__convertInvalidDateTime = convert;
             }
 
         }
     }
 }).as(exports, "MySQLDatabase");

 /**
  * @projectName patio
  * @github https://github.com/C2FO/patio
  * @includeDoc [Connecting] ../docs-md/connecting.md
  * @includeDoc [Models] ../docs-md/models.md
  * @includeDoc [Associations] ../docs-md/associations.md
  * @includeDoc [Model Inheritance] ../docs-md/model-inheritance.md
  * @includeDoc [Model Validation] ../docs-md/validation.md
  * @includeDoc [Model Plugins] ../docs-md/plugins.md
  * @includeDoc [Querying] ../docs-md/querying.md
  * @includeDoc [DDL] ../docs-md/DDL.md
  * @includeDoc [Migrations] ../docs-md/migrations.md
  * @includeDoc [Logging] ../docs-md/logging.md
  * @includeDoc [Change Log] ../History.md
  * @includeDoc [Test Coverage] [../docs-md/coverage.html]
  *
  * @header [../README.md]
  */
 
 
 
 
 
 
1var Dataset = require("./dataset"),
     Database = require("./database"),
     adapters = require("./adapters"),
     EventEmitter = require("events").EventEmitter,
     PatioError = require("./errors").PatioError,
     migrate = require("./migration"),
     model = require("./model"),
     Model = model.Model,
     plugins = require("./plugins"),
     comb = require("comb-proxy"),
     Time = require("./time"),
     date = comb.date,
     SQL = require("./sql").sql,
     Promise = comb.Promise,
     PromiseList = comb.PromiseList,
     singleton = comb.singleton,
     isFunction = comb.isFunction,
     executeInOrder = comb.executeInOrder,
     argsToArray = comb.argsToArray,
     isString = comb.isString,
     patio = exports;
 
1var LOGGER = comb.logger("patio");
 
1var Patio = singleton([EventEmitter, Time], {
     instance: {
         /**
          * @lends patio.prototype
          */
 
         __camelize: false,
 
         __underscore: false,
 
         __inImportOfModels: false,
 
 
         /**
          * A singleton class that acts as the entry point for all actions performed in patio.
          *
          * @example
          *
          * var patio = require("patio");
          *
          * patio.createConnection(....);
          *
          * patio.camelize = true;
          * patio.quoteIdentifiers=false;
          *
          * patio.createModel("my_table");
          *
          *
          *  //CHANGING IDENTIFIER INPUT METHOD
          *
          *
          *  //use whatever is passed in
          *   patio.identifierInputMethod = null;
          *  //convert to uppercase
          *  patio.identifierInputMethod = "toUpperCase";
          *  //convert to camelCase
          *  patio.identifierInputMethod = "camelize";
          *  //convert to underscore
          *  patio.identifierInputMethod = "underscore";
          *
          *
          *  //CHANGING IDENTIFIER OUTPUT METHOD
          *
          *  //use whatever the db returns
          *   patio.identifierOutputMethod = null;
          *  //convert to uppercase
          *  patio.identifierOutputMethod = "toUpperCase";
          *  //convert to camelCase
          *  patio.identifierOutputMethod = "camelize";
          *  //convert to underscore
          *  patio.identifierOutputMethod = "underscore";
          *
          *  //TURN QUOTING OFF
          *   patio.quoteIdentifiers = false
          *
          * @constructs
          * @augments patio.Time
          * @param options
          */
         constructor: function () {
1            this._super(arguments);
1            var constants = SQL.Constants;
1            for (var i in constants) {
9                this[i] = constants[i];
             }
         },
 
         /**
          * Returns a {@link patio.Database} object that can be used to for querying.
          *
          * <p>This method is the entry point for all interactions with a database including getting
          * {@link patio.Dataset}s for creating queries(see {@link patio.Database#from}).
          * </p>
          *
          * <p>The {@link patio.Database} returned can also be used to create({@link patio.Database#createTable}),
          * alter(@link patio.Database#alterTable}), rename({@link patio.Database#renameTable}), and
          * drop({@link patio.Database#dropTable}) as well as many other {@link patio.Database} actions.
          * </p>
          *
          * @example
          *
          * //connect using an object
          * var DB = patio.createConnection({
          *              host : "127.0.0.1",
          *              port : 3306,
          *              type : "mysql",
          *              maxConnections : 1,
          *              minConnections : 1,
          *              user : "test",
          *              password : "testpass",
          *              database : 'test'
          * });
          * //connect using a connection string
          * var CONNECT_STRING = "mysql://test:testpass@localhost:3306/test?maxConnections=1&minConnections=1";
          * var DB = patio.createConnection(CONNECT_STRING);
          *
          * //...do something
          * DB.createTable("myTable", function(){
          *    this.name("text");
          *    this.value("integer");
          * }).chain(function(){
          *     //tables created!!!
          * });
          *
          * @param {String|Object} options the options used to initialize the database connection.
          *                        This may be a database connetion string or object.
          * @param {Number} [options.maxConnections = 10] the number of connections to pool.
          * @param {Number} [options.minConnections = 3] the number of connections to pool.
          * @param {String} [options.type = "mysql"] the type of database to communicate with.
          * @param {String} options.user the user to authenticate as.
          * @param {String} options.password the password of the user.
          * @param {String} options.database the name of the database to use, the database
          *                                   specified here is the default database for all connections.
          */
         createConnection: function (options) {
38            var ret = Database.connect(options);
38            this.emit("connect", ret);
38            return ret;
         },
 
         /**
          *  @see patio#createConnection
          */
         connect: function () {
14            return this.createConnection.apply(this, arguments);
         },
 
         /**
          * This method allows one to connect to a database and immediately execute code.
          * For connection options @see patio#createConnection
          *
          * @example
          *
          *
          * var DB;
          * var CONNECT_STRING = "dummyDB://test:testpass@localhost/dummySchema";
          * var connectPromise = patio.connectAndExecute(CONNECT_STRING, function (db) {
          *      db.dropTable("test");
          *      db.createTable("test", function () {
          *          this.primaryKey("id");
          *          this.name(String);
          *          this.age(Number);
          *      });
          * });
          *
          * connectPromise.chain(function (db) {
          *      //do more stuff!
          *  });
          *
          * @param {String|Object} options @see patio#createConnection
          * @param {Function} cb the function to callback once connected.
          *
          * @returns {comb.Promise} a promise that is resolved once the database execution has finished.
          */
         connectAndExecute: function (options, cb) {
23            if (!isFunction(cb)) {
0                throw new PatioError("callback must be a function");
             }
23            var db = this.createConnection.apply(this, arguments);
23            return executeInOrder(db, patio, function (db, patio) {
23                cb(db, patio);
23                return db;
             });
         },
 
         /**
          * Disconnects all databases in use.
          *
          * @param {Function} [cb=null] a callback to call when disconnect has completed
          * @return {comb.Promise} a promise that is resolved once all databases have disconnected.
          */
         disconnect: function (cb) {
39            var ret = Database.disconnect(cb), self = this;
39            ret.classic(function (err) {
39                if (err) {
0                    self.emit("error", err);
                 } else {
39                    self.emit("disconnect");
                 }
             });
39            return ret.promise();
         },
 
 
         /**
          * This method is used to create a {@link patio.Model} object.
          *
          * @example
          * var Flight = patio.addModel("flight", {
          *      instance:{
          *              toObject:function () {
          *                  var obj = this._super(arguments);
          *                  obj.weekdays = this.weekdaysArray;
          *                  obj.legs = this.legs.map(function (l) {
          *                      return l.toObject();
          *                  });
          *                  return obj;
          *              },
          *
          *              _setWeekdays:function (weekdays) {
          *                  this.weekdaysArray = weekdays.split(",");
          *                  return weekdays;
          *              }
          *      },
          *
          *      static:{
          *
          *          init:function () {
          *              this.oneToMany("legs", {
          *                  model:"flightLeg",
          *                  orderBy:"scheduledDepartureTime",
          *                  fetchType:this.fetchType.EAGER
          *              });
          *          },
          *
          *          byAirline:function (airline) {
          *              return this.filter({airline:airline}).all();
          *          },
          *
          *          arrivesAt:function (airportCode) {
          *              return this.join(this.flightLeg.select("flightId").filter({arrivalCode:airportCode}).distinct(), {flightId:"id"}).all();
          *          },
          *
          *          departsFrom:function (airportCode) {
          *              return this.join(this.flightLeg.select("flightId").filter({departureCode:airportCode}).distinct(), {flightId:"id"}).all();
          *          },
          *
          *          getters:{
          *              flightLeg:function () {
          *                  if (!this.__flightLeg) {
          *                      this.__flightLeg = this.patio.getModel("flightLeg");
          *                  }
          *                  return this.__flightLeg;
          *              }
          *          }
          *      }
          *  });
          *
          *
          * @param {String|patio.Dataset} table the table to use as the base for the model.
          * @param {patio.Model|patio.Model[]} Parent models of this model.
          *                  See {@link patio.plugins.ClassTableInheritancePlugin}.
          * @param {Object} [proto] an object to be used as the prototype for the model. See
          * <a href="http://c2fo.github.com/comb/symbols/comb.html#.define">comb.define</a>.
          * @param [Object[]] [proto.plugins] this can be used to specify additional plugins to use such as.
          * <ul>
          *     <li>{@link patio.plugins.TimeStampPlugin</li>
          *     <li>{@link patio.plugins.CachePlugin</li>
          * </ul>
          *
          *
          *
          */
         addModel: function (table, supers, proto) {
86            return model.create.apply(model, arguments);
         },
 
         /**
          * Returns a model from the name of the table for which the model was created.
          *
          * {@code
          * var TestModel = patio.addModel("test_model").sync(function(err){
          *      if(err){
          *         console.log(err.stack);
          *      }else{
          *            var TestModel = patio.getModel("test_model");
          *      }
          * });
          * }
          *
          * If you have two tables with the same name in different databases then you can use the db parameter also.
          *
          * {@code
          *
          * var DB1 = patio.createConnection("mysql://test:testpass@localhost:3306/test_1");
          * var DB2 = patio.createConnection("mysql://test:testpass@localhost:3306/test_2");
          * var Test1 = patio.addModel(DB1.from("test");
          * var Test2 = patio.addModel(DB2.from("test");
          *
          * //sync the models
          * patio.syncModels().chain(function(){
          *      //now you can use them
          *      var test1Model = new Test1();
          *      var test2Model = new Test2();
          * });
          * }
          *
          *
          * @param {String} name the name of the table that the model represents.
          * @param {@patio.Database} [db] optional database in case you have two models with the same table names in
          *                               different databases.
          */
         getModel: function (name, db) {
79            return model.getModel(name, db);
         },
 
         /**
          * Helper method to sync all models at once.
          *
          * @example
          *
          * var User = patio.addModel("user");
          * var Blog = patio.addModel("blog");
          *
          * //using promise api
          * patio.syncModels().chain(function(){
          *     var user = new User();
          * }, function(error){
          *    console.log(err);
          * });
          *
          * //using a callback
          *
          *  patio.syncModels(function(err){
          *      if(err){
          *          console.log(err);
          *      }else{
          *          var user = new User();
          *      }
          *  });
          *
          * @param {Function} [cb] an optional callback to be invoked when all models have been synced
          * @return {comb.Promise} a promise that will be resolved when the models have been synced.
          */
         syncModels: function (cb) {
31            return model.syncModels(cb);
         },
 
         resetIdentifierMethods: function () {
49            this.quoteIdentifiers = true;
49            this.identifierOutputMethod = null;
49            this.identifierInputMethod = null;
49            Model.identifierOutputMethod = null;
49            Model.identifierInputMethod = null;
         },
 
 
         /**
          * Migrates the database using migration files found in the supplied directory.
          * <br/>
          * <br/>
          * <div>
          *     <h3>Integer Migrations</h3>
          *      Integer migrations are the simpler of the two migrations but are less flexible than timestamp based migrations.
          *      In order for patio to determine which versions to use the file names must end in <versionNumber>.js where
          *      versionNumber is a integer value representing the version number. <b>NOTE:</b>With integer migrations
          *      missing versions are not allowed.
          *      <br/>
          *      <br/>
          *      An example directory structure might look like the following:
          *
          *      <pre class="code">
          * -migrations
          *      - createFirstTables.0.js
          *      - shortDescription.1.js
          *      - another.2.js
          *      .
          *      .
          *      .
          *      -lastMigration.n.js
          *      </pre>
          *      In order to easily identify where certain schema alterations have taken place it is a good idea to provide a brief
          *      but meaningful migration name.
          *      <pre class="code">
          *          createEmployee.0.js
          *          alterEmployeeNameColumn.1.js
          *      </pre>
          *</div>
          *
          * <div>
          *     <h3>Timestamp Migrations</h3>
          *      Timestamp migrations are the more complex of the two migrations but offer greater flexibility especially
          *      with development teams. This is because Timestamp migrations do not require consecutive version numbers,
          *      ,allow for duplicate version numbers(but this should be avoided), keeps track of all currently applied migrations,
          *      and it will merge missing migrations. In order for patio to determine the order of the migration files
          *      the file names must end in <timestamp>.js where the timestamp can be any form of a time stamp.
          *      <pre class="code">
          * //yyyyMMdd
          * 20110131
          * //yyyyMMddHHmmss
          * 20110131123940
          * //unix epoch timestamp
          * 1328035161
          *      </pre>
          *      as long as it is greater than 20000101 other wise it will be assumed to be part of an integer migration.
          *      <br/>
          *      <br/>
          *      An example directory structure might look like the following:
          *
          *      <pre class="code">
          * -migrations
          *      - createFirstTables.1328035161.js
          *      - shortDescription.1328035360.js
          *      - another.1328035376.js
          *      .
          *      .
          *      .
          *      -lastMigration.n.js
          *      </pre>
          *      In order to easily identify where certain schema alterations have taken place it is a good idea to provide a brief
          *      but meaningful migration name.
          *      <pre class="code">
          *          createEmployee.1328035161.js
          *          alterEmployeeNameColumn.1328035360.js
          *      </pre>
          *</div>
          *
          * <b>NOTE:</b>If you start with IntegerBased migrations and decide to transition to Timestamp migrations the
          * patio will attempt the migrate the current schema to the timestamp based migration schema.
          *
          * <div>
          * In order to run a migraton all one has to do is call patio.migrate(DB, directory, options);
          *
          * <pre class="code">
          *  var DB = patio.connect("my://connection/string");
          *  patio.migrate(DB, __dirname + "/migrations").chain(function(){
          *      console.log("migrations finished");
          *  });
          * </pre>
          *
          * <b>Example migration file</b>
          * <pre class="code">
          *
          * //Up function used to migrate up a version
          * exports.up = function(db) {
          *   //create a new table
          *   db.createTable("company", function() {
          *       this.primaryKey("id");
          *       this.companyName(String, {size : 20, allowNull : false});
          *   });
          *   db.createTable("employee", function(table) {
          *       this.primaryKey("id");
          *       this.firstName(String);
          *       this.lastName(String);
          *       this.middleInitial("char", {size : 1});
          *   });
          *};
          *
          * //Down function used to migrate down version
          *exports.down = function(db) {
          *    db.dropTable("employee", "company");
          *};
          * </pre>
          *
          *</div>
          *
          * @param {String|patio.Database} db the database or connection string to a database to migrate.
          * @param {String} directory directory that the migration files reside in
          * @param {Object} [opts={}] optional parameters.
          * @param {String} [opts.column] the column in the table that version information should be stored.
          * @param {String} [opts.table] the table that version information should be stored.
          * @param {Number} [opts.target] the target migration(i.e the migration to migrate up/down to).
          * @param {String} [opts.current] the version that the database is currently at if the current version
          * is not provided it is retrieved from the database.
          *
          * @return {Promise} a promise that is resolved once the migration is complete.
          */
         migrate: function (db) {
31            db = isString(db) ? this.connect(db) : db;
31            var args = argsToArray(arguments);
31            args.splice(0, 1);
31            return migrate.run.apply(migrate, [db].concat(args));
         },
 
         /**
          * This can be used to configure logging. If a options
          * hash is passed in then it will passed to the comb.logging.PropertyConfigurator.
          * If the options are omitted then a ConsoleAppender will be added and the level will
          * be set to info.
          *
          * @example
          * var config = {
          *     "patio" : {
          *         level : "INFO",
          *         appenders : [
          *             {
          *                 type : "RollingFileAppender",
          *                 file : "/var/log/patio.log",
          *             },
          *             {
          *                 type : "RollingFileAppender",
          *                 file : "/var/log/patio-error.log",
          *                 name : "errorFileAppender",
          *                 level : "ERROR"
          *             }
          *         ]
          * };
          *
          * patio.configureLogging(config);
          *
          * @param opts
          */
         configureLogging: function (opts) {
0            comb.logger.configure(opts);
0            if (!opts) {
0                LOGGER.level = "info";
             }
         },
 
         /**
          * Logs an INFO level message to the "patio" logger.
          */
         logInfo: function () {
0            if (LOGGER.isInfo) {
0                LOGGER.info.apply(LOGGER, arguments);
             }
         },
 
         /**
          * Logs a DEBUG level message to the "patio" logger.
          */
         logDebug: function () {
0            if (LOGGER.isDebug) {
0                LOGGER.debug.apply(LOGGER, arguments);
             }
         },
 
         /**
          * Logs an ERROR level message to the "patio" logger.
          */
         logError: function () {
0            if (LOGGER.isError) {
0                LOGGER.error.apply(LOGGER, arguments);
             }
         },
 
         /**
          * Logs a WARN level message to the "patio" logger.
          */
         logWarn: function () {
0            if (LOGGER.isWarn) {
0                LOGGER.warn.apply(LOGGER, arguments);
             }
         },
 
         /**
          * Logs a TRACE level message to the "patio" logger.
          */
         logTrace: function () {
0            if (LOGGER.isTrace) {
0                LOGGER.trace.apply(LOGGER, arguments);
             }
         },
 
         /**
          * Logs a FATAL level message to the "patio" logger.
          */
         logFatal: function () {
0            if (LOGGER.isFatal) {
0                LOGGER.fatal.apply(LOGGER, arguments);
             }
         },
 
 
         /**@ignore*/
         getters: {
             /**@lends patio.prototype*/
             /**
              * An array of databases that are currently connected.
              * @field
              * @type patio.Database[]
              * @default []
              */
             DATABASES: function () {
645                return Database.DATABASES;
             },
             /**
              * Returns the default database. This is the first database created using {@link patio#connect}.
              * @field
              * @type patio.Database
              * @default null
              */
             defaultDatabase: function () {
344                return this.DATABASES.length ? this.DATABASES[0] : null;
             },
             /**@ignore*/
             Database: function () {
9                return Database;
             },
 
             /**@ignore*/
             Dataset: function () {
57                return Dataset;
             },
 
             /**@ignore*/
             SQL: function () {
26                return SQL;
             },
 
             /**@ignore*/
             sql: function () {
864                return SQL;
             },
 
             /**@ignore*/
             plugins: function () {
7                return plugins;
             },
 
             /**@ignore*/
             migrations: function () {
0                return migrate;
             },
 
             /**
              * Returns the root comb logger using this logger you
              * can set the levels add appenders etc.
              *
              * @type Logger
              * @field
              * @default comb.logger("patio")
              */
             LOGGER: function () {
0                return LOGGER;
             },
 
             /**
              * Returns the default method used to transform identifiers sent to the database.
              * See (@link patio.Database.identifierInputMethod}
              * @ignore
              * @field
              * @type String
              * @default Database.identifierInputMethod
              */
             identifierInputMethod: function () {
3                return Database.identifierInputMethod;
             },
 
             /**
              * Returns the default method used to transform identifiers returned from the database.
              * See (@link patio.Database.identifierOutputMethod}
              * @ignore
              * @field
              * @type String
              *
              */
             identifierOutputMethod: function () {
3                return Database.identifierOutputMethod;
             },
 
             /**
              * @ignore
              * @type Boolean
              * Returns whether or not identifiers are quoted before being sent to the database.
              */
             quoteIdentifiers: function (value) {
1                return Database.quoteIdentifiers;
             },
 
             /**@ignore*/
             camelize: function () {
1                return this.__camelize;
             },
 
             /**@ignore*/
             underscore: function () {
1                return this.__underscore;
             }
 
         },
 
 
         /**@ignore*/
         setters: {
             /**@lends patio.prototype*/
             /**
              * Set the method to call on identifiers going into the database.  This affects
              * how identifiers are sent to the database. So if you use camelCased and the db identifiers are all underscored
              * use camelize. The method can include
              * <ul>
              *     <li>toUpperCase</li>
              *     <li>toLowerCase</li>
              *     <li>camelize</li>
              *     <li>underscore</li>
              *     <li>Other String instance method names.</li>
              * </ul>
              *
              * patio uses toUpperCase identifiers in all SQL strings for most databases.
              *
              * @field
              * @type String
              * @ignoreCode
              * @example
              *  //use whatever is passed in
              *   patio.identifierInputMethod = null;
              *  //convert to uppercase
              *  patio.identifierInputMethod = "toUpperCase";
              *  //convert to camelCase
              *  patio.identifierInputMethod = "camelize";
              *  //convert to underscore
              *  patio.identifierInputMethod = "underscore";
              *
              * */
             identifierInputMethod: function (value) {
77                Database.identifierInputMethod = value;
             },
 
             /**
              * Set the method to call on identifiers coming out of the database.  This affects
              * the how identifiers are represented by calling the method on them.
              * The method can include
              * <ul>
              *     <li>toUpperCase</li>
              *     <li>toLowerCase</li>
              *     <li>camelize</li>
              *     <li>underscore</li>
              *     <li>Other String instance method names.</li>
              * </ul>
              * most database implementations in patio use toLowerCase
              * @ignoreCode
              * @field
              * @type String
              * @example
              *  //use whatever the db returns
              *   patio.identifierOutputMethod = null;
              *  //convert to uppercase
              *  patio.identifierOutputMethod = "toUpperCase";
              *  //convert to camelCase
              *  patio.identifierOutputMethod = "camelize";
              *  //convert to underscore
              *  patio.identifierOutputMethod = "underscore";
              *
              * */
             identifierOutputMethod: function (value) {
77                Database.identifierOutputMethod = value;
             },
 
             /**
              * Set whether to quote identifiers for all databases by default. By default,
              * patio quotes identifiers in all SQL strings.
              *
              * @ignoreCode
              * @field
              * @type Boolean
              *
              * @example
              *   //Turn quoting off
              *   patio.quoteIdentifiers = false
              * */
             quoteIdentifiers: function (value) {
80                Database.quoteIdentifiers = value;
             },
 
             /**
              * Sets the whether or not to camelize identifiers coming from the database and to underscore
              * identifiers when sending identifiers to the database. Setting this property to true has the same effect
              * as:
              * <pre class="code">
              *     patio.identifierOutputMethod = "camelize";
              *     patio.identifierInputMethod = "underscore";
              * </pre>
 
              * @field
              * @ignoreCode
              * @example
              * patio.camelize = true;
              * patio.connectAndExecute("mysql://test:testpass@localhost:3306/airports", function (db) {
              *      db.createTable("airport", function () {
              *          this.primaryKey("id");
              *          this.airportCode(String, {size:4, allowNull:false, unique:true});
              *          this.name(String, {allowNull:false});
              *          this.city(String, {allowNull:false});
              *          this.state(String, {size:2, allowNull:false});
              *      });
              *      //=> CREATE TABLE `airport`(
              *      //    id integer PRIMARY KEY AUTO_INCREMENT,
              *      //    airport_code varchar(4) UNIQUE NOT NULL,
              *      //    name varchar(255) NOT NULL,
              *      //    city varchar(255) NOT NULL,
              *      //    state varchar(2) NOT NULL
              *      //);
              *  }):
              *
              * @param {Boolean} camelize set to true to camelize all identifiers coming from the database and to
              *                  underscore all identifiers sent to the database.
              */
             camelize: function (camelize) {
21                camelize = camelize === true;
21                Model.camelize = camelize;
21                this.identifierOutputMethod = camelize ? "camelize" : "underscore";
21                this.identifierInputMethod = camelize ? "underscore" : "camelize";
21                this.__underscore = !camelize;
21                this.__camelize = camelize;
             },
 
             /**
              * Sets the whether or not to underscore identifiers coming from the database and to camelize
              * identifiers when sending identifiers to the database. Setting this property to true has the same effect
              * as:
              * <pre class="code">
              *     patio.identifierOutputMethod = "underscore";
              *     patio.identifierInputMethod = "camelize";
              * </pre>
              *
              *
              * @field
              * @ignoreCode
              * @example
              * patio.camelize = true;
              * patio.connectAndExecute("mysql://test:testpass@localhost:3306/airports", function (db) {
              *      db.createTable("airport", function () {
              *          this.primaryKey("id");
              *          this.airport_code(String, {size:4, allowNull:false, unique:true});
              *          this.name(String, {allowNull:false});
              *          this.city(String, {allowNull:false});
              *          this.state(String, {size:2, allowNull:false});
              *      });
              *      //=> CREATE TABLE `airport`(
              *      //    id integer PRIMARY KEY AUTO_INCREMENT,
              *      //    airportCode varchar(4) UNIQUE NOT NULL,
              *      //    name varchar(255) NOT NULL,
              *      //    city varchar(255) NOT NULL,
              *      //    state varchar(2) NOT NULL
              *      //);
              *  }):
              *
              * @param {Boolean} camelize set to true to underscore all identifiers coming from the database and to
              *                  camelize all identifiers sent to the database.
              */
             underscore: function (underscore) {
1                underscore = underscore === true;
1                Model.underscore = underscore;
1                this.identifierOutputMethod = underscore ? "underscore" : "camelize";
1                this.identifierInputMethod = underscore ? "camelize" : "underscore";
1                this.__camelize = !underscore;
1                this.__underscore = underscore;
             }
         }
     }
 });
 
 
1module.exports = patio = new Patio();
1patio.__Patio = Patio;
1var adapters = Database.ADAPTERS;
1for (var i in adapters) {
4    patio[i] = adapters[i];
 }