1var comb = require("comb-proxy"),
     argsToArray = comb.argsToArray,
     merge = comb.merge,
     isFunction = comb.isFunction,
     isDefined = comb.isDefined,
     isHash = comb.isHash,
     isString = comb.isString,
     isArray = comb.isArray,
     toArray = comb.array.toArray,
     methodMissing = comb.methodMissing,
     define = comb.define;
 
 
1var Generator = define(null, {
     instance:{
         /**@lends patio.SchemaGenerator.prototype*/
 
         __primaryKey:null,
 
         /**
          * An internal class that the user is not expected to instantiate directly.
          * Instances are created by {@link patio.Database#createTable}.
          * It is used to specify table creation parameters.  It takes a Database
          * object and a block of column/index/constraint specifications, and
          * gives the Database a table description, which the database uses to
          * create a table.
          *
          * {@link patio.SchemaGenerator} has some methods but also includes method_missing,
          * allowing users to specify column type as a method instead of using
          * the column method, which makes for a cleaner code.
          * @constructs
          * @example
          *comb.executeInOrder(DB, function(DB){
          *       DB.createTable("airplane_type", function () {
          *          this.primaryKey("id");
          *          this.name(String, {allowNull:false});
          *          this.max_seats(Number, {size:3, allowNull:false});
          *          this.company(String, {allowNull:false});
          *       });
          *      DB.createTable("airplane", function () {
          *          this.primaryKey("id");
          *          this.total_no_of_seats(Number, {size:3, allowNull:false});
          *          this.foreignKey("typeId", "airplane_type", {key:"id"});
          *      });
          *      DB.createTable("flight_leg", function () {
          *          this.primaryKey("id");
          *          this.scheduled_departure_time("time");
          *          this.scheduled_arrival_time("time");
          *          this.foreignKey("departure_code", "airport", {key:"airport_code", type : String, size : 4});
          *          this.foreignKey("arrival_code", "airport", {key:"airport_code", type : String, size : 4});
          *          this.foreignKey("flight_id", "flight", {key:"id"});
          *      });
          *      DB.createTable("leg_instance", function () {
          *          this.primaryKey("id");
          *          this.date("date");
          *          this.arr_time("datetime");
          *          this.dep_time("datetime");
          *          this.foreignKey("airplane_id", "airplane", {key:"id"});
          *          this.foreignKey("flight_leg_id", "flight_leg", {key:"id"});
          *      });
          *});
          * @param {patio.Database} the database this generator is for
          */
         constructor:function (db) {
218            this.db = db;
218            this.columns = [];
218            this.indexes = [];
218            this.constraints = [];
218            this.__primaryKey = null;
         },
 
         /**
          * Add an unnamed constraint to the DDL, specified by the given block
          * or args:
          *
          * @example
          * db.createTable("test", function(){
          *   this.check({num : {between : [1,5]}})
          *      //=> CHECK num >= 1 AND num <= 5
          *   this.check(function(){return this.num.gt(5);});
          *      //=> CHECK num > 5
          * });
          **/
         check:function () {
0            return this.constraint.apply(this, [null].concat(argsToArray(arguments)));
         },
 
         /**
          * Add a column with the given name, type, and opts to the DDL.
          *
          * <pre class="code">
          *  DB.createTable("test", function(){
          *      this.column("num", "integer");
          *          //=> num INTEGER
          *      this.column('name", String, {allowNull : false, "default" : "a");
          *          //=> name varchar(255) NOT NULL DEFAULT 'a'
          *      this.column("ip", "inet");
          *          //=> ip inet
          *   });
          * </pre>
          *
          * You can also create columns via method missing, so the following are
          * equivalent:
          * <pre class="code">
          * DB.createTable("test", function(){
          *   this.column("number", "integer");
          *   this.number("integer");
          * });
          * </pre>
          *
          * @param {String|patio.sql.Identifier} name the name of the column
          * @param type the datatype of the column.
          * @param {Object} [opts] additional options
          *
          * @param [opts.default] The default value for the column.
          * @param [opts.deferrable] This ensure Referential Integrity will work even if
          *                reference table will use for its foreign key a value that does not
          *                exists(yet) on referenced table. Basically it adds
          *                DEFERRABLE INITIALLY DEFERRED on key creation.
          * @param {Boolean} [opts.index]  Create an index on this column.
          * @param {String|patio.sql.Identifier} [key] For foreign key columns, the column in the associated table
          *         that this column references.  Unnecessary if this column references the primary key of the
          *         associated table.
          * @param {Boolean} [opts.allowNull]  Mark the column as allowing NULL values (if true),
          *          or not allowing NULL values (if false).  If unspecified, will default
          *          to whatever the database default is.
          * @param {String} [opts.onDelete] Specify the behavior of this column when being deleted
          *               ("restrict", "cascade", "setNull", "setDefault", "noAction").
          * @param {String} [opts.onUpdate] Specify the behavior of this column when being updated
          *               Valid options ("restrict", "cascade", "setNull", "setDefault", "noAction").
          * @param {Boolean} [opts.primaryKey] Make the column as a single primary key column.  This should only
          *                 be used if you have a single, non-autoincrementing primary key column.
          * @param {Number} [opts.size] The size of the column, generally used with string
          *          columns to specify the maximum number of characters the column will hold.
          *          An array of two integers can be provided to set the size and the
          *          precision, respectively, of decimal columns.
          * @param {String} [opts.unique] Mark the column as unique, generally has the same effect as
          *            creating a unique index on the column.
          * @param {String} [opts.unsigned] Make the column type unsigned, only useful for integer
          *              columns.
          * @param {Array} [opts.elements] Available items used for set and enum columns.
          *
          **/
         column:function (name, type, opts) {
549            opts = opts || {};
549            this.columns.push(merge({name:name, type:type}, opts));
549            if (opts.index) {
1                this.index(name);
             }
         },
 
         /**
          * Adds a named constraint (or unnamed if name is nil) to the DDL,
          * with the given block or args.
          * @example
          * DB.createTable("test", function(){
          *      this.constraint("blah", {num : {between : [1,5])
          *              //=> CONSTRAINT blah CHECK num >= 1 AND num <= 5
          *      this.check("foo", function(){
          *          return this.num.gt(5);
          *      }); # CONSTRAINT foo CHECK num > 5
          * });
          * @param {String|patio.sql.Identifier} name the name of the constraint
          * @param {...} args variable number of arguments to create the constraint filter.
          *              See {@link patio.Dataset#filter} for valid filter arguments.
          *   */
         constraint:function (name, args) {
0            args = argsToArray(arguments).slice(1);
0            var block = isFunction(args[args.length - 1]) ? args.pop : null;
0            this.constraints.push({name:name, type:"check", check:block || args});
         },
 
         /**
          *  Add a foreign key in the table that references another table to the DDL. See {@link patio.SchemaGenerator#column{
          * for options.
          *
          * @example
          * DB.createTable("flight_leg", function () {
          *      this.primaryKey("id");
          *      this.scheduled_departure_time("time");
          *      this.scheduled_arrival_time("time");
          *      this.foreignKey("departure_code", "airport", {key:"airport_code", type : String, size : 4});
          *      this.foreignKey("arrival_code", "airport", {key:"airport_code", type : String, size : 4});
          *      this.foreignKey("flight_id", "flight", {key:"id"});
          * });
          **/
         foreignKey:function (name, table, opts) {
37            opts = opts || {};
37            opts = isHash(table) ? merge({}, table, opts) : isString(table) ? merge({table:table}, opts) : opts;
37            if (isArray(name)) {
5                return this.__compositeForeignKey(name, opts);
             } else {
32                return this.column(name, "integer", opts);
             }
         },
 
         /**
          *Add a full text index on the given columns to the DDL.
          *
          * @example
          *  DB.createTable("posts", function () {
          *      this.title("text");
          *      this.body("text");
          *      this.fullTextIndex("title");
          *      this.fullTextIndex(["title", "body"]);
          *  });
          */
         fullTextIndex:function (columns, opts) {
4            opts = opts || {};
4            return this.index(columns, merge({type:"fullText"}, opts));
         },
 
         /**
          *
          * Check if the DDL includes the creation of a column with the given name.
          * @return {Boolean} true if the DDL includes the creation of a column with the given name.
          */
         hasColumn:function (name) {
70            return this.columns.some(function (c) {
310                return c.name == name
             });
         },
 
         /**
          * Add an index on the given column(s) with the given options to the DDL.
          * The available options are:
          * @example
          * DB.createTable("test", function(table) {
          *       table.primaryKey("id", "integer", {null : false});
          *       table.column("name", "text");
          *       table.index("name", {unique : true});
          * });
          *
          * @param columns the column/n to create the index from.
          * @param {Object}  [opts] Additional options
          * @param {String}  [opts.type] The type of index to use (only supported by some databases)
          * @param {Boolean} [opts.unique] :: Make the index unique, so duplicate values are not allowed.
          * @param [opts.where] :: Create a partial index (only supported by some databases)
          **/
         index:function (columns, opts) {
17            this.indexes.push(merge({columns:toArray(columns)}, opts || {}));
         },
 
         /**
          * Adds an auto-incrementing primary key column or a primary key constraint to the DDL.
          * To create a constraint, the first argument should be an array of columns
          * specifying the primary key columns. To create an auto-incrementing primary key
          * column, a single column can be used. In both cases, an options hash can be used
          * as the second argument.
          *
          * If you want to create a primary key column that is not auto-incrementing, you
          * should not use this method.  Instead, you should use the regular {@link patio.SchemaGenerator#column}
          * method with a {primaryKey : true} option.
          *
          * @example
          * db.createTable("airplane_type", function () {
          *      this.primaryKey("id");
          *          //=> id integer NOT NULL PRIMARY KEY AUTOINCREMENT
          *      this.name(String, {allowNull:false});
          *      this.max_seats(Number, {size:3, allowNull:false});
          *      this.company(String, {allowNull:false});
          * });
          * */
         primaryKey:function (name) {
70            if (isArray(name)) {
0                return this.__compositePrimaryKey.apply(this, arguments);
             } else {
70                var args = argsToArray(arguments, 1), type;
70                var opts = args.pop();
70                this.__primaryKey = merge({}, this.db.serialPrimaryKeyOptions, {name:name}, opts);
70                if (isDefined((type = args.pop()))) {
3                    merge(opts, {type:type});
                 }
70                merge(this.__primaryKey, opts);
70                return this.__primaryKey;
             }
         },
 
         /**
          * Add a spatial index on the given columns to the DDL.
          */
         spatialIndex:function (columns, opts) {
2            opts = opts || {};
2            return this.index(columns, merge({type:"spatial"}, opts));
         },
 
         /**
          * Add a unique constraint on the given columns to the DDL. See {@link patio.SchemaGenerator#constraint}
          * for argument types.
          * @example
          * DB.createTable("test", function(){
          *   this.unique("name");
          *          //=> UNIQUE (name)
          * });
          *   */
         unique:function (columns, opts) {
0            opts = opts || {};
0            this.constraints.push(merge({type:"unique", columns:toArray(columns)}, opts));
         },
 
 
         /**
          * @private
          * Add a composite primary key constraint
          */
         __compositePrimaryKey:function (columns) {
0            var args = argsToArray(arguments, 1);
0            var opts = args.pop() || {};
0            this.constraints.push(merge({type:"primaryKey", columns:columns}, opts));
         },
 
         /**
          * @private
          * Add a composite foreign key constraint
          */
         __compositeForeignKey:function (columns, opts) {
5            this.constraints.push(merge({type:"foreignKey", columns:columns}, opts));
         },
 
         /**@ignore*/
         getters:{
             // The name of the primary key for this generator, if it has a primary key.
             primaryKeyName:function () {
70                return this.__primaryKey ? this.__primaryKey.name : null;
             }
 
         }
 
     }
 });
 
