Class that is used for querying/retrieving datasets from a database.

Dynamically generated methods include

• Join methods from patio.Dataset.CONDITIONED_JOIN_TYPES and patio.Dataset.UNCONDITIONED_JOIN_TYPES, these methods handle the type call to patio.Dataset#joinTable, so to invoke include all arguments that patio.Dataset#joinTable requires except the type parameter. The default list includes.
  • Conditioned join types that accept conditions.
    • inner - INNER JOIN
    • fullOuter - FULL OUTER
    • rightOuter - RIGHT OUTER JOIN
    • leftOuter - LEFT OUTER JOIN
    • full - FULL JOIN
    • right - RIGHT JOIN
    • left - LEFT JOIN
  • Unconditioned join types that do not accept join conditions
    • natural - NATURAL JOIN
    • naturalLeft - NATURAL LEFT JOIN
    • naturalRight - NATURAL RIGHT JOIN
    • naturalFull - NATURA FULLL JOIN
    • cross - CROSS JOIN

Features:

Features that a particular patio.Dataset supports are shown in the example below. If you wish to implement an adapter please override these values depending on the database that you are developing the adapter for.

         var ds = DB.from("test");

         //The default values returned

         //Whether this dataset quotes identifiers.
         //Whether this dataset quotes identifiers.
         ds.quoteIdentifiers //=>true

         //Whether this dataset will provide accurate number of rows matched for
         //delete and update statements.  Accurate in this case is the number of
         //rows matched by the dataset's filter.
         ds.providesAccurateRowsMatched; //=>true

         //Times Whether the dataset requires SQL standard datetimes (false by default,
         // as most allow strings with ISO 8601 format).
         ds.requiresSqlStandardDate; //=>false

         //Whether the dataset supports common table expressions (the WITH clause).
         ds.supportsCte; //=>true

         //Whether the dataset supports the DISTINCT ON clause, false by default.
         ds.supportsDistinctOn; //=>false

         //Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
         ds.supportsIntersectExcept; //=>true

         //Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default
         ds.supportsIntersectExceptAll; //=>true

         //Whether the dataset supports the IS TRUE syntax.
         ds.supportsIsTrue; //=>true

         //Whether the dataset supports the JOIN table USING (column1, ...) syntax.
         ds.supportsJoinUsing; //=>true

         //Whether modifying joined datasets is supported.
         ds.supportsModifyingJoin; //=>false

         //Whether the IN/NOT IN operators support multiple columns when an
         ds.supportsMultipleColumnIn; //=>true

         //Whether the dataset supports timezones in literal timestamps
         ds.supportsTimestampTimezone; //=>false

         //Whether the dataset supports fractional seconds in literal timestamps
         ds.supportsTimestampUsecs; //=>true

         //Whether the dataset supports window functions.
         ds.supportsWindowFunctions; //=>false
      

Actions