1exports.SchemaGenerator = function (db, block) {
218    var gen = new Generator(db);
218    var prox = methodMissing(gen, function (name) {
431        return function (type, opts) {
431            name = name || null;
431            opts = opts || {};
431            if (name) {
431                return this.column(name, type, opts);
             } else {
0                throw new TypeError();
             }
         }
     }, Generator);
218    block.apply(prox, [prox]);
218    gen.columns = prox.columns;
218    if (gen.__primaryKey && !gen.hasColumn(gen.primaryKeyName)) {
70        gen.columns.unshift(gen.__primaryKey);
     }
218    return gen;
 }
 
 
1var AlterTableGenerator = define(null, {
     instance:{
         /**@lends patio.AlterTableGenerator.prototype*/
 
         /**
          * An internal class that the user is not expected to instantiate directly.
          * Instances are created by {@link patio.Database#alterTable}.
          * It is used to specify table alteration parameters.  It takes a Database
          * object and a function which is called in the scope of the {@link patio.AlterTableGenerator}
          * to perform on the table, and gives the Database an array of table altering operations,
          * which the database uses to alter a table's description.
          *
          * @example
          * DB.alterTable("xyz", function() {
          *      this.addColumn("aaa", "text", {null : false, unique : true});
          *      this.dropColumn("bbb");
          *      this.renameColumn("ccc", "ddd");
          *      this.setColumnType("eee", "integer");
          *      this.setColumnDefault("hhh", 'abcd');
          *      this.addIndex("fff", {unique : true});
          *      this.dropIndex("ggg");
          * });
          *
          * //or using the passed in generator
          *  DB.alterTable("xyz", function(table) {
          *      table.addColumn("aaa", "text", {null : false, unique : true});
          *      table.dropColumn("bbb");
          *      table.renameColumn("ccc", "ddd");
          *      table.setColumnType("eee", "integer");
          *      table.setColumnDefault("hhh", 'abcd');
          *      table.addIndex("fff", {unique : true});
          *      table.dropIndex("ggg");
          * });
          * @constructs
          *
          * @param {patio.Database} db the database object which is performing the alter table operation.
          * @param {Function} block a block which performs the operations. The block is called in the scope
          * of the {@link patio.AlterTableGenerator} and is passed an instance of {@link patio.AlterTableGenerator}
          * as the first argument.
          */
         constructor:function (db, block) {
80            this.db = db;
80            this.operations = [];
80            block.apply(this, [this]);
 
         },
 
         /**
          * Add a column with the given name, type, and opts to the DDL for the table.
          * See {@link patio.SchemaGenerator#column} for the available options.
          *
          * @example
          * DB.alterTable("test", function(){
          *   this.addColumn("name", String);
          *     //=> ADD COLUMN name varchar(255)
          * });
          **/
         addColumn:function (name, type, opts) {
13            opts = opts || {};
13            this.operations.push(merge({op:"addColumn", name:name, type:type}, opts));
         },
 
         /**
          * Add a constraint with the given name and args to the DDL for the table.
          * See {@link patio.SchemaGenerator#constraint}.
          *
          * @example
          * var sql = patio.sql;
          * DB.alterTable("test", function(){
          *      this.addConstraint("valid_name", sql.name.like('A%'));
          *          //=>ADD CONSTRAINT valid_name CHECK (name LIKE 'A%')
          * });
          *   */
         addConstraint:function (name) {
0            var args = argsToArray(arguments);
0            var block = isFunction(args[args.length - 1]) ? args.pop() : null;
0            this.operations.push({op:"addConstraint", name:name, type:"check", check:block || args});
         },
 
         /**
          * Add a unique constraint to the given column(s).
          * See {@link patio.SchemaGenerator#constraint}.
          * @example
          * DB.alterTable("test", function(){
          *   this.addUniqueConstraint("name");
          *      //=> ADD UNIQUE (name)
          *   this.addUniqueConstraint("name", {name : "uniqueName});
          *      //=> ADD CONSTRAINT uniqueName UNIQUE (name)
          * });
          **/
         addUniqueConstraint:function (columns, opts) {
0            opts = opts || {};
0            this.operations.push(merge({op:"addConstraint", type:"unique", columns:toArray(columns)}, opts));
         },
 
         /**
          * Add a foreign key with the given name and referencing the given table
          * to the DDL for the table.  See {@link patio.SchemaGenerator#column}
          * for the available options.
          *
          * You can also pass an array of column names for creating composite foreign
          * keys. In this case, it will assume the columns exists and will only add
          * the constraint.
          *
          * NOTE: If you need to add a foreign key constraint to a single existing column
          * use the composite key syntax even if it is only one column.
          * @example
          * DB.alterTable("albums", function(){
          *   this.addForeignKey("artist_id", "table");
          *          //=>ADD COLUMN artist_id integer REFERENCES table
          *   this.addForeignKey(["name"], "table")
          *          //=>ADD FOREIGN KEY (name) REFERENCES table
          * });
          */
         addForeignKey:function (name, table, opts) {
3            opts = opts;
3            if (isArray(name)) {
1                return this.__addCompositeForeignKey(name, table, opts);
             } else {
2                return this.addColumn(name, "integer", merge({table:table}, opts));
             }
         },
 
         /**
          * Add a full text index on the given columns to the DDL for the table.
          * See @{link patio.SchemaGenerator#index} for available options.
          */
         addFullTextIndex:function (columns, opts) {
0            opts = opts || {};
0            return this.addIndex(columns, merge({type:"fullText"}, opts));
         },
 
         /**
          * Add an index on the given columns to the DDL for the table.  See
          * {@link patio.SchemaGenerator#index} for available options.
          * @example
          * DB.alterTable("table", function(){
          *   this.addIndex("artist_id");
          *          //=> CREATE INDEX table_artist_id_index ON table (artist_id)
          * });
          */
         addIndex:function (columns, opts) {
5            opts = opts || {};
5            this.operations.push(merge({op:"addIndex", columns:toArray(columns)}, opts));
         },
 
         /**
          * Add a primary key to the DDL for the table.  See {@link patio.SchemaGenerator#column}
          * for the available options.  Like {@link patio.ALterTableGenerator#addForeignKey}, if you specify
          * the column name as an array, it just creates a constraint:
          *
          * @example
          * DB.alterTable("albums", function(){
          *      this.addPrimaryKey("id");
          *           //=> ADD COLUMN id serial PRIMARY KEY
          *      this.addPrimaryKey(["artist_id", "name"])
          *          //=>ADD PRIMARY KEY (artist_id, name)
          * });
          */
         addPrimaryKey:function (name, opts) {
0            opts = opts || {};
0            if (isArray(name)) {
0                return this.__addCompositePrimaryKey(name, opts);
             } else {
0                opts = merge({}, this.db.serialPrimaryKeyOptions, opts);
0                delete opts.type;
0                return this.addColumn(name, "integer", opts);
             }
         },
 
         /**
          * Add a spatial index on the given columns to the DDL for the table.
          * See {@link patio.SchemaGenerator#index} for available options.
          * */
         addSpatialIndex:function (columns, opts) {
0            opts = opts || {};
0            this.addIndex(columns, merge({}, {type:"spatial"}, opts))
         },
 
         /**
          * Remove a column from the DDL for the table.
          *
          * @example
          * DB.alterTable("albums", function(){
          *   this.dropColumn("artist_id");
          *      //=>DROP COLUMN artist_id
          * });
          *
          * @param {String|patio.sql.Identifier} name the name of the column to drop.
          */
         dropColumn:function (name) {
4            this.operations.push({op:"dropColumn", name:name});
         },
 
         /**
          * Remove a constraint from the DDL for the table.
          * @example
          * DB.alterTable("test", function(){
          *      this.dropConstraint("constraint_name");
          *          //=>DROP CONSTRAINT constraint_name
          * });
          * @param {String|patio.sql.Identifier} name the name of the constraint to drop.
          */
         dropConstraint:function (name) {
0            this.operations.push({op:"dropConstraint", name:name});
         },
 
         /**
          * Remove an index from the DDL for the table.
          *
          * @example
          * DB.alterTable("albums", function(){
          *   this.dropIndex("artist_id")
          *      //=>DROP INDEX table_artist_id_index
          *   this.dropIndex(["a", "b"])
          *      //=>DROP INDEX table_a_b_index
          *   this.dropIndex(["a", "b"], {name : "foo"})
          *          //=>DROP INDEX foo
          * });
          */
         dropIndex:function (columns, opts) {
2            opts = opts || {};
2            this.operations.push(merge({op:"dropIndex", columns:toArray(columns)}, opts));
         },
 
         /**
          * Modify a column's name in the DDL for the table.
          *
          * @example
          * DB.alterTable("artist", function(){
          *      this.renameColumn("name", "artistName");
          *          //=> RENAME COLUMN name TO artist_name
          * });
          */
         renameColumn:function (name, newName, opts) {
51            opts = opts || {};
51            this.operations.push(merge({op:"renameColumn", name:name, newName:newName}, opts));
         },
 
         /**
          * Modify a column's default value in the DDL for the table.
          * @example
          * DB.alterTable("artist", function(){
          *      //=>this.setColumnDefault("artist_name", "a");
          *          //=> ALTER COLUMN artist_name SET DEFAULT 'a'
          * });
          *   */
         setColumnDefault:function (name, def) {
5            this.operations.push({op:"setColumnDefault", name:name, "default":def});
         },
 
         /**
          * Modify a column's type in the DDL for the table.
          *
          * @example
          * DB.alterTable("artist", function(){
          *   this.setColumnType("artist_name", 'char(10)');
          *      //=> ALTER COLUMN artist_name TYPE char(10)
          * });
          */
         setColumnType:function (name, type, opts) {
7            opts = opts || {}
7            this.operations.push(merge({op:"setColumnType", name:name, type:type}, opts));
         },
 
         /**
          * Modify a column's NOT NULL constraint.
          * @example
          * DB.alterTable("artist", function(){
          *   this.setColumnAllowNull("artist_name", false);
          *      //=> ALTER COLUMN artist_name SET NOT NULL
          * });
          **/
         setAllowNull:function (name, allowNull) {
1            this.operations.push({op:"setColumnNull", name:name, "null":allowNull});
         },
 
         /**
          * @private
          * Add a composite primary key constraint
          **/
         __addCompositePrimaryKey:function (columns, opts) {
0            this.operations.push(merge({op:"addConstraint", type:"primaryKey", columns:columns}, opts));
         },
 
         /**
          * @private
          * Add a composite foreign key constraint
          * */
         __addCompositeForeignKey:function (columns, table, opts) {
1            this.operations.push(merge({op:"addConstraint", type:"foreignKey", columns:columns, table:table}, opts));
         }
     }
 }).as(exports, "AlterTableGenerator");
 
 
 

 /**
  * @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
  * [![Build Status](https://secure.travis-ci.org/C2FO/patio.png)](http://travis-ci.org/C2FO/patio)
  *
  * Patio is a <a href="http://sequel.rubyforge.org/" target="patioapi">Sequel</a> inspired query engine.
  *
  * <h3>Why Use Patio?</h3>
  *
  * <p>
  * Patio is different because it allows the developers to choose the level of abtraction they are comfortable with.
  * </p>
  * <p>
  * If you want to use <a href="./models.html">ORM</a> functionality you can. If you dont you can just use the
  * <a href="./DDL.html">Database</a> and <a href="./querying.html">Datasets</a> as a querying API, and if you need to
  * you can <a href="./patio_Database.html#run">write plain SQL</a>.
  * </p>
  *
  *
  * ###Getting Started
  *
  * To install patio run
  *
  * `npm install comb patio`
  *
  * If you want to use the patio executable for migrations
  *
  * `npm install -g patio`
  *
  *
  * Create some tables.
  *
  * ```
  * var patio = require("patio"),
  * comb = require("comb"),
  * when = comb.when,
  * serial = comb.serial;
  *
  *
  * //set all db name to camelize
  * patio.camelize = true;
  * patio.configureLogging();
  * //connect to the db
  * var DB = patio.connect(<CONNECTION_URI>);
  *
  * function errorHandler(error) {
  *      console.log(error);
  *      patio.disconnect();
  * };
  *
  * function createTables() {
  *      return comb.serial([
  *           function () {
  *                return DB.forceDropTable(["capital", "state"]);
  *           },
  *           function () {
  *                return DB.createTable("state", function () {
  *                     this.primaryKey("id");
  *                     this.name(String)
  *                     this.population("integer");
  *                     this.founded(Date);
  *                     this.climate(String);
  *                     this.description("text");
  *                });
  *           },
  *           function () {
  *                return DB.createTable("capital", function () {
  *                     this.primaryKey("id");
  *                     this.population("integer");
  *                     this.name(String);
  *                     this.founded(Date);
  *                     this.foreignKey("stateId", "state", {key:"id"});
  *                });
  *           }
  *      ]);
  * };
  *
  * createTables().then(function () {
  *      patio.disconnect();
  * }, errorHandler);
  * ```
  *
  * Next lets create some models for the tables created.
  *
  * ```
  * var State = patio.addModel("state").oneToOne("capital");
  * var Capital = patio.addModel("capital").manyToOne("state");
  * ```
  *
  * Next you'll need to sync your models. **Note**: The sync operation returns a promise.
  *
  * ```
  * patio.syncModels();
  * ```
  *
  * Save some data to query.
  *
  * ```
  * //comb.when waits for the save operation to complete
  * return comb.when(
  *      State.save({
  *           name:"Nebraska",
  *           population:1796619,
  *           founded:new Date(1867, 2, 4),
  *           climate:"continental",
  *           capital:{
  *                name:"Lincoln",
  *                founded:new Date(1856, 0, 1),
  *                population:258379
  *          }
  *      }),
  *      Capital.save({
  *           name:"Austin",
  *           founded:new Date(1835, 0, 1),
  *           population:790390,
  *           state:{
  *                name:"Texas",
  *                population:25674681,
  *                founded:new Date(1845, 11, 29)
  *           }
  *      })
  * );
  * ```
  *
  * Now we can query the states and capitals we created.
  *
  * ```
  * State.order("name").forEach(function (state) {
  *      //if you return a promise here it will prevent the foreach from
  *      //resolving until all inner processing has finished.
  *      return state.capital.then(function (capital) {
  *          console.log("%s's capital is %s.", state.name, capital.name);
  *      });
  * });
  * ```
  *
  * ```
  * Capital.order("name").forEach(function (capital) {
  *      //if you return a promise here it will prevent the foreach from
  *      //resolving until all inner processing has finished.
  *      return capital.state.then(function (state) {
  *          console.log(comb.string.format("%s is the capital of %s.", capital.name, state.name));
  *      });
  * });
  * ```
  */
 
 
 
 
 
 
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,
     hitch = comb.hitch,
     Promise = comb.Promise,
     PromiseList = comb.PromiseList,
     singleton = comb.singleton,
     isFunction = comb.isFunction,
     executeInOrder = comb.executeInOrder,
     argsToArray = comb.argsToArray,
     isString = comb.isString;
 
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");
          * }).then(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) {
41            var ret = Database.connect(options);
41            this.emit("connect", ret);
41            return ret;
         },
 
         /**
          *  @see patio#createConnection
          */
         connect:function () {
13            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.then(function (db) {
          *      DB = 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) {
27            if (!isFunction(cb)) {
0                throw new PatioError("callback must be a function");
             }
27            var db = this.createConnection.apply(this, arguments);
27            return executeInOrder(db, patio, function (db, patio) {
27                cb(db, patio);
27                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) {
41            var ret = Database.disconnect(cb);
41            ret.classic(hitch(this, function (err) {
41                if (err) {
0                    this.emit("error", err);
                 } else {
41                    this.emit("disconnect");
                 }
             }));
41            return ret.promise();
         },
 
         /**
          * Allows for the importing of multiple models so you do not have to worry about the promise that is returned from create model,
          * or a directory if an index.js file is used.
          *
          * <p>
          *     To import a group of model files you can do the following:
          * {@code
          * patio.import(__dirname + "/models/Flight.js",
          *              __dirname + "/models/Airport.js",
          *              __dirname + "/models/Airplane.js").then(function(Flight, Airport, Airplane){
          *                  //...
          *              });
          *
          * patio.import(__dirname + "/models/Flight.js",
          *              __dirname + "/models/Airport.js",
          *              __dirname + "/models/Airplane.js").then(function(){
          *                  var Flight = patio.getModel("flight"),
          *                      Airport = patio.getModel("airport"),
          *                      Airplane = patio.getModel("airplane");
          *              });
          *      </pre>
          *     Another approach is to create an index.js file inside of a directory that requires all of the models needed.
          *     then use {@link patio#import} on that file.
          *     <pre class="code">
          * patio.import(__dirname + "/models").then(function(){
          *      var Flight = patio.getModel("flight"),
          *          Airport = patio.getModel("airport"),
          *          Airplane = patio.getModel("airplane");
          * });
          * }
          * </p>
          *
          * @param files a single or list of files to import.
          * @param {Function} [cb] an optional callback to call when importing is complete
          *
          * @return {Promise} returns a promise that will be resolved when all models in the imported files
          * have been loaded.
          */
         "import":function (files, cb) {
0            files = argsToArray(arguments);
0            if (isFunction(files[files.length])) {
0                cb = files.pop();
             } else {
0                cb = null;
             }
0            files.map(function (file) {
0                require(file);
             });
0            return model.syncModels(cb).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) {
93            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().then(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) {
83            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().then(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) {
35            return model.syncModels(cb);
         },
 
         resetIdentifierMethods:function () {
51            this.quoteIdentifiers = true;
51            this.identifierOutputMethod = null;
51            this.identifierInputMethod = null;
51            Model.identifierOutputMethod = null;
51            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").then(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 () {
733                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 () {
392                return this.DATABASES.length ? this.DATABASES[0] : null;
             },
             /**@ignore*/
             Database:function () {
9                return Database;
             },
 
             /**@ignore*/
             Dataset:function () {
57                return Dataset;
             },
 
             /**@ignore*/
             SQL:function () {
25                return SQL;
             },
 
             /**@ignore*/
             sql:function () {
8                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) {
79                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) {
79                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) {
81                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;
             }
         }
     }
 });
 
 
1var patio = exports;
1module.exports = patio = new Patio();
1patio.__Patio = Patio;
1var adapters = Database.ADAPTERS;
1for (var i in adapters) {
3    patio[i] = adapters[i];
 }

1var pg = require("pg"),
     PgTypes = require("pg/lib/types"),
     StringDecoder = require("string_decoder").StringDecoder,
     comb = require("comb"),
     asyncArray = comb.async.array,
     string = comb.string,
     pad = string.pad,
     format = string.format,
     hitch = comb.hitch,
     when = comb.when,
     serial = comb.serial,
     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,
     Double = sql.Double,
     identifier = sql.identifier,
     BooleanExpression = sql.BooleanExpression,
     LiteralString = sql.LiteralString,
     Subscript = sql.Subscript,
     patio;
 
1var getPatio = function () {
42    return patio || (patio = require("../index.js"));
 };
 
1var isBlank = function (obj) {
374    var ret = false;
374    if (isUndefinedOrNull(obj)) {
313        ret = true;
61    } else if (isString(obj) || isArray(obj)) {
61        ret = obj.length === 0;
0    } else if (isBoolean(obj) && !obj) {
0        ret = true;
0    } else if (isObject(obj) && isEmpty(obj)) {
0        ret = true;
     }
374    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 (full_match, 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) {
0    return getPatio().stringToTime(val.toString(), DS.TIME_FORMAT);
 });
 
 
1var Connection = define(null, {
     instance:{
 
         connection:null,
 
 
         constructor:function (conn) {
64            this.connection = conn;
         },
 
         closeConnection:function () {
64            this.connection.end();
64            return new Promise().callback().promise();
         },
 
         query:function (query) {
7582            var ret = new Promise();
7582            try {
7582                this.connection.setMaxListeners(0);
7582                var fields = [];
7582                var q = this.connection.query(query, hitch(this, function (err, results) {
7582                    q.handleRowDescription = orig;
7582                    if (err) {
71                        return ret.errback(err);
                     } else {
7511                        return ret.callback(results.rows, fields);
                     }
                 }));
7582                var orig = q.handleRowDescription;
7582                q.handleRowDescription = function (msg) {
4372                    fields = msg.fields;
4372                    return orig.apply(q, arguments);
                 };
             } catch (e) {
0                patio.logError(e);
             }
7582            return ret.promise();
         }
     }
 });
 
1var DS = define(Dataset, {
     instance:{
 
         complexExpressionSql:function (op, args) {
5982            var ret = "";
5982            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 {
5982                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                return this.db.transaction(opts, function () {
1                    return serial([
                         this.lock.bind(this, mode, opts),
                         cb.bind(this)
                     ]);
 
                 }.bind(this));
             } 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))];
         },
 
 
         _deleteFromSql:function () {
930            var self = this._static, space = self.SPACE;
930            return [space, self.FROM, space, this._sourceList(this.__opts.from[0])].join("");
         },
 
 
         _deleteUsingSql:function () {
930            return this._joinFromSql("USING");
         },
 
         _joinFromSql:function (type) {
1136            var from = this.__opts.from.slice(1), join = this.__opts.join, ret = "";
1136            if (!from.length) {
1136                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("");
             }
1136            return ret;
         },
 
         _selectLockSql:function () {
3079            if (this.__opts.lock === "share") {
0                return this._static.FOR_SHARE;
             } else {
3079                return this._super(arguments);
             }
         },
 
         _selectWithSql:function () {
5535            var optsWith = this.__opts["with"];
5535            if (!isEmpty(optsWith) && optsWith.some(function (w) {
0                return w.recursive;
             })) {
0                return this._static.SQL_WITH_RECURSIVE;
             } else {
5535                return this._super(arguments);
             }
         },
 
         _updateFromSql:function () {
206            return this._joinFromSql("FROM");
         },
 
         _updateTableSql:function () {
206            return [this._static.SPACE, this._sourceList(this.__opts.from.slice(0, 1))].join("");
         },
 
         _quotedIdentifier:function (c) {
25470            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 () {
2626            var args = arguments;
2626            if (this.__opts.returning) {
1313                return this._super(arguments);
             } else {
1313                var ret = new Promise();
1313                this.primaryKey(this.__opts.from).then(function (res) {
1313                    var pks = res.map(function (r) {
1147                        return r.name;
                     });
1313                    var ds = this.returning.apply(this, pks);
1313                    var dsPromise = ds.insert.apply(ds, args), l = res.length;
1313                    if (l) {
1147                        dsPromise.then(function (insertRes) {
1147                            if (l === 1) {
1147                                ret.callback(insertRes.map(function (i) {
1147                                    return i[pks[0]];
                                 }).pop());
                             } else {
0                                ret.callback(insertRes.pop());
                             }
 
                         }, ret);
                     } else {
166                        dsPromise.then(ret);
                     }
                 }.bind(this), ret);
1313                return ret.promise();
             }
         },
 
         primaryKey:function () {
1313            return this.db.primaryKey(this.__opts.from[0]);
         },
 
         fetchRows:function (sql) {
3059            var oi = this.outputIdentifier.bind(this);
3059            return asyncArray(this.execute(sql).chain(function (rows, fields) {
3059                var cols = [];
3059                if (rows && rows.length) {
2563                    cols = this.__columns = fields && fields.length ? fields.map(function (f) {
19239                        return f.name;
                     }) : Object.keys(rows[0]);
                     //the pg driver does auto type coercion
2563                    cols = cols.map(function (c) {
19239                        return [oi(c), function (o) {
28729                            return o;
                         }, c];
                     }, this);
                 }
3059                return this.__processRows(rows, cols);
             }.bind(this)));
         },
 
         __processRows:function (rows, cols) {
             //dp this so the callbacks are called in appropriate order also.
3059            return comb(rows).map(function (row, i) {
3673                var h = {};
3673                cols.forEach(function (col) {
28729                    h[col[0]] = col[1](row[col[2]]);
                 });
3673                return h;
             });
         },
 
 
         _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 = new Promise();
6                if (this.__columns) {
0                    ret.callback(this.__columns);
                 } else {
6                    this.db.schema(this.firstSourceTable).then(function (schema) {
6                        this.__columns = schema ? Object.keys(schema) : [];
6                        ret.callback(this.__columns);
                     }, ret);
                 }
6                return ret.promise();
             },
 
             supportsCteInSubqueries:function () {
0                return true;
             },
 
             supportsDistinctOn:function () {
12697                return true;
             },
 
             supportsModifyingJoins:function () {
15178                return true;
             },
 
             supportsTimestampTimezones:function () {
12695                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("''")
 
 
     }
 });
 
1var DB = define(Database, {
     instance:{
 
         EXCLUDE_SCHEMAS:/pg_*|information_schema/i,
         PREsPARED_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 () {
34            this._super(arguments);
34            this.__primaryKeys = {};
         },
 
         createConnection:function (opts) {
64            delete opts.query;
64            var conn = new pg.Client(merge({}, opts, {typeCast:false}));
64            conn.connect();
             //conn.useDatabase(opts.database)
64            return new Connection(conn);
         },
 
         closeConnection:function (conn) {
64            return conn.closeConnection();
         },
 
         validate:function (conn) {
2181            return new Promise().callback(true).promise();
         },
 
         execute:function (sql, opts, conn) {
5782            return when(conn || this._getConnection())
                 .chain(function (conn) {
5782                return this.__execute(conn, sql, opts);
             }.bind(this));
         },
 
         __execute:function (conn, sql, opts, cb) {
5782            return this.__logAndExecute(sql, comb("query").bindIgnore(conn, sql))
                 .both(comb("_returnConnection").bindIgnore(this, conn));
 
 
         },
 
         // 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            var ret = new Promise();
0            when(this.serverVersion()).then(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(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                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);
                 }).then(function () {
0                        ret.callback(indexes);
                     }, ret);
             }, ret);
 
0            return ret.promise();
         },
 
         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 () {
1            var ret = new Promise();
1            if (!this.__serverVersion) {
1                this.get(identifier("version").sqlFunction).then(hitch(this, function (version) {
1                    var m = version.match(/PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/);
1                    this._serverVersion = (parseInt(m[1], 10) * 10000) + (parseInt(m[2], 10) * 100) + parseInt(m[3], 10);
1                    ret.callback(this._serverVersion);
                 }), ret);
             } else {
0                ret.callback(this._serverVersion);
             }
1            return ret.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) {
1313            var ret, quotedTable = this.__quoteSchemaTable(table).toString(), pks = this.__primaryKeys;
1313            if (pks.hasOwnProperty(quotedTable.toString())) {
1243                ret = pks[quotedTable];
             } else {
70                ret = (pks[quotedTable] = this.__primarykey(table));
             }
1313            return ret.promise();
         },
 
         __primarykey:function (table) {
70            var parts = this.__schemaAndTable(table);
70            var m2 = this.inputIdentifierFunc;
70            var schema = parts[0];
70            table = parts[1];
70            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())]
             ]);
70            if (schema) {
0                ds.filter({pg_namespace__nspname:m2(schema)});
             }
70            return ds.all();
 
         },
 
 
         schemaParseTable:function (tableName, opts) {
65            var m = this.outputIdentifierFunc,
                 m2 = this.inputIdentifierFunc;
65            var ds = this.metadataDataset
                 .select(
                 "pg_attribute__attname___name",
                 sql.format_type("pg_type__oid", "pg_attribute__atttypmod").as(literal('"dbType"')),
                 sql.pg_get_expr("pg_attrdef__adbin", "pg_class__oid").as(literal('"default"')),
                 sql.NOT("pg_attribute__attnotnull").as(literal('"allowNull"')),
                 sql.COALESCE(BooleanExpression.fromValuePairs({pg_attribute__attnum:sql.ANY("pg_index__indkey")}), false).as(literal('"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");
65            ds = this.__filterSchema(ds, opts);
65            var currentSchema = null;
65            return ds.map(function (row) {
374                var sch = row.nspname;
374                delete row.nspname;
374                if (currentSchema) {
309                    if (sch !== currentSchema) {
0                        var error = new Error("columns from two tables were returned please specify a schema");
0                        this.logError(error);
                     }
                 } else {
65                    currentSchema = sch;
                 }
374                if (isBlank(row["default"])) {
313                    row["default"] = null;
                 }
374                row.type = this.schemaColumnType(row.dbType);
374                var fieldName = m(row.name);
374                delete row.name;
374                return [fieldName, row];
 
             }.bind(this));
 
         },
 
         __commitTransaction:function (conn, opts) {
856            opts = opts || {};
856            var s = opts.prepare;
856            if (s && this.__transactionDepth <= 1) {
0                return this.__logConnectionExecute(conn, ["PREPARE TRANSACTION ", this.literal(s)].join(""));
             } else {
856                return this._super(arguments);
             }
         },
 
         //Backbone of the tables and views support.
         __pgClassRelname:function (type, opts, cb) {
0            var ret = new Promise();
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                when(cb(ds)).then(ret);
             } else {
0                ds.map(function (r) {
0                    return m(r.relname);
                 }).then(ret);
             }
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) {
65            opts = opts || {};
65            var schema = opts.schema, ret = ds;
65            if (schema) {
0                ds = ds.filter({pg_namespace__nspname:schema});
             } else {
65                ds = ds.exclude({pg_namespace__nspname:this.EXCLUDE_SCHEMAS});
             }
65            return ds;
         },
 
         __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) {
133            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) {
157            if (column.fixed) {
0                return ["char(", column.size || 255, ")"].join("");
157            } else if (column.text === false || column.size) {
139                return ["varchar(", column.size || 255, ")"].join("");
             } else {
18                return 'text';
             }
 
         },
 
 
         getters:{
 
             connectionExecuteMethod:function () {
1800                return "query";
             },
 
             dataset:function () {
948                return new DS(this);
             },
 
             serialPrimaryKeyOptions:function () {
62                return {primaryKey:true, serial:true, type:"integer"};
             },
 
             supportsSavepoints:function () {
10140                return true;
             },
 
             supportsTransactionIsolationLevels:function () {
900                return true;
             },
 
             identifierInputMethodDefault:function () {
0                return null;
             },
 
             identifierOutputMethodDefault:function () {
0                return null;
             }
         }
     },
 
     "static":{
 
         init:function () {
1            this.setAdapterType("pg");
         }
 
     }
 }).
     as(exports, "PostgresDatabase");