Each dataset does not actually send any query to the database until an action method has been called upon it(with the exception of patio.Dataset#graph because columns from the other table might need retrived in order to set up the graph). Each action returns a comb.Promise that will be resolved with the result or errback, it is important that you account for errors otherwise it can be difficult to track down issues. The list of action methods is:

• patio.Dataset#all
• patio.Dataset#one
• patio.Dataset#avg
• patio.Dataset#count
• patio.Dataset#columns
• patio.Dataset#remove
• patio.Dataset#forEach
• patio.Dataset#empty
• patio.Dataset#first
• patio.Dataset#get
• patio.Dataset#import
• patio.Dataset#insert
• patio.Dataset#save
• patio.Dataset#insertMultiple
• patio.Dataset#saveMultiple
• patio.Dataset#interval
• patio.Dataset#last
• patio.Dataset#map
• patio.Dataset#max
• patio.Dataset#min
• patio.Dataset#multiInsert
• patio.Dataset#range
• patio.Dataset#selectHash
• patio.Dataset#selectMap
• patio.Dataset#selectOrderMap
• patio.Dataset#set
• patio.Dataset#singleRecord
• patio.Dataset#singleValue
• patio.Dataset#sum
• patio.Dataset#toCsv
• patio.Dataset#toHash
• patio.Dataset#truncate
• patio.Dataset#update

 DB.from("table").columns.chain(function(columns){
       // => ["id", "name"]
  });

   DB.from("table").firstSourceAlias;   //=> "table"    DB.from("table___t").firstSourceAlias;   //=> "t" 

   DB.from("table").firstSourceTable;         //=> "table"   DB.from("table___t").firstSourceTable;         //=> "t" 

     DB.from("items").isSimpleSelectAll; //=> true     DB.from("items").filter({a : 1}).isSimpleSelectAll; //=> false 

Constructor

function (db,opts){
   this._super(arguments);
   this.db = db;
   this.__opts = {};
   this.__rowCb = null;
   if (db) {
       this.__quoteIdentifiers = db.quoteIdentifiers;
       this.__identifierInputMethod = db.identifierInputMethod;
       this.__identifierOutputMethod = db.identifierOutputMethod;
   }
           
}
            

__aggregateDataset Function Private

function (){
   return this._optionsOverlap(this._static.COUNT_FROM_SELF_OPTS) ? this.fromSelf() : this.unordered();
           
}
    

__argumentList Function Private

Do a simple join of the arguments (which should be strings) separated by commas

• args :

function (args){
   return args.join(this._static.COMMA_SEPARATOR);
           
}
    

__arrayToConditionSpecifier Function Private

• arr :

  array of elements to make a condition specifier out of

• defaultOp :

  the value to assign a value if one is not provided.

• [[]]

  an array of two element arrays.

function (arr,defaultOp){
   var ret = [];
   arr.forEach(function (a) {
       if (isString(a)) {
           a = this.stringToIdentifier(a);
       }
       if (isInstanceOf(a, Identifier)) {
           ret.push([a, defaultOp]);
       } else if (isHash(a)) {
           ret = ret.concat(array.toArray(a));
       } else {
           throw new QueryError("Invalid condition specifier " + a);
       }
   }, this);
   return ret;
           
}
    

__asSql Function Private

SQL fragment for specifying an alias. expression should already be literalized.

• expression :
• alias :

function (expression,alias){
   return string.format("%s AS %s", expression, this.quoteIdentifier(alias));
           
}
    

__columnList Function Private

Converts an array of column names into a comma seperated string of column names. If the array is empty, a wildcard (*) is returned.

• columns :

function (columns){
   return (!columns || columns.length === 0) ? this._static.WILDCARD : this.__expressionList(columns);
           
}
    

__createBetweenExpression Function Private

ds.__createBetweenExpression({x : [1,2]}) => //=> WHERE ((x >= 1) AND (x <= 10))
ds.__createBetweenExpression({x : [1,2]}, true) => //=> WHERE ((x < 1) OR (x > 10))
        

• obj :

  object where the keys are columns and the values are two element arrays.

• invert? :

  if set to true it inverts the between to make it not between the two values

• patio.sql.BooleanExpression

  a boolean expression containing the between expression.

function (obj,invert){
   var pairs = [];
   for (var i in obj) {
       var v = obj[i];
       if (isArray(v) && v.length) {
           var ident = this.stringToIdentifier(i);
           pairs.push(new BooleanExpression("AND", new BooleanExpression("gte", ident, v[0]), new BooleanExpression("lte", ident, v[1])));
       } else {
           throw new QueryError("Between requires an array for the value");
       }
   }
   var ret = pairs.length === 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
   return invert ? BooleanExpression.invert(ret) : ret;
           
}
    

__createBoolExpression Function Private

Creates a boolean expression that each key is compared to its value using the provided operator.

ds.__createBoolExpression("gt", {x : 1, y:2, z : 5}) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
ds.__createBoolExpression("gt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x > 1) AND (y > 2) AND (z > 5))
ds.__createBoolExpression("lt", {x : 1, y:2, z : 5}) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
ds.__createBoolExpression("lt", [[x, 1], [y,2], [z, 5]) //=> WHERE ((x < 1) AND (y < 2) AND (z < 5))
        

• op :

  valid boolean expression operator to capare each K,V pair with

• obj :

  object or two dimensional array containing key value pairs

• patio.sql.BooleanExpression

  boolean expression joined by a AND of each key value pair compared by the op

function (op,obj){
   var pairs = [];
   if (Expression.isConditionSpecifier(obj)) {
       if (isHash(obj)) {
           obj = array.toArray(obj);
       }
       obj.forEach(function (pair) {
           pairs.push(new BooleanExpression(op, new Identifier(pair[0]), pair[1]));
       });
   }
   return pairs.length === 1 ? pairs[0] : BooleanExpression.fromArgs(["AND"].concat(pairs));
           
}
    

__defaultServerOpts Function Private

• opts :

function (opts){
   return merge({server: this.__opts.server || "default"}, opts || {});
           
}
    

__expressionList Function Private

Converts an array of expressions into a comma separated string of expressions.

• columns :

function (columns){
   return columns.map(this.literal, this).join(this._static.COMMA_SEPARATOR);
           
}
    

__hashIdentifierToName Function Private

• identifier :

  identifier to resolve to a string.

• String

  the string version of the identifier.

function (identifier){
   return isString(identifier) ? this.__hashIdentifierToName(this.stringToIdentifier(identifier)) :
       isInstanceOf(identifier, Identifier) ? identifier.value :
           isInstanceOf(identifier, QualifiedIdentifier) ? identifier.column :
               isInstanceOf(identifier, AliasedExpression) ? identifier.alias : identifier;
           
}
    

__tableRef Function Private

• t :

• SQL fragment specifying a table name.

function (t){
   return isString(t) ? this._quotedIdentifier(t) : this.literal(t);
           
}
    

_addGroupedCondition Function Private

DB.from("items").filter({id, [1,2,3]})._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
     //=> SELECT
              *
          FROM
              items
          WHERE
              ((id IN (1, 2, 3)) AND ((price < 0) OR (price > 10)))
 
DB.from("items")._addGroupedCondition("AND", "OR", [{price: {lt : 0}}, {price: {gt: 10}]).sql;
     //=> SELECT
              *
          FROM
              items
          WHERE
              ((price < 0) OR (price > 10))
        

• addedByBool :
• groupedByBool :
• If String :

  there is an existing where/having clause, this arg will join the new condition group to it. "AND" if undef. Should be "AND" or "OR"

• The String :

  conditions will be joined this. Same expectations as the first param.

• See :

  patio.Dataset#filter.

• patio.Dataset

  a cloned dataset with the condition group added to the WHERE/HAVING clause.

function (addedByBool,groupedByBool){
   groupedByBool = isUndefined(groupedByBool) ? "AND" : groupedByBool;
   var tOpts = this.__opts,
       clause = (tOpts.having ? "having" : "where"),
       clauseObj = tOpts[clause];
   var args = argsToArray(arguments, 2);
   args = args.length === 1 ? args[0] : args;
   var opts = {};
   if (clauseObj) {
       addedByBool = isUndefined(addedByBool) ? "AND" : addedByBool;
       opts[clause] = new BooleanExpression(addedByBool, clauseObj, this._filterExpr(args, null, groupedByBool));
   } else {
       opts[clause] = this._filterExpr(args, null, groupedByBool);
   }
   return this.mergeOptions(opts);
           
}
    

_compoundFromSelf Function Private

Return a [@link patio.sql._Query#fromSelf} dataset if an order or limit is specified, so it works as expected with UNION, EXCEPT, and INTERSECT clauses.

function (){
   var opts = this.__opts;
   return (opts["limit"] || opts["order"]) ? this.fromSelf() : this;
           
}
    

_datasetAlias Function Private

The alias to use for datasets, takes a number to make sure the name is unique.

• number :

function (number){
   return this._static.DATASET_ALIAS_BASE_NAME + number;
           
}
    

_deleteFromSql Function Private

function (){
   return this._selectFromSql();
           
}
    

_deleteOrderSql Function Private

function (){
   return this._selectOrderSql();
           
}
    

_deleteWhereSql Function Private

function (){
   return this._selectWhereSql();
           
}
    

_filter Function Private

• clause :

function (clause){
   var cond = argsToArray(arguments).slice(1), cb;
   if (cond.length && isFunction(cond[cond.length - 1])) {
       cb = cond.pop();
   }
   cond = cond.length === 1 ? cond[0] : cond;
   if ((cond == null || cond === undefined || cond === "") || (isArray(cond) && cond.length === 0 && !cb) || (isObject(cond) && isEmpty(cond) && !cb)) {
       return this.mergeOptions();
   } else {
       cond = this._filterExpr(cond, cb);
       var cl = this.__opts[clause];
       cl && (cond = new BooleanExpression("AND", cl, cond));
       var opts = {};
       opts[clause] = cond;
       return this.mergeOptions(opts);
   }
           
}
    

_filterExpr Function Private

• expr :
• cb :
• joinCond :

function (expr,cb,joinCond){
   expr = (isUndefined(expr) || isNull(expr) || (isArray(expr) && !expr.length)) ? null : expr;
   if (expr && cb) {
       return new BooleanExpression(joinCond || "AND", this._filterExpr(expr, null, joinCond), this._filterExpr(cb, null, joinCond));
   } else if (cb) {
       expr = cb;
   }
   if (isInstanceOf(expr, Expression)) {
       if (isInstanceOf(expr, NumericExpression, StringExpression)) {
           throw new QueryError("Invalid SQL Expression type : " + expr);
       }
       return expr;
   } else if (isArray(expr)) {
       if (expr.length) {
           var first = expr[0];
           if (isString(first)) {
               return new PlaceHolderLiteralString(first, expr.slice(1), true);
           } else if (Expression.isConditionSpecifier(expr)) {
               return BooleanExpression.fromValuePairs(expr, joinCond);
           } else {
               return BooleanExpression.fromArgs([joinCond || "AND"].concat(expr.map(function (e) {
                   return this._filterExpr(e, null, "AND");
               }, this)));
           }
       }
   } else if (isFunction(expr)) {
       return this._filterExpr(expr.call(sql, sql), null, joinCond);
   } else if (isBoolean(expr)) {
       return new BooleanExpression("NOOP", expr);
   } else if (isString(expr)) {
       return this.stringToIdentifier(expr);
   } else if (isInstanceOf(expr, LiteralString)) {
       return new LiteralString("(" + expr + ")");
   } else if (isHash(expr)) {
       return BooleanExpression.fromValuePairs(expr, joinCond);
   } else {
       throw new QueryError("Invalid filter argument");
   }
           
}
    

_invertOrder Function Private

• order :

function (order){
   var ret = order;
   if (order) {
       ret = order.map(function (o) {
           if (isInstanceOf(o, OrderedExpression)) {
               return o.invert();
           } else {
               return new OrderedExpression(isString(o) ? new Identifier(o) : o);
           }
       }, this);
   }
   return ret;
           
}
    

_joinTypeSql Function Private

SQL fragment specifying a JOIN type, splits a camelCased join type and converts to uppercase/

• joinType :

function (joinType){
   return (joinType || "").replace(/([a-z]+)|([A-Z][a-z]+)/g, function (m) {
           return m.toUpperCase() + " ";
       }).trimRight() + " JOIN";
           
}
    

_literalArray Function Private

• v :

• SQL fragment for Array. Treats as an expression if an array of all two pairs, or as a SQL array otherwise.

function (v){
   return Expression.isConditionSpecifier(v) ? this._literalExpression(BooleanExpression.fromValuePairs(v)) : this._arraySql(v);
           
}
    

_literalBoolean Function Private

• b :

• SQL fragment for a boolean.

function (b){
   return b ? this._static.BOOL_TRUE : this._static.BOOL_FALSE;
           
}
    

_literalBuffer Function Private

• b :

• SQL fragment for Buffer, treated as an expression

function (b){
   return "X'" + b.toString("hex") + "'";
           
}
    

_literalDataset Function Private

• dataset :

• SQL fragment for Dataset. Does a subselect inside parantheses.

function (dataset){
   return string.format("(%s)", this._subselectSql(dataset));
           
}
    

_literalDate Function Private

• date :

• SQL fragment for Date, using the ISO8601 format.

function (date){
   return (this.requiresSqlStandardDateTimes ? "DATE '" : "'") + patio.dateToString(date) + "'";
           
}
    

_literalExpression Function Private

• v :

• SQL fragment for SQL::Expression, result depends on the specific type of expression.

function (v){
   return v.toString(this);
           
}
    

_literalHash Function Private

• v :

• SQL fragment for Hash, treated as an expression

function (v){
   return this._literalExpression(BooleanExpression.fromValuePairs(v));
           
}
    

_literalJson Function Private

• v :

• SQL fragment for json. Doubles ' by default.

function (v){
   throw new QueryError("Json not supported.");
           
}
    

_literalNull Function Private

• SQL fragment for null

function (){
   return this._static.NULL;
           
}
    

_literalNumber Function Private

• num :

• SQL fragment for a number.

function (num){
   var ret = "" + num;
   if (isNaN(num) || num === Infinity) {
       ret = string.format("'%s'", ret);
   }
   return ret;
           
}
    

_literalObject Function Private

• v :

• SQL fragment for Hash, treated as an expression

function (v){
   return this._literalExpression(BooleanExpression.fromValuePairs(v));
           
}
    

_literalOther Function Private

• v :

• SQL fragment for a type of object not handled by patio.dataset._Sql#literal. If object has a method sqlLiteral then it is called with this dataset as the first argument, otherwise raises an error. Classes implementing sqlLiteral should call a class-specific method on the dataset provided and should add that method to patio.dataset.Dataset, allowing for adapters to provide customized literalizations. If a database specific type is allowed, this should be overriden in a subclass.

function (v){
   if (isFunction(v.sqlLiteral)) {
       return v.sqlLiteral(this);
   } else {
       throw new QueryError(string.format("can't express %j as a SQL literal", [v]));
   }
           
}
    

_literalString Function Private

• v :

• SQL fragment for String. Doubles \ and ' by default.

function (v){
   var parts = this._splitString(v);
   var table = parts[0], column = parts[1], alias = parts[2], ret;
   if (!alias) {
       if (column && table) {
           ret = this._literalExpression(QualifiedIdentifier.fromArgs([table, column]));
       } else {
           ret = "'" + v.replace(/\\/g, "\\\\").replace(/'/g, "''") + "'";
       }
   } else {
       if (column && table) {
           ret = new AliasedExpression(QualifiedIdentifier.fromArgs([table, column]), alias);
       } else {
           ret = new AliasedExpression(new Identifier(column), alias);
       }
       ret = this.literal(ret);
   }
   return ret;
           
}
    

_literalTime Function Private

• v :

• SQL fragment for a timestamp, using the ISO8601 format.

function (v){
   return this.formatTimestamp(v, this._static.TIME_FORMAT);
           
}
    

_literalTimestamp Function Private

• v :

• SQL fragment for a timestamp, using the ISO8601 format.

function (v){
   return this.formatTimestamp(v, this._static.TIMESTAMP_FORMAT);
           
}
    

_literalYear Function Private

• o :

• SQL fragment for a year.

function (o){
   return patio.dateToString(o, this._static.YEAR_FORMAT);
           
}
    

_optionsOverlap Function Private

Return true if the dataset has a non-null value for any key in opts.

• opts :

  the options to compate this datasets options to

• Boolean

  true if the dataset has a non-null value for any key in opts.

function (opts){
   var o = [];
   for (var i in this.__opts) {
       if (!isUndefinedOrNull(this.__opts[i])) {
           o.push(i);
       }
   }
   return intersect(compact(o), opts).length !== 0;
           
}
    

_qualifiedExpression Function Private

Qualify the given expression to the given table.

• e :
• table :

  the table to qualify the expression to

• column patio.sql.Expression :

  the expression to qualify

function (e,table){
   var h, i, args;
   if (isString(e)) {
       //this should not be hit but here just for completeness
       return this.stringToIdentifier(e);
   } else if (isArray(e)) {
       return e.map(function (exp) {
           return this._qualifiedExpression(exp, table);
       }, this);
   } else if (isInstanceOf(e, Identifier)) {
       return new QualifiedIdentifier(table, e);
   } else if (isInstanceOf(e, OrderedExpression)) {
       return new OrderedExpression(this._qualifiedExpression(e.expression, table), e.descending,
           {nulls: e.nulls});
   } else if (isInstanceOf(e, AliasedExpression)) {
       return new AliasedExpression(this._qualifiedExpression(e.expression, table), e.alias);
   } else if (isInstanceOf(e, CaseExpression)) {
       args = [this._qualifiedExpression(e.conditions, table), this._qualifiedExpression(e.def, table)];
       if (e.hasExpression) {
           args.push(this._qualifiedExpression(e.expression, table));
       }
       return CaseExpression.fromArgs(args);
   } else if (isInstanceOf(e, Cast)) {
       return new Cast(this._qualifiedExpression(e.expr, table), e.type);
   } else if (isInstanceOf(e, SQLFunction)) {
       return SQLFunction.fromArgs([e.f].concat(this._qualifiedExpression(e.args, table)));
   } else if (isInstanceOf(e, ComplexExpression)) {
       return ComplexExpression.fromArgs([e.op].concat(this._qualifiedExpression(e.args, table)));
   } else if (isInstanceOf(e, SubScript)) {
       return new SubScript(this._qualifiedExpression(e.f, table), this._qualifiedExpression(e.sub, table));
   } else if (isInstanceOf(e, PlaceHolderLiteralString)) {
       args = [];
       var eArgs = e.args;
       if (isHash(eArgs)) {
           h = {};
           for (i in eArgs) {
               h[i] = this._qualifiedExpression(eArgs[i], table);
           }
           args = h;
       } else {
           args = this._qualifiedExpression(eArgs, table);
       }
       return new PlaceHolderLiteralString(e.str, args, e.parens);
   } else if (isHash(e)) {
       h = {};
       for (i in e) {
           h[this._qualifiedExpression(i, table) + ""] = this._qualifiedExpression(e[i], table);
       }
       return h;
   } else {
       return e;
   }
           
}
    

_selectColumnsSql Function Private

• the columns selected

function (){
   return " " + this.__columnList(this.__opts.select);
           
}
    

_selectCompoundsSql Function Private

• the EXCEPT, INTERSECT, or UNION clause. This uses a subselect for the compound datasets used, because using parantheses doesn't work on all databases.

function (){
   var opts = this.__opts, compounds = opts.compounds, ret = [];
   if (compounds) {
       compounds.forEach(function (c) {
           var type = c[0], dataset = c[1], all = c[2];
           ret.push(string.format(" %s%s %s", type.toUpperCase(), all ? " ALL" : "", this._subselectSql(dataset)));
       }, this);
   }
   return ret.join("");
           
}
    

_selectDistinctSql Function Private

• the DISTINCT clause.

function (){
   var distinct = this.__opts.distinct, ret = [];
   if (distinct) {
       ret.push(" DISTINCT");
       if (distinct.length) {
           ret.push(format(" ON (%s)", this.__expressionList(distinct)));
       }
   }
   return ret.join("");
           
}
    

_selectFromSql Function Private

• the sql to add the list of tables to select FROM

function (){
   var from = this.__opts.from;
   return from ? string.format(" %s%s", this._static.FROM, this._sourceList(from)) : "";
           
}
    

_selectGroupSql Function Private

• the GROUP BY clause

function (){
   var group = this.__opts.group;
   return group ? string.format(" GROUP BY %s", this.__expressionList(group)) : "";
           
}
    

_selectHavingSql Function Private

• the sql to add the filter criteria in the HAVING clause

function (){
   var having = this.__opts.having;
   return having ? string.format(" HAVING %s", this.literal(having)) : "";
           
}
    

_selectJoinSql Function Private

• the JOIN clause.

function (){
   var join = this.__opts.join, ret = [];
   if (join) {
       join.forEach(function (j) {
           ret.push(this.literal(j));
       }, this);
   }
   return ret.join("");
           
}
    

_selectLimitSql Function Private

• the LIMIT and OFFSET clauses.

function (){
   var ret = [], limit = this.__opts.limit, offset = this.__opts.offset;
   !isUndefined(limit) && !isNull(limit) && (ret.push(format(" LIMIT %s", this.literal(limit))));
   !isUndefined(offset) && !isNull(offset) && (ret.push(format(" OFFSET %s", this.literal(offset))));
   return ret.join("");
           
}
    

_selectLockSql Function Private

• SQL for different locking modes.

function (){
   var lock = this.__opts.lock, ret = [];
   if (lock) {
       if (lock === "update") {
           ret.push(this._static.FOR_UPDATE);
       } else {
           ret.push(" ", lock);
       }
   }
   return ret.join("");
           
}
    

_selectOrderSql Function Private

• the SQL ORDER BY clause fragment.

function (){
   var order = this.__opts.order;
   return order ? string.format(" ORDER BY %s", this.__expressionList(order)) : "";
           
}
    

_selectWhereSql Function Private

• the SQL WHERE clause fragment.

function (){
   var where = this.__opts.where;
   return where ? string.format(" WHERE %s", this.literal(where)) : "";
           
}
    

_selectWithSql Function Private

• sql :

• SQL WITH clause fragment.

function (sql){
   var wit = this.__opts["with"];
   if (wit && wit.length) {
       //sql.length = 0;
       var base = sql.join("");
       sql.length = 0;
       sql.push([this._selectWithSqlBase(), wit.map(function (w) {
           return [
               this.quoteIdentifier(w.name),
               (w.args ? ("(" + this.__argumentList(w.args) + ")") : ""),
               " AS ",
               this._literalDataset(w.dataset)
           ].join("");
       }, this).join(this._static.COMMA_SEPARATOR), base].join(" "));
   }
           
}
    

_selectWithSqlBase Function Private

• The base keyword to use for the SQL WITH clause

function (){
   return this._static.SQL_WITH;
           
}
    

_sourceList Function Private

Converts an array of source names into into a comma separated list.

• source :

function (source){
   if (!Array.isArray(source)) {
       source = [source];
   }
   if (!source || !source.length) {
       throw new QueryError("No source specified for the query");
   }
   return " " + source.map(
           function (s) {
               return this.__tableRef(s);
           }, this).join(this._static.COMMA_SEPARATOR);
           
}
    

_splitAlias Function Private

Splits a possible implicit alias, handling both patio.sql.AliasedExpressions and strings. Returns an array of two elements, with the first being the main expression, and the second being the alias. Alias may be null if it is a string that does not contain an alias {table}_{alias}.

• c :

function (c){
   var ret;
   if (isInstanceOf(c, AliasedExpression)) {
       ret = [c.expression, c.alias];
   } else if (isString(c)) {
       var parts = this._splitString(c), cTable = parts[0], column = parts[1], alias = parts[2];
       if (alias) {
           ret = [cTable ? new QualifiedIdentifier(cTable, column) : column, alias];
       } else {
           ret = [c, null];
       }
   } else {
       ret = [c, null];
   }
   return ret;
           
}
    

_splitString Function Private

Can either be a string or null.

//columns
 table__column___alias //=> table.column as alias
 table__column //=> table.column
 //tables
 schema__table___alias //=> schema.table as alias
 schema__table //=> schema.table
 
//name and alias
columnOrTable___alias //=> columnOrTable as alias
        

• s :

• String[]

  an array with the elements being:

  • For columns :[table, column, alias].
  • For tables : [schema, table, alias].

function (s){
   var ret, m;
   if ((m = s.match(this._static.COLUMN_REF_RE1)) !== null) {
       ret = m.slice(1);
   }
   else if ((m = s.match(this._static.COLUMN_REF_RE2)) !== null) {
       ret = [null, m[1], m[2]];
   }
   else if ((m = s.match(this._static.COLUMN_REF_RE3)) !== null) {
       ret = [m[1], m[2], null];
   }
   else {
       ret = [null, s, null];
   }
   return ret;
           
}
    

_staticSql Function Private

• sql :

• SQL to use if this dataset uses static SQL. Since static SQL can be a PlaceholderLiteralString in addition to a String, we literalize nonstrings.

function (sql){
   return isString(sql) ? sql : this.literal(sql);
           
}
    

_subselectSql Function Private

• ds :

• SQL fragment for a subselect using the given database's SQL.

function (ds){
   return ds.sql;
           
}
    

_toTableName Function Private

Returns a string that is the name of the table.

• name :

  the object to get the table name from.

• String

  the name of the table.

• patio.QueryError

  If the name is not a String patio.sql.Identifier, patio.sql.QualifiedIdentifier or patio.sql.AliasedExpression.

function (name){
   var ret;
   if (isString(name)) {
       var parts = this._splitString(name);
       var schema = parts[0], table = parts[1], alias = parts[2];
       ret = (schema || alias) ? alias || table : table;
   } else if (isInstanceOf(name, Identifier)) {
       ret = name.value;
   } else if (isInstanceOf(name, QualifiedIdentifier)) {
       ret = this._toTableName(name.column);
   } else if (isInstanceOf(name, AliasedExpression)) {
       ret = this.__toAliasedTableName(name.alias);
   } else {
       throw new QueryError("Invalid object to retrieve the table name from");
   }
   return ret;
           
}