1var comb = require("comb"),
     Promise = comb.Promise,
     PromiseList = comb.PromiseList,
     isFunction = comb.isFunction,
     Queue = comb.collections.Queue,
     merge = comb.merge,
     define = comb.define,
     Pool = comb.collections.Pool;
 
1define(Pool, {
 
     instance:{
         /**@lends patio.ConnectionPool.prototype*/
 
         /**
          * ConnectionPool object used internall by the {@link patio.Database} class;
          * @constructs;
          * @param options
          */
         constructor:function (options) {
122            options = options || {};
122            if (!options.createConnection || !isFunction(options.createConnection)) {
0                throw "patio.adapters.clients.ConnectionPool : create connection CB required.";
             }
122            if (!options.closeConnection || !isFunction(options.closeConnection)) {
0                throw "patio.adapters.clients.ConnectionPool : close connection CB required.";
             }
122            options.minObjects = parseInt(options.minConnections || 0, 10);
122            options.maxObjects = parseInt(options.maxConnections || 10, 10);
122            this.__deferredQueue = new Queue();
122            this._options = options;
122            this.__createConnectionCB = options.createConnection;
122            this.__closeConnectionCB = options.closeConnection;
122            this.__validateConnectionCB = options.validateConnection;
122            this._super(arguments);
         },
 
         /**
          * Checks all deferred connection requests.
          */
         __checkQueries:function () {
2593            var fc = this.freeCount, def, defQueue = this.__deferredQueue;
2593            while (fc-- >= 0 && defQueue.count) {
0                def = defQueue.dequeue();
0                var conn = this.getObject();
0                if (conn) {
0                    def.callback(conn);
                 } else {
                     //we didnt get a conneciton so assume we're out.
0                    break;
                 }
0                fc--;
             }
         },
 
         /**
          * Performs a query on one of the connection in this Pool.
          *
          * @return {comb.Promise} A promise to called back with a connection.
          */
         getConnection:function () {
2597            var ret = new Promise();
             //todo override getObject to make async so creating a connetion can execute setup sql
2597            var conn = this.getObject();
2597            if (!conn) {
                 //we need to deffer it
0                this.__deferredQueue.enqueue(ret);
             } else {
2597                ret.callback(conn);
             }
2597            return ret.promise();
         },
 
         /**
          * Override comb.collections.Pool to allow async validation to allow
          * pools to do any calls to reset a connection if it needs to be done.
          *
          * @param {*} connection the connection to return.
          *
          */
         returnObject:function (obj) {
2593            if (this.count <= this.__maxObjects) {
2593                this.validate(obj).then(function (valid) {
2593                    if (valid) {
2593                        this.__freeObjects.enqueue(obj);
2593                        var index;
2593                        if ((index = this.__inUseObjects.indexOf(obj)) > -1) {
2593                            this.__inUseObjects.splice(index, 1);
                         }
2593                        this.__checkQueries();
                     } else {
0                        this.removeObject(obj);
                     }
                 }.bind(this));
             } else {
0                this.removeObject(obj);
             }
         },
 
         /**
          * Removes a connection from the pool.
          * @param conn
          */
         removeConnection:function (conn) {
0            this.closeConnection(conn);
0            return this.removeObject(conn);
         },
 
         /**
          * Return a connection to the pool.
          *
          * @param {*} connection the connection to return.
          *
          * @return {*} an adapter specific connection.
          */
         returnConnection:function (connection) {
2593            this.returnObject(connection);
         },
 
         createObject:function () {
80            return this.createConnection();
         },
 
         /**
          * Override to implement the closing of all connections.
          *
          * @return {comb.Promise} called when all connections are closed.
          */
         endAll:function () {
41            this.__ending = true;
41            var conn, fQueue = this.__freeObjects, count = this.count, ps = [];
41            while ((conn = this.__freeObjects.dequeue()) != undefined) {
67                ps.push(this.closeConnection(conn));
             }
41            var inUse = this.__inUseObjects;
41            for (var i = inUse.length - 1; i >= 0; i--) {
4                ps.push(this.closeConnection(inUse[i]));
             }
41            this.__inUseObjects.length = 0;
41            return new PromiseList(ps).promise();
         },
 
 
         /**
          * Override to provide any additional validation. By default the promise is called back with true.
          *
          * @param {*} connection the conneciton to validate.
          *
          * @return {comb.Promise} called back with a valid or invalid state.
          */
         validate:function (conn) {
2593            if (!this.__validateConnectionCB) {
0                var ret = new Promise();
0                ret.callback(true);
0                return ret;
             } else {
2593                return this.__validateConnectionCB();
             }
         },
 
         /**
          * Override to create connections to insert into this ConnectionPool.
          */
         createConnection:function () {
80            return  this.__createConnectionCB(this._options);
         },
 
         /**
          * Override to implement close connection functionality;
          * @param {*} conn the connection to close;
          *
          * @return {comb.Promise} called back when the connection is closed.
          */
         closeConnection:function (conn) {
71            return this.__closeConnectionCB(conn);
         }
     },
 
     "static":{
         /**@lends patio.ConnectionPool*/
 
         getPool:function (opts, createConnection, closeConnection, validateConnection) {
122            return new this(merge(opts, {
                 createConnection:createConnection,
                 closeConnection:closeConnection,
                 validateConnection:validateConnection
             }));
         }
     }
 }).as(module);