2013-03-19 20:28:03 -04:00
<!DOCTYPE html>
< html >
< head >
< title > knex.js< / title >
< meta http-equiv = "content-type" content = "text/html; charset=UTF-8" >
< meta name = "viewport" content = "width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;" >
< link rel = "stylesheet" media = "all" href = "docco.css" / >
< / head >
< body >
< div id = "container" >
< div id = "background" > < / div >
< ul class = "sections" >
< li id = "title" >
< div class = "annotation" >
< h1 > knex.js< / h1 >
< / div >
< / li >
< li id = "section-1" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-1" > ¶ < / a >
< / div >
< pre > < code > Knex.js 0.1.0
2013-03-12 11:52:08 -04:00
(c) 2013 Tim Griesser
Bookshelf may be freely distributed under the MIT license.
For details and documentation:
2013-03-19 20:28:03 -04:00
http://knexjs.org< / code > < / pre >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > (< span class = "keyword" > function< / span > () {
< span class = "string" > "use strict"< / span > ;< / pre > < / div > < / div >
< / li >
< li id = "section-2" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-2" > ¶ < / a >
< / div >
< p > Required dependencies.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > _ = require(< span class = "string" > 'underscore'< / span > );
< span class = "keyword" > var< / span > Q = require(< span class = "string" > 'q'< / span > );< / pre > < / div > < / div >
< / li >
< li id = "section-3" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-3" > ¶ < / a >
< / div >
< p > < code > Knex< / code > is the root namespace and a chainable function where
< code > Knex(' tableName' )< / code > is shorthand for < code > new Knex.Builder(' tableName' )< / code >
or < code > new Knex.Builder().from(' tableName' )< / code > .< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Knex = < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > return< / span > < span class = "keyword" > new< / span > Knex.Builder(table);
};< / pre > < / div > < / div >
< / li >
< li id = "section-4" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-4" > ¶ < / a >
< / div >
< p > Default client paths, located in the < code > ./clients< / code > directory.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Clients = {
< span class = "string" > 'mysql'< / span > : < span class = "string" > './clients/mysql.js'< / span > ,
< span class = "string" > 'postgres'< / span > : < span class = "string" > './clients/postgres.js'< / span > ,
< span class = "string" > 'sqlite3'< / span > : < span class = "string" > './clients/sqlite3.js'< / span >
};
< span class = "keyword" > var< / span > push = Array.prototype.push;< / pre > < / div > < / div >
< / li >
< li id = "section-5" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-5" > ¶ < / a >
< / div >
< p > Keep in sync with package.json< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > Knex.VERSION = < span class = "string" > '0.0.0'< / span > ;< / pre > < / div > < / div >
< / li >
< li id = "section-6" >
< div class = "annotation" >
< div class = "pilwrap for-h2" >
< a class = "pilcrow" href = "#section-6" > ¶ < / a >
< / div >
< h2 > Knex.Initialize< / h2 >
< / div >
< / li >
< li id = "section-7" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-7" > ¶ < / a >
< / div >
< / div >
< / li >
< li id = "section-8" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-8" > ¶ < / a >
< / div >
< p > Takes a hash of options to initialize the database
2013-03-12 11:52:08 -04:00
connection. The < code > client< / code > is required to choose which client
path above is loaded, or to specify a custom path to a client.
Other options, such as < code > connection< / code > or < code > pool< / code > are passed
2013-03-19 20:28:03 -04:00
into < code > client.initialize< / code > .< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > Knex.Initialize = < span class = "keyword" > function< / span > (options) {
options || (options = {});
< span class = "keyword" > var< / span > client = options.client;
< span class = "keyword" > if< / span > (!client) {
< span class = "keyword" > throw< / span > < span class = "keyword" > new< / span > Error(< span class = "string" > 'The client is required to use Knex.'< / span > );
}< / pre > < / div > < / div >
< / li >
< li id = "section-9" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-9" > ¶ < / a >
< / div >
< p > Checks if this is a default client. If it' s not,
require it as the path to the client if it' s a string,
and otherwise, set the object to the client.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > if< / span > (Clients[client]) {
Knex.client = require(Clients[client]);
} < span class = "keyword" > else< / span > {
< span class = "keyword" > if< / span > (_.isString(client)) {
Knex.client = require(client);
} < span class = "keyword" > else< / span > {
Knex.client = client;
}
}
Knex.client.initialize(options);
};< / pre > < / div > < / div >
< / li >
< li id = "section-10" >
< div class = "annotation" >
< div class = "pilwrap for-h2" >
< a class = "pilcrow" href = "#section-10" > ¶ < / a >
< / div >
< h2 > Knex.Grammar< / h2 >
< / div >
< / li >
< li id = "section-11" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-11" > ¶ < / a >
< / div >
< p > Creates a new Grammar, with the mixins for the
2013-03-12 11:52:08 -04:00
specified query dialect, which are defined in each
2013-03-19 20:28:03 -04:00
client' s < code > exports.grammar< / code > .< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Grammar = Knex.Grammar = < span class = "keyword" > function< / span > (mixins) {
_.extend(< span class = "keyword" > this< / span > , mixins);
};< / pre > < / div > < / div >
< / li >
< li id = "section-12" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-12" > ¶ < / a >
< / div >
< p > The list of different components< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > components = [
< span class = "string" > 'aggregate'< / span > , < span class = "string" > 'columns'< / span > , < span class = "string" > 'from'< / span > ,
< span class = "string" > 'joins'< / span > , < span class = "string" > 'wheres'< / span > , < span class = "string" > 'groups'< / span > , < span class = "string" > 'havings'< / span > ,
< span class = "string" > 'orders'< / span > , < span class = "string" > 'limit'< / span > , < span class = "string" > 'offset'< / span >
];
Grammar.prototype = {
tablePrefix: < span class = "string" > ''< / span > ,
dateFormat: < span class = "string" > 'Y-m-d H:i:s'< / span > ,< / pre > < / div > < / div >
< / li >
< li id = "section-13" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-13" > ¶ < / a >
< / div >
< p > Compiles the < code > select< / code > statement, or nested sub-selects
by calling each of the component compilers, trimming out
the empties, and returning a generated query string.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileSelect: < span class = "keyword" > function< / span > (qb) {
< span class = "keyword" > if< / span > (_.isEmpty(qb.columns)) qb.columns = [< span class = "string" > '*'< / span > ];
< span class = "keyword" > var< / span > sql = {};
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = components.length; i < l; i++) {
< span class = "keyword" > var< / span > component = components[i];
< span class = "keyword" > if< / span > (_.result(qb, component) != < span class = "literal" > null< / span > ) {
sql[component] = < span class = "keyword" > this< / span > [< span class = "string" > 'compile'< / span > + capitalize(component)](qb, _.result(qb, component));
}
}
< span class = "keyword" > return< / span > _.compact(sql).join(< span class = "string" > ' '< / span > );
},< / pre > < / div > < / div >
< / li >
< li id = "section-14" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-14" > ¶ < / a >
< / div >
< p > Compiles an aggregate query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileAggregate: < span class = "keyword" > function< / span > (qb, aggregate) {
< span class = "keyword" > var< / span > column = < span class = "keyword" > this< / span > .columnize(aggregate.columns);
< span class = "keyword" > if< / span > (qb.isDistinct & & column !== < span class = "string" > '*'< / span > ) {
column = < span class = "string" > 'distinct '< / span > + column;
}
< span class = "keyword" > return< / span > < span class = "string" > 'select '< / span > + aggregate.type + < span class = "string" > '('< / span > + column + < span class = "string" > ') as aggregate'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-15" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-15" > ¶ < / a >
< / div >
< p > Compiles the columns in the query, specifying if an item was distinct.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileColumns: < span class = "keyword" > function< / span > (qb, columns) {
< span class = "keyword" > if< / span > (qb.aggregate != < span class = "literal" > null< / span > ) < span class = "keyword" > return< / span > ;
< span class = "keyword" > return< / span > (qb.isDistinct ? < span class = "string" > 'select distinct '< / span > : < span class = "string" > 'select '< / span > ) + < span class = "keyword" > this< / span > .columnize(columns);
},< / pre > < / div > < / div >
< / li >
< li id = "section-16" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-16" > ¶ < / a >
< / div >
< p > Compiles the < code > from< / code > tableName portion of the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileFrom: < span class = "keyword" > function< / span > (qb, table) {
< span class = "keyword" > return< / span > < span class = "string" > 'from '< / span > + < span class = "keyword" > this< / span > .wrapTable(table);
},< / pre > < / div > < / div >
< / li >
< li id = "section-17" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-17" > ¶ < / a >
< / div >
< p > Compiles all each of the < code > join< / code > clauses on the query,
including any nested join queries.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileJoins: < span class = "keyword" > function< / span > (qb, joins) {
< span class = "keyword" > var< / span > sql = [];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = joins.length; i < l; i++) {
< span class = "keyword" > var< / span > join = joins[i];
< span class = "keyword" > var< / span > clauses = [];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i2 = < span class = "number" > 0< / span > , l2 = join.clauses.length; i2 < l2; i2++) {
< span class = "keyword" > var< / span > clause = join.clauses[i2];
clauses.push(
[clause[< span class = "string" > 'bool'< / span > ], < span class = "keyword" > this< / span > .wrap(clause[< span class = "string" > 'first'< / span > ]), clause.operator, < span class = "keyword" > this< / span > .wrap(clause[< span class = "string" > 'second'< / span > ])].join(< span class = "string" > ' '< / span > )
);
}
clauses[< span class = "number" > 0< / span > ] = clauses[< span class = "number" > 0< / span > ].replace(< span class = "regexp" > /and |or /< / span > , < span class = "string" > ''< / span > );
sql.push(join.type + < span class = "string" > ' join '< / span > + < span class = "keyword" > this< / span > .wrapTable(join.table) + < span class = "string" > ' on '< / span > + clauses.join(< span class = "string" > ' '< / span > ));
}
< span class = "keyword" > return< / span > sql.join(< span class = "string" > ' '< / span > );
},< / pre > < / div > < / div >
< / li >
< li id = "section-18" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-18" > ¶ < / a >
< / div >
< p > Compiles all < code > where< / code > statements on the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileWheres: < span class = "keyword" > function< / span > (qb) {
< span class = "keyword" > var< / span > sql = [];
< span class = "keyword" > var< / span > wheres = qb.wheres;
< span class = "keyword" > if< / span > (wheres.length === < span class = "number" > 0< / span > ) < span class = "keyword" > return< / span > < span class = "string" > ''< / span > ;
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = wheres.length; i < l; i++) {
< span class = "keyword" > var< / span > where = wheres[i];
sql.push(where.bool + < span class = "string" > ' '< / span > + < span class = "keyword" > this< / span > [< span class = "string" > 'where'< / span > + where.type](qb, where));
}
< span class = "keyword" > return< / span > (sql.length > < span class = "number" > 0< / span > ? < span class = "string" > 'where '< / span > + sql.join(< span class = "string" > ' '< / span > ).replace(< span class = "regexp" > /and |or /< / span > , < span class = "string" > ''< / span > ) : < span class = "string" > ''< / span > );
},< / pre > < / div > < / div >
< / li >
< li id = "section-19" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-19" > ¶ < / a >
< / div >
< p > Compiles a nested where clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNested: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "string" > '('< / span > + < span class = "keyword" > this< / span > .compileWheres(where.query).slice(< span class = "number" > 6< / span > ) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-20" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-20" > ¶ < / a >
< / div >
< p > Compiles a nested where clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereSub: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' '< / span > + where.operator + < span class = "string" > ' ('< / span > + (< span class = "keyword" > this< / span > .compileSelect(where.query)) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-21" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-21" > ¶ < / a >
< / div >
< p > Compiles a basic where clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereBasic: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' '< / span > + where.operator + < span class = "string" > ' '< / span > + < span class = "keyword" > this< / span > .parameter(where.value);
},< / pre > < / div > < / div >
< / li >
< li id = "section-22" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-22" > ¶ < / a >
< / div >
< p > Compiles a basic exists clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereExists: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "string" > 'exists ('< / span > + < span class = "keyword" > this< / span > .compileSelect(where.query) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-23" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-23" > ¶ < / a >
< / div >
< p > Compiles a basic not exists clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotExists: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "string" > 'not exists ('< / span > + < span class = "keyword" > this< / span > .compileSelect(where.query) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-24" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-24" > ¶ < / a >
< / div >
< p > Compiles a where in clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereIn: < span class = "keyword" > function< / span > (qb, where) {
2013-04-29 10:44:16 -04:00
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' in ('< / span > + < span class = "keyword" > this< / span > .parameterize(where.value) + < span class = "string" > ')'< / span > ;
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
< li id = "section-25" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-25" > ¶ < / a >
< / div >
< p > Compiles a where not in clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotIn: < span class = "keyword" > function< / span > (qb, where) {
2013-04-29 10:44:16 -04:00
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' not in ('< / span > + < span class = "keyword" > this< / span > .parameterize(where.value) + < span class = "string" > ')'< / span > ;
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
< li id = "section-26" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-26" > ¶ < / a >
< / div >
< p > Compiles a sub-where in clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereInSub: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' in ('< / span > + < span class = "keyword" > this< / span > .compileSelect(where.query) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-27" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-27" > ¶ < / a >
< / div >
< p > Compiles a sub-where not in clause.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotInSub: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' not in ('< / span > + < span class = "keyword" > this< / span > .compileSelect(where.query) + < span class = "string" > ')'< / span > ;
},< / pre > < / div > < / div >
< / li >
< li id = "section-28" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-28" > ¶ < / a >
< / div >
< p > Where between.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereBetween: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' between ? and ?'< / span > ;
},
whereNull: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' is null'< / span > ;
},
whereNotNull: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(where.column) + < span class = "string" > ' is not null'< / span > ;
},
whereRaw: < span class = "keyword" > function< / span > (qb, where) {
< span class = "keyword" > return< / span > where.sql;
},< / pre > < / div > < / div >
< / li >
< li id = "section-29" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-29" > ¶ < / a >
< / div >
< p > Compiles the < code > group by< / code > columns.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileGroups: < span class = "keyword" > function< / span > (qb, groups) {
< span class = "keyword" > return< / span > < span class = "string" > 'group by '< / span > + < span class = "keyword" > this< / span > .columnize(groups);
},< / pre > < / div > < / div >
< / li >
< li id = "section-30" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-30" > ¶ < / a >
< / div >
< p > Compiles the < code > having< / code > statements.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileHavings: < span class = "keyword" > function< / span > (qb, havings) {
< span class = "keyword" > return< / span > < span class = "string" > 'having '< / span > + havings.map(< span class = "keyword" > function< / span > (having) {
< span class = "keyword" > return< / span > < span class = "string" > ''< / span > + < span class = "keyword" > this< / span > .wrap(having.column) + < span class = "string" > ' '< / span > + having.operator + < span class = "string" > ' '< / span > + < span class = "keyword" > this< / span > .parameter(having[< span class = "string" > 'value'< / span > ]);
}, < span class = "keyword" > this< / span > ).join(< span class = "string" > ' and'< / span > ).replace(< span class = "regexp" > /and /< / span > , < span class = "string" > ''< / span > );
},< / pre > < / div > < / div >
< / li >
< li id = "section-31" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-31" > ¶ < / a >
< / div >
< p > Compiles the < code > order by< / code > statements.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileOrders: < span class = "keyword" > function< / span > (qb, orders) {
< span class = "keyword" > if< / span > (orders.length > < span class = "number" > 0< / span > ) {
< span class = "keyword" > return< / span > < span class = "string" > 'order by '< / span > + orders.map(< span class = "keyword" > function< / span > (order) {
< span class = "keyword" > return< / span > < span class = "string" > ''< / span > + < span class = "keyword" > this< / span > .wrap(order.column) + < span class = "string" > ' '< / span > + order.direction;
}, < span class = "keyword" > this< / span > ).join(< span class = "string" > ', '< / span > );
}
},< / pre > < / div > < / div >
< / li >
< li id = "section-32" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-32" > ¶ < / a >
< / div >
< p > Compiles the < code > limit< / code > statements.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileLimit: < span class = "keyword" > function< / span > (qb, limit) {
< span class = "keyword" > return< / span > < span class = "string" > 'limit '< / span > + limit;
},< / pre > < / div > < / div >
< / li >
< li id = "section-33" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-33" > ¶ < / a >
< / div >
< p > Compiles an < code > offset< / code > statement on the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileOffset: < span class = "keyword" > function< / span > (qb, offset) {
< span class = "keyword" > return< / span > < span class = "string" > 'offset '< / span > + offset;
},< / pre > < / div > < / div >
< / li >
< li id = "section-34" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-34" > ¶ < / a >
< / div >
< p > Compiles an < code > insert< / code > query, allowing for multiple
inserts using a single query statement.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileInsert: < span class = "keyword" > function< / span > (qb, values) {
< span class = "keyword" > var< / span > table = < span class = "keyword" > this< / span > .wrapTable(qb.table);
2013-04-29 10:44:16 -04:00
< span class = "keyword" > var< / span > columns = < span class = "keyword" > this< / span > .columnize(_.keys(values[< span class = "number" > 0< / span > ]).sort());
2013-04-11 08:29:11 -04:00
< span class = "keyword" > var< / span > parameters = < span class = "keyword" > this< / span > .parameterize(_.values(values[< span class = "number" > 0< / span > ]));
2013-04-29 10:44:16 -04:00
< span class = "keyword" > var< / span > paramBlocks = [];< / pre > < / div > < / div >
< / li >
< li id = "section-35" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-35" > ¶ < / a >
< / div >
< p > If there are any " where" clauses, we need to omit
any bindings that may have been associated with them.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > if< / span > (qb.wheres.length > < span class = "number" > 0< / span > ) < span class = "keyword" > this< / span > ._clearWhereBindings(qb);
2013-03-19 20:28:03 -04:00
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = values.length; i < l; ++i) {
paramBlocks.push(< span class = "string" > "("< / span > + parameters + < span class = "string" > ")"< / span > );
}
< span class = "keyword" > return< / span > < span class = "string" > "insert into "< / span > + table + < span class = "string" > " ("< / span > + columns + < span class = "string" > ") values "< / span > + paramBlocks.join(< span class = "string" > ', '< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-36" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-36" > ¶ < / a >
< / div >
< p > Depending on the type of < code > where< / code > clause, this will appropriately
remove any binding caused by " where" constraints, allowing the same
query to be used for < code > insert< / code > and < code > update< / code > without issue.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _clearWhereBindings: < span class = "keyword" > function< / span > (qb) {
< span class = "keyword" > var< / span > wheres = qb.wheres;
< span class = "keyword" > var< / span > bindingCount = < span class = "number" > 0< / span > ;
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = wheres.length; i< l; i++) {
< span class = "keyword" > var< / span > where = wheres[i];
< span class = "keyword" > if< / span > (_.isArray(where.value)) {
bindingCount += where.value.length;
} < span class = "keyword" > else< / span > < span class = "keyword" > if< / span > (where.query) {
bindingCount += where.query.bindings.length;
} < span class = "keyword" > else< / span > {
bindingCount += < span class = "number" > 1< / span > ;
}
}
qb.bindings = qb.bindings.slice(bindingCount);
},< / pre > < / div > < / div >
< / li >
< li id = "section-37" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-37" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Compiles an < code > update< / code > query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileUpdate: < span class = "keyword" > function< / span > (qb, values) {
< span class = "keyword" > var< / span > table = < span class = "keyword" > this< / span > .wrapTable(qb.table), columns = [];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > key < span class = "keyword" > in< / span > values) {
< span class = "keyword" > var< / span > value = values[key];
columns.push(< span class = "keyword" > this< / span > .wrap(key) + < span class = "string" > ' = '< / span > + < span class = "keyword" > this< / span > .parameter(value));
}
< span class = "keyword" > return< / span > < span class = "string" > 'update '< / span > + table + < span class = "string" > ' set '< / span > + columns.join(< span class = "string" > ', '< / span > ) + < span class = "string" > ' '< / span > + < span class = "keyword" > this< / span > .compileWheres(qb);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-38" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-38" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Compiles a < code > delete< / code > query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileDelete: < span class = "keyword" > function< / span > (qb) {
< span class = "keyword" > var< / span > table = < span class = "keyword" > this< / span > .wrapTable(qb.table);
< span class = "keyword" > var< / span > where = !_.isEmpty(qb.wheres) ? < span class = "keyword" > this< / span > .compileWheres(qb) : < span class = "string" > ''< / span > ;
< span class = "keyword" > return< / span > < span class = "string" > 'delete from '< / span > + table + < span class = "string" > ' '< / span > + where;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-39" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-39" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Compiles a < code > truncate< / code > query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileTruncate: < span class = "keyword" > function< / span > (qb) {
< span class = "keyword" > return< / span > < span class = "string" > 'truncate '< / span > + < span class = "keyword" > this< / span > .wrapTable(qb.from);
},
wrap: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > var< / span > segments;
< span class = "keyword" > if< / span > (value < span class = "keyword" > instanceof< / span > Knex.Raw) < span class = "keyword" > return< / span > value.value;
< span class = "keyword" > if< / span > (_.isNumber(value)) < span class = "keyword" > return< / span > value;
< span class = "keyword" > if< / span > (value.toLowerCase().indexOf(< span class = "string" > ' as '< / span > ) !== -< span class = "number" > 1< / span > ) {
segments = value.split(< span class = "string" > ' '< / span > );
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrap(segments[< span class = "number" > 0< / span > ]) + < span class = "string" > ' as '< / span > + < span class = "keyword" > this< / span > .wrap(segments[< span class = "number" > 2< / span > ]);
}
< span class = "keyword" > var< / span > wrapped = [];
segments = value.split(< span class = "string" > '.'< / span > );
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = segments.length; i < l; i = ++i) {
value = segments[i];
< span class = "keyword" > if< / span > (i === < span class = "number" > 0< / span > & & segments.length > < span class = "number" > 1< / span > ) {
wrapped.push(< span class = "keyword" > this< / span > .wrapTable(value));
} < span class = "keyword" > else< / span > {
wrapped.push(< span class = "keyword" > this< / span > .wrapValue(value));
}
}
< span class = "keyword" > return< / span > wrapped.join(< span class = "string" > '.'< / span > );
},
wrapArray: < span class = "keyword" > function< / span > (values) {
< span class = "keyword" > return< / span > _.map(values, < span class = "keyword" > this< / span > .wrap, < span class = "keyword" > this< / span > );
},
wrapTable: < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > if< / span > (table < span class = "keyword" > instanceof< / span > Knex.Raw) < span class = "keyword" > return< / span > table.value;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .wrapValue(< span class = "keyword" > this< / span > .tablePrefix + table);
},
columnize: < span class = "keyword" > function< / span > (columns) {
< span class = "keyword" > return< / span > _.map(columns, < span class = "keyword" > this< / span > .wrap, < span class = "keyword" > this< / span > ).join(< span class = "string" > ', '< / span > );
},
parameterize: < span class = "keyword" > function< / span > (values) {
< span class = "keyword" > return< / span > _.map(values, < span class = "keyword" > this< / span > .parameter, < span class = "keyword" > this< / span > ).join(< span class = "string" > ', '< / span > );
},
parameter: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > return< / span > (value < span class = "keyword" > instanceof< / span > Knex.Raw ? value.value : < span class = "string" > '?'< / span > );
}
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-40" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-40" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.Builder< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-41" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-41" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Builder = Knex.Builder = < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > this< / span > .table = table;
< span class = "keyword" > this< / span > .reset();
< span class = "keyword" > this< / span > .grammar = < span class = "keyword" > new< / span > Grammar(Knex.client.grammar);
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-42" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-42" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > All operators used in the < code > where< / code > clause generation.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > operators = [< span class = "string" > '='< / span > , < span class = "string" > '< '< / span > , < span class = "string" > '> '< / span > , < span class = "string" > '< ='< / span > , < span class = "string" > '> ='< / span > , < span class = "string" > 'like'< / span > , < span class = "string" > 'not like'< / span > , < span class = "string" > 'between'< / span > , < span class = "string" > 'ilike'< / span > ];
2013-04-11 08:29:11 -04:00
Builder.prototype = {< / pre > < / div > < / div >
2013-03-19 20:28:03 -04:00
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-43" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-43" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Sets the < code > tableName< / code > on the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > from: < span class = "keyword" > function< / span > (tableName) {
< span class = "keyword" > if< / span > (!tableName) < span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .table;
< span class = "keyword" > this< / span > .table = tableName;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-44" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-44" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > distinct< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > distinct: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .isDistinct = < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-45" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-45" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Clones the current query builder, including any
pieces that have been set thus far< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > clone: < span class = "keyword" > function< / span > () {
< span class = "keyword" > var< / span > item = < span class = "keyword" > new< / span > Builder(< span class = "keyword" > this< / span > .table);
< span class = "keyword" > var< / span > items = [
2013-04-11 08:29:11 -04:00
< span class = "string" > 'isDistinct'< / span > , < span class = "string" > 'joins'< / span > ,
2013-03-19 20:28:03 -04:00
< span class = "string" > 'wheres'< / span > , < span class = "string" > 'orders'< / span > , < span class = "string" > 'columns'< / span > , < span class = "string" > 'bindings'< / span > ,
< span class = "string" > 'grammar'< / span > , < span class = "string" > 'connection'< / span > , < span class = "string" > 'transaction'< / span >
];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = items.length; i < l; i++) {
< span class = "keyword" > var< / span > k = items[i];
item[k] = < span class = "keyword" > this< / span > [k];
}
< span class = "keyword" > return< / span > item;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-46" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-46" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Resets all attributes on the query builder.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > reset: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .joins = [];
< span class = "keyword" > this< / span > .wheres = [];
< span class = "keyword" > this< / span > .orders = [];
< span class = "keyword" > this< / span > .columns = [];
< span class = "keyword" > this< / span > .bindings = [];
< span class = "keyword" > this< / span > .isDistinct = < span class = "literal" > false< / span > ;
2013-04-01 00:50:50 -04:00
},
2013-04-29 10:44:16 -04:00
toJSON: < span class = "keyword" > function< / span > () {
2013-04-01 00:50:50 -04:00
< span class = "keyword" > return< / span > {
joins: < span class = "keyword" > this< / span > .joins,
wheres: < span class = "keyword" > this< / span > .wheres,
order: < span class = "keyword" > this< / span > .orders,
columns: < span class = "keyword" > this< / span > .columns,
bindings: < span class = "keyword" > this< / span > .bindings,
isDistinct: < span class = "keyword" > this< / span > .isDistinct
};
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-47" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-47" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a join clause to the query, allowing for advanced joins
with an anonymous function as the second argument.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > join: < span class = "keyword" > function< / span > (table, first, operator, second, type) {
< span class = "keyword" > var< / span > join;
< span class = "keyword" > if< / span > (_.isFunction(first)) {
type = operator;
join = < span class = "keyword" > new< / span > JoinClause(type || < span class = "string" > 'inner'< / span > , table);
first.call(join, join);
} < span class = "keyword" > else< / span > {
join = < span class = "keyword" > new< / span > JoinClause(type || < span class = "string" > 'inner'< / span > , table);
join.on(first, operator, second);
}
< span class = "keyword" > this< / span > .joins.push(join);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-48" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-48" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > The where function can be used in several ways:
The most basic is < code > where(key, value)< / code > , which expands to
where key = value. < / p >
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
< / div >
< div class = "content" > < div class = 'highlight' > < pre > where: < span class = "keyword" > function< / span > (column, operator, value, bool) {
< span class = "keyword" > var< / span > key;
bool || (bool = < span class = "string" > 'and'< / span > );
< span class = "keyword" > if< / span > (_.isFunction(column)) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._whereNested(column, bool);
}
< span class = "keyword" > if< / span > (_.isObject(column)) {
< span class = "keyword" > for< / span > (key < span class = "keyword" > in< / span > column) {
value = column[key];
< span class = "keyword" > this< / span > [bool + < span class = "string" > 'Where'< / span > ](key, < span class = "string" > '='< / span > , value);
}
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
}
< span class = "keyword" > if< / span > (!_.contains(operators, operator)) {
value = operator;
operator = < span class = "string" > '='< / span > ;
}
< span class = "keyword" > if< / span > (_.isFunction(value)) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._whereSub(column, operator, value, bool);
}
< span class = "keyword" > this< / span > .wheres.push({
type: < span class = "string" > 'Basic'< / span > ,
column: column,
operator: operator,
value: value,
bool: bool
});
< span class = "keyword" > this< / span > .bindings.push(value);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-49" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-49" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Alias to < code > where< / code > , for internal builder consistency.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > andWhere: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .where.apply(< span class = "keyword" > this< / span > , arguments);
},
whereRaw: < span class = "keyword" > function< / span > (sql, bindings, bool) {
bindings || (bindings = []);
bool || (bool = < span class = "string" > 'and'< / span > );
< span class = "keyword" > this< / span > .wheres.push({type:< span class = "string" > 'raw'< / span > , sql:sql, bool:bool});
push.apply(< span class = "keyword" > this< / span > .bindings, bindings);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
orWhereRaw: < span class = "keyword" > function< / span > (sql, bindings) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereRaw(sql, bindings, < span class = "string" > 'or'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-50" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-50" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds an < code > or where< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhere: < span class = "keyword" > function< / span > (column, operator, value) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .where(column, operator, value, < span class = "string" > 'or'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-51" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-51" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where exists< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereExists: < span class = "keyword" > function< / span > (callback, bool, type) {
< span class = "keyword" > var< / span > query = < span class = "keyword" > new< / span > Builder();
query.isSubQuery = < span class = "literal" > true< / span > ;
callback.call(query, query);
< span class = "keyword" > this< / span > .wheres.push({
type: (type || < span class = "string" > 'Exists'< / span > ),
query: query,
bool: (bool || < span class = "string" > 'and'< / span > )
});
push.apply(< span class = "keyword" > this< / span > .bindings, query.bindings);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-52" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-52" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds an < code > or where exists< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereExists: < span class = "keyword" > function< / span > (callback) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereExists(callback, < span class = "string" > 'or'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-53" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-53" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where not exists< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotExists: < span class = "keyword" > function< / span > (callback) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereExists(callback, < span class = "string" > 'and'< / span > , < span class = "string" > 'NotExists'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-54" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-54" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where not exists< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereNotExists: < span class = "keyword" > function< / span > (callback) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereExists(callback, < span class = "string" > 'or'< / span > , < span class = "string" > 'NotExists'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-55" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-55" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where in< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereIn: < span class = "keyword" > function< / span > (column, values, bool, condition) {
bool || (bool = < span class = "string" > 'and'< / span > );
< span class = "keyword" > if< / span > (_.isFunction(values)) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._whereInSub(column, values, bool, < span class = "string" > 'not'< / span > );
}
< span class = "keyword" > this< / span > .wheres.push({
type: (condition || < span class = "string" > 'In'< / span > ),
column: column,
2013-04-29 10:44:16 -04:00
value: values,
2013-03-19 20:28:03 -04:00
bool: bool
});
push.apply(< span class = "keyword" > this< / span > .bindings, values);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-56" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-56" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where in< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereIn: < span class = "keyword" > function< / span > (column, values) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereIn(column, values, < span class = "string" > 'or'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-57" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-57" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where not in< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotIn: < span class = "keyword" > function< / span > (column, values) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereIn(column, values, < span class = "string" > 'and'< / span > , < span class = "string" > 'NotIn'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-58" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-58" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where not in< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereNotIn: < span class = "keyword" > function< / span > (column, values) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereIn(column, values, < span class = "string" > 'or'< / span > , < span class = "string" > 'NotIn'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-59" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-59" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where null< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNull: < span class = "keyword" > function< / span > (column, bool, type) {
< span class = "keyword" > this< / span > .wheres.push({type: (type || < span class = "string" > 'Null'< / span > ), column: column, bool: (bool || < span class = "string" > 'and'< / span > )});
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-60" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-60" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where null< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereNull: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereNull(column, < span class = "string" > 'or'< / span > , < span class = "string" > 'Null'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-61" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-61" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where not null< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereNotNull: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereNull(column, < span class = "string" > 'and'< / span > , < span class = "string" > 'NotNull'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-62" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-62" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where not null< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereNotNull: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .whereNull(column, < span class = "string" > 'or'< / span > , < span class = "string" > 'NotNull'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-63" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-63" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > where between< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > whereBetween: < span class = "keyword" > function< / span > (column, values) {
< span class = "keyword" > this< / span > .wheres.push({column: column, type: < span class = "string" > 'Between'< / span > , bool: < span class = "string" > 'and'< / span > });
push.apply(< span class = "keyword" > this< / span > .bindings, values);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-64" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-64" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > or where between< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orWhereBetween: < span class = "keyword" > function< / span > (column, values) {
< span class = "keyword" > this< / span > .wheres.push({column: column, type: < span class = "string" > 'Between'< / span > , bool: < span class = "string" > 'or'< / span > });
push.apply(< span class = "keyword" > this< / span > .bindings, values);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-65" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-65" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< hr >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-66" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-66" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > group by< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > groupBy: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .groups = < span class = "keyword" > this< / span > .groups.concat(_.toArray(arguments));
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-67" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-67" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > order by< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > orderBy: < span class = "keyword" > function< / span > (column, direction) {
< span class = "keyword" > this< / span > .orders.push({column: column, direction: (direction || < span class = "string" > 'asc'< / span > )});
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-68" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-68" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Adds a < code > having< / code > clause to the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > having: < span class = "keyword" > function< / span > (column, operator, value) {
< span class = "keyword" > this< / span > .havings.push({column: column, operator: (operator || < span class = "string" > ''< / span > ), value: (value || < span class = "string" > ''< / span > )});
< span class = "keyword" > this< / span > .bindings.push(value);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-69" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-69" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< hr >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-70" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-70" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > offset: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > if< / span > (value == < span class = "literal" > null< / span > ) < span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .isOffset;
< span class = "keyword" > this< / span > .isOffset = value;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
limit: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > if< / span > (value == < span class = "literal" > null< / span > ) < span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .isLimit;
< span class = "keyword" > this< / span > .isLimit = value;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-71" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-71" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< hr >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-72" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-72" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Determine if any rows exist for the current query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > exists: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .count().then(< span class = "keyword" > function< / span > (count) {
< span class = "keyword" > return< / span > (count > < span class = "number" > 0< / span > );
});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-73" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-73" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Retrieve the " count" result of the query.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > count: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._aggregate(< span class = "string" > 'count'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-74" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-74" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Retrieve the minimum value of a given column.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > min: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._aggregate(< span class = "string" > 'min'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-75" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-75" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Retrieve the maximum value of a given column.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > max: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._aggregate(< span class = "string" > 'max'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-76" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-76" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Retrieve the sum of the values of a given column.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > sum: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._aggregate(< span class = "string" > 'sum'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-77" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-77" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Increments a column' s value by the specified amount.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > increment: < span class = "keyword" > function< / span > (column, amount) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._counter(column, amount);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-78" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-78" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Decrements a column' s value by the specified amount.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > decrement: < span class = "keyword" > function< / span > (column, amount) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._counter(column, amount, < span class = "string" > '-'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-79" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-79" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Performs a < code > select< / code > query, returning a promise.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > select: < span class = "keyword" > function< / span > (columns) {
< span class = "keyword" > this< / span > .columns = < span class = "keyword" > this< / span > .columns.concat(columns ? (_.isArray(columns) ? columns : _.toArray(arguments)) : < span class = "string" > '*'< / span > );
2013-04-01 00:50:50 -04:00
< span class = "keyword" > if< / span > (!< span class = "keyword" > this< / span > .isSubQuery & & !< span class = "keyword" > this< / span > .isQueryString) {
2013-03-19 20:28:03 -04:00
< span class = "keyword" > return< / span > Knex.runQuery(< span class = "keyword" > this< / span > , {sql: < span class = "keyword" > this< / span > .grammar.compileSelect(< span class = "keyword" > this< / span > ), bindings: < span class = "keyword" > this< / span > ._cleanBindings()});
}
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-80" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-80" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-29 10:44:16 -04:00
< p > Performs an < code > insert< / code > query, returning a promise.< / p >
2013-03-19 20:28:03 -04:00
< / div >
< div class = "content" > < div class = 'highlight' > < pre > insert: < span class = "keyword" > function< / span > (values, returning) {
2013-04-01 00:50:50 -04:00
< span class = "keyword" > if< / span > (!_.isArray(values)) values = values ? [values] : [];
2013-04-29 10:44:16 -04:00
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = values.length; i< l; i++) {
< span class = "keyword" > var< / span > obj = sortObject(values[i]);
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i2 = < span class = "number" > 0< / span > , l2 = obj.length; i2 < l2; i2++) {
< span class = "keyword" > this< / span > .bindings.push(obj[i2][< span class = "number" > 1< / span > ]);
}
2013-03-19 20:28:03 -04:00
}
2013-04-11 08:29:11 -04:00
< span class = "keyword" > var< / span > str = < span class = "keyword" > this< / span > .grammar.compileInsert(< span class = "keyword" > this< / span > , values);
2013-04-01 00:50:50 -04:00
< span class = "keyword" > return< / span > Knex.runQuery(< span class = "keyword" > this< / span > , {sql: str, bindings: < span class = "keyword" > this< / span > ._cleanBindings(), type: < span class = "string" > 'insert'< / span > });
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-81" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-81" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Performs an < code > update< / code > query, returning a promise.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > update: < span class = "keyword" > function< / span > (values) {
< span class = "keyword" > this< / span > .bindings = _.values(values).concat(< span class = "keyword" > this< / span > .bindings);
2013-04-01 00:50:50 -04:00
< span class = "keyword" > return< / span > Knex.runQuery(< span class = "keyword" > this< / span > , {sql: < span class = "keyword" > this< / span > .grammar.compileUpdate(< span class = "keyword" > this< / span > , values), bindings: < span class = "keyword" > this< / span > ._cleanBindings(), type: < span class = "string" > 'update'< / span > });
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-82" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-82" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Executes a delete statement on the query;< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "string" > "delete"< / span > : < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .del();
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-83" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-83" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Alias to delete< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > del: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > Knex.runQuery(< span class = "keyword" > this< / span > , {sql: < span class = "keyword" > this< / span > .grammar.compileDelete(< span class = "keyword" > this< / span > ), bindings: < span class = "keyword" > this< / span > ._cleanBindings()});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-84" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-84" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Truncate< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > truncate: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > Knex.runQuery(< span class = "keyword" > this< / span > , {sql: < span class = "keyword" > this< / span > .grammar.compileTruncate(< span class = "keyword" > this< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-85" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-85" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Set by < code > transacting< / code > - contains the object with the connection
needed to execute a transaction< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > transaction: < span class = "literal" > false< / span > ,< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-86" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-86" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Sets the current Builder connection to that of the
the currently running transaction< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > transacting: < span class = "keyword" > function< / span > (t) {
< span class = "keyword" > this< / span > .transaction = t;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-87" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-87" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< hr >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-88" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-88" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _whereInSub: < span class = "keyword" > function< / span > (column, callback, bool, condition) {
< span class = "keyword" > var< / span > type = condition ? < span class = "string" > 'NotInSub'< / span > : < span class = "string" > 'InSub'< / span > ;
< span class = "keyword" > var< / span > query = < span class = "keyword" > new< / span > Builder();
query.isSubQuery = < span class = "literal" > true< / span > ;
callback.call(query, query);
< span class = "keyword" > this< / span > .wheres.push({type: type, column: column, query: query, bool: bool});
push.apply(< span class = "keyword" > this< / span > .bindings, query.bindings);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
_whereNested: < span class = "keyword" > function< / span > (callback, bool) {
< span class = "keyword" > var< / span > query = < span class = "keyword" > new< / span > Builder();
query.isSubQuery = < span class = "literal" > true< / span > ;
query.table = < span class = "keyword" > this< / span > .table;
callback.call(query, query);
< span class = "keyword" > this< / span > .wheres.push({type: < span class = "string" > 'Nested'< / span > , query: query, bool: bool});
2013-04-29 10:44:16 -04:00
push.apply(< span class = "keyword" > this< / span > .bindings, query.bindings);
2013-03-19 20:28:03 -04:00
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
_whereSub: < span class = "keyword" > function< / span > (column, operator, callback, bool) {
< span class = "keyword" > var< / span > query = < span class = "keyword" > new< / span > Builder();
query.isSubQuery = < span class = "literal" > true< / span > ;
callback.call(query, query);
< span class = "keyword" > this< / span > .wheres.push({
type: < span class = "string" > 'Sub'< / span > ,
column: column,
operator: operator,
query: query,
bool: bool
});
push.apply(< span class = "keyword" > this< / span > .bindings, query.bindings);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
_aggregate: < span class = "keyword" > function< / span > (type, columns) {
< span class = "keyword" > this< / span > .aggregate = {type: type, columns: columns};
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .get(columns);
},
_counter: < span class = "keyword" > function< / span > (column, amount, symbol) {
< span class = "keyword" > var< / span > sql = {};
sql[column] = < span class = "keyword" > new< / span > Knex.Raw(< span class = "string" > ''< / span > + < span class = "keyword" > this< / span > .grammar.wrap(column) + < span class = "string" > ' '< / span > + (symbol || < span class = "string" > '+'< / span > ) + < span class = "string" > ' '< / span > + amount);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .update(sql, callback);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-89" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-89" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Returns all bindings excluding the < code > Knex.Raw< / code > types.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _cleanBindings: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > _.map(< span class = "keyword" > this< / span > .bindings, < span class = "keyword" > function< / span > (binding) {
< span class = "keyword" > return< / span > (binding < span class = "keyword" > instanceof< / span > Knex.Raw ? < span class = "keyword" > void< / span > < span class = "number" > 0< / span > : binding);
});
}
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-90" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-90" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.JoinClause< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-91" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-91" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > JoinClause = Knex.JoinClause = < span class = "keyword" > function< / span > (type, table) {
< span class = "keyword" > this< / span > .clauses = [];
< span class = "keyword" > this< / span > .type = type;
< span class = "keyword" > this< / span > .table = table;
};
JoinClause.prototype = {
on: < span class = "keyword" > function< / span > (first, operator, second) {
< span class = "keyword" > this< / span > .clauses.push({first: first, operator: operator, second: second, bool: < span class = "string" > 'and'< / span > });
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
orOn: < span class = "keyword" > function< / span > (first, operator, second) {
< span class = "keyword" > this< / span > .clauses.push({first: first, operator: operator, second: second, bool: < span class = "string" > 'or'< / span > });
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
}
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-92" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-92" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.Transaction< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-93" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-93" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
2013-04-29 10:44:16 -04:00
< div class = "content" > < div class = 'highlight' > < pre > Knex.Transaction = < span class = "keyword" > function< / span > (container) {< / pre > < / div > < / div >
2013-03-19 20:28:03 -04:00
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-94" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-94" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Initiate a deferred object, so we know when the
transaction completes or fails, we know what to do.< / p >
< / div >
2013-04-29 10:44:16 -04:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > deferred = Q.defer();
Knex.client.beginTransaction(< span class = "keyword" > function< / span > (err, connection) {< / pre > < / div > < / div >
2013-03-19 20:28:03 -04:00
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-95" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-95" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Finish the transaction connection< / p >
< / div >
2013-04-29 10:44:16 -04:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > finish = < span class = "keyword" > function< / span > (type, data) {
connection.end();
< span class = "keyword" > this< / span > .connection = < span class = "literal" > null< / span > ;
deferred[type](data);
};< / pre > < / div > < / div >
2013-03-19 20:28:03 -04:00
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-96" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-96" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Call the container with the transaction
commit & rollback objects< / p >
< / div >
2013-04-29 10:44:16 -04:00
< div class = "content" > < div class = 'highlight' > < pre > container({
commit: < span class = "keyword" > function< / span > (data) {
< span class = "keyword" > var< / span > transaction = < span class = "keyword" > this< / span > ;
Knex.client.commitTransaction(connection, < span class = "keyword" > function< / span > (err) {
< span class = "keyword" > if< / span > (err) < span class = "keyword" > throw< / span > < span class = "keyword" > new< / span > Error(err);
finish.call(transaction, < span class = "string" > 'resolve'< / span > , data);
});
},
rollback: < span class = "keyword" > function< / span > (data) {
< span class = "keyword" > var< / span > transaction = < span class = "keyword" > this< / span > ;
Knex.client.rollbackTransaction(connection, < span class = "keyword" > function< / span > (err) {
< span class = "keyword" > if< / span > (err) < span class = "keyword" > throw< / span > < span class = "keyword" > new< / span > Error(err);
finish.call(transaction, < span class = "string" > 'reject'< / span > , data);
});
},
connection: connection
});
2013-03-19 20:28:03 -04:00
});
< span class = "keyword" > return< / span > deferred.promise;
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-97" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-97" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.Schema< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-98" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-98" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Top level object for Schema related functions< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Schema = Knex.Schema = {};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-99" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-99" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Attach main static methods, which passthrough to the
SchemaBuilder instance methods< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.each([< span class = "string" > 'connection'< / span > , < span class = "string" > 'createTable'< / span > , < span class = "string" > 'dropTable'< / span > , < span class = "string" > 'dropTableIfExists'< / span > , < span class = "string" > 'table'< / span > , < span class = "string" > 'transacting'< / span > ], < span class = "keyword" > function< / span > (method) {
Schema[method] = < span class = "keyword" > function< / span > () {
< span class = "keyword" > var< / span > builder = < span class = "keyword" > new< / span > SchemaBuilder();
< span class = "keyword" > return< / span > builder[method].apply(builder, arguments);
};
});< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-100" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-100" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.SchemaBuilder< / h2 >
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-101" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-101" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > SchemaBuilder = Knex.SchemaBuilder = < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .grammar = < span class = "keyword" > new< / span > Knex.SchemaGrammar(Knex.client.schemaGrammar);
};
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
SchemaBuilder.prototype = {
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
_connection: < span class = "literal" > null< / span > ,
transaction: < span class = "literal" > false< / span > ,< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-102" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-102" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Connection< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > connection: < span class = "keyword" > function< / span > (connection) {
< span class = "keyword" > if< / span > (connection == < span class = "literal" > null< / span > ) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._connection || Knex.client.getConnection();
}
< span class = "keyword" > this< / span > ._connection = connection;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-103" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-103" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Used before a builder call, specifying if this call
is nested inside a transaction< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > transacting: < span class = "keyword" > function< / span > (t) {
< span class = "keyword" > this< / span > .transaction = t;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-104" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-104" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Determine if the given table exists.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > hasTable: < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > var< / span > sql = < span class = "keyword" > this< / span > .grammar.compileTableExists();
table = < span class = "keyword" > this< / span > .connection.getTablePrefix() + table;
< span class = "keyword" > var< / span > deferred = Q.defer();
Knex.runQuery(< span class = "keyword" > this< / span > , {sql: sql, bindings: [table]}).then(< span class = "keyword" > function< / span > (resp) {
< span class = "keyword" > if< / span > (resp.length > < span class = "number" > 0< / span > ) {
< span class = "keyword" > return< / span > deferred.resolve(resp);
} < span class = "keyword" > else< / span > {
< span class = "keyword" > return< / span > deferred.reject(< span class = "keyword" > new< / span > Error(< span class = "string" > 'Table'< / span > + table + < span class = "string" > ' does not exist'< / span > ));
}
}, deferred.reject);
< span class = "keyword" > return< / span > deferred.promise;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-105" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-105" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Modify a table on the schema.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > table: < span class = "keyword" > function< / span > (table, callback) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .build(< span class = "keyword" > this< / span > .createBlueprint(table, callback));
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-106" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-106" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new table on the schema.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > createTable: < span class = "keyword" > function< / span > (table, callback) {
< span class = "keyword" > var< / span > blueprint = < span class = "keyword" > this< / span > .createBlueprint(table);
blueprint.createTable();
callback(blueprint);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .build(blueprint);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-107" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-107" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Drop a table from the schema.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropTable: < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > var< / span > blueprint = < span class = "keyword" > this< / span > .createBlueprint(table);
blueprint.dropTable();
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .build(blueprint);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-108" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-108" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Drop a table from the schema if it exists.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropTableIfExists: < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > var< / span > blueprint = < span class = "keyword" > this< / span > .createBlueprint(table);
blueprint.dropTableIfExists();
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .build(blueprint);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-109" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-109" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Rename a table on the schema.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > renameTable: < span class = "keyword" > function< / span > (from, to) {
< span class = "keyword" > var< / span > blueprint = < span class = "keyword" > this< / span > .createBlueprint(from);
blueprint.renameTable(to);
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .build(blueprint);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-110" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-110" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Execute the blueprint to build / modify the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > build: < span class = "keyword" > function< / span > (blueprint) {
< span class = "keyword" > return< / span > blueprint.build(< span class = "keyword" > this< / span > .connection, < span class = "keyword" > this< / span > .grammar);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-111" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-111" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new command set with a Closure.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > createBlueprint: < span class = "keyword" > function< / span > (table, callback) {
< span class = "keyword" > return< / span > < span class = "keyword" > new< / span > Blueprint(table, callback);
}
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-112" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-112" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.SchemaGrammar< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-113" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-113" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > SchemaGrammar = Knex.SchemaGrammar = < span class = "keyword" > function< / span > (mixins) {
_.extend(< span class = "keyword" > this< / span > , mixins);
};
_.extend(SchemaGrammar.prototype, Grammar.prototype, {< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-114" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-114" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Compile a foreign key command.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > compileForeign: < span class = "keyword" > function< / span > (blueprint, command) {
< span class = "keyword" > var< / span > table = < span class = "keyword" > this< / span > .wrapTable(blueprint);
< span class = "keyword" > var< / span > on = < span class = "keyword" > this< / span > .wrapTable(command.on);< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-115" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-115" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > We need to prepare several of the elements of the foreign key definition
2013-03-12 11:52:08 -04:00
before we can create the SQL, such as wrapping the tables and convert
2013-03-19 20:28:03 -04:00
an array of columns to comma-delimited strings for the SQL queries.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > columns = < span class = "keyword" > this< / span > .columnize(command.columns);
< span class = "keyword" > var< / span > onColumns = < span class = "keyword" > this< / span > .columnize(command.references);
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
< span class = "keyword" > var< / span > sql = < span class = "string" > "alter table "< / span > + table + < span class = "string" > " add constraint "< / span > + command.index + < span class = "string" > " "< / span > ;
sql += < span class = "string" > "foreign key ("< / span > + columns + < span class = "string" > ") references "< / span > + on + < span class = "string" > " ("< / span > + onColumns + < span class = "string" > ")"< / span > ;< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-116" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-116" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Once we have the basic foreign key creation statement constructed we can
2013-03-12 11:52:08 -04:00
build out the syntax for what should happen on an update or delete of
2013-03-19 20:28:03 -04:00
the affected columns, which will get something like " cascade" , etc.< / p >
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > if< / span > (command.onDelete) sql += < span class = "string" > " on delete "< / span > + command.onDelete;
< span class = "keyword" > if< / span > (command.onUpdate) sql += < span class = "string" > " on update "< / span > + command.onUpdate;
< span class = "keyword" > return< / span > sql;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-117" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-117" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Each of the column types have their own compiler functions which are
2013-03-12 11:52:08 -04:00
responsible for turning the column definition into its SQL format
2013-03-19 20:28:03 -04:00
for the platform. Then column modifiers are compiled and added.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > getColumns: < span class = "keyword" > function< / span > (blueprint) {
< span class = "keyword" > var< / span > columns = [];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = blueprint.columns.length; i < l; i++) {
< span class = "keyword" > var< / span > column = blueprint.columns[i];
< span class = "keyword" > var< / span > sql = < span class = "keyword" > this< / span > .wrap(column) + < span class = "string" > ' '< / span > + < span class = "keyword" > this< / span > .getType(column);
columns.push(< span class = "keyword" > this< / span > .addModifiers(sql, blueprint, column));
}
< span class = "keyword" > return< / span > columns;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-118" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-118" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add the column modifiers to the definition.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > addModifiers: < span class = "keyword" > function< / span > (sql, blueprint, column) {
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = < span class = "keyword" > this< / span > .modifiers.length; i < l; i++) {
< span class = "keyword" > var< / span > modifier = < span class = "keyword" > this< / span > .modifiers[i];
< span class = "keyword" > var< / span > method = < span class = "string" > "modify"< / span > + modifier;
< span class = "keyword" > if< / span > (_.has(< span class = "keyword" > this< / span > , method)) {
sql += < span class = "keyword" > this< / span > [method](blueprint, column) || < span class = "string" > ''< / span > ;
}
}
< span class = "keyword" > return< / span > sql;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-119" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-119" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Get the primary key command if it exists on the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > getCommandByName: < span class = "keyword" > function< / span > (blueprint, name) {
< span class = "keyword" > var< / span > commands = < span class = "keyword" > this< / span > .getCommandsByName(blueprint, name);
< span class = "keyword" > if< / span > (commands.length > < span class = "number" > 0< / span > ) < span class = "keyword" > return< / span > commands[< span class = "number" > 0< / span > ];
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-120" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-120" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Get all of the commands with a given name.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > getCommandsByName: < span class = "keyword" > function< / span > (blueprint, name) {
< span class = "keyword" > return< / span > _.where(blueprint.commands, < span class = "keyword" > function< / span > (value) { < span class = "keyword" > return< / span > value.name == name; });
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-121" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-121" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Get the SQL for the column data type.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > getType: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > [< span class = "string" > "type"< / span > + capitalize(column.type)](column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-122" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-122" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add a prefix to an array of values.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > prefixArray: < span class = "keyword" > function< / span > (prefix, values) {
< span class = "keyword" > return< / span > _.map(values, < span class = "keyword" > function< / span > (value) { < span class = "keyword" > return< / span > prefix + < span class = "string" > ' '< / span > + value; });
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-123" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-123" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Wrap a table in keyword identifiers.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > wrapTable: < span class = "keyword" > function< / span > (table) {
< span class = "keyword" > if< / span > (table < span class = "keyword" > instanceof< / span > Blueprint) table = table.table;
< span class = "keyword" > return< / span > Knex.Grammar.prototype.wrapTable.call(< span class = "keyword" > this< / span > , table);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-124" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-124" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Wrap a value in keyword identifiers.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > wrap: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > if< / span > (value < span class = "keyword" > instanceof< / span > Chainable) value = value.name;
< span class = "keyword" > return< / span > Knex.Grammar.prototype.wrap.call(< span class = "keyword" > this< / span > , value);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-125" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-125" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Format a value so that it can be used in " default" clauses.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > getDefaultValue: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > if< / span > (value === < span class = "literal" > true< / span > || value === < span class = "literal" > false< / span > ) {
< span class = "keyword" > return< / span > parseInt(value, < span class = "number" > 10< / span > );
}
< span class = "keyword" > return< / span > < span class = "string" > ''< / span > + value;
}
});< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-126" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-126" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.SchemaBlueprint< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-127" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-127" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Blueprint = Knex.SchemaBlueprint = < span class = "keyword" > function< / span > (table, callback) {
< span class = "keyword" > this< / span > .table = table;
< span class = "keyword" > this< / span > .columns = [];
< span class = "keyword" > this< / span > .commands = [];
< span class = "keyword" > if< / span > (callback) callback(< span class = "keyword" > this< / span > );
};
Blueprint.prototype = {
2013-03-12 11:52:08 -04:00
2013-03-19 20:28:03 -04:00
build: < span class = "keyword" > function< / span > (connection, grammar) {
< span class = "keyword" > var< / span > statements = < span class = "keyword" > this< / span > .toSql(grammar);
< span class = "keyword" > var< / span > promises = [];
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = statements.length; i < l; i++) {
< span class = "keyword" > var< / span > statement = statements[i];
promises.push(Knex.runQuery(< span class = "keyword" > this< / span > , {sql: statement}));
}
< span class = "keyword" > return< / span > Q.all(promises);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-128" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-128" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Get the raw sql statements for the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > toSql: < span class = "keyword" > function< / span > (grammar) {< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-129" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-129" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add the commands that are implied by the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > if< / span > (< span class = "keyword" > this< / span > .columns.length > < span class = "number" > 0< / span > & & !< span class = "keyword" > this< / span > .creating()) {
< span class = "keyword" > this< / span > .commands.unshift(< span class = "keyword" > new< / span > Chainable({name: < span class = "string" > 'add'< / span > }));
}< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-130" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-130" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add indicies< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = < span class = "keyword" > this< / span > .columns.length; i < l; i++) {
< span class = "keyword" > var< / span > column = < span class = "keyword" > this< / span > .columns[i];
< span class = "keyword" > var< / span > indices = [< span class = "string" > 'primary'< / span > , < span class = "string" > 'unique'< / span > , < span class = "string" > 'index'< / span > ];
continueIndex:
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i2 = < span class = "number" > 0< / span > , l2 = indices.length; i2 < l2; i2++) {
< span class = "keyword" > var< / span > index = indices[i2];
< span class = "keyword" > var< / span > indexVar = < span class = "string" > 'is'< / span > + capitalize(index);< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-131" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-131" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > If the index has been specified on the given column, but is simply
equal to " true" (boolean), no name has been specified for this
index, so we will simply call the index methods without one.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > if< / span > (column[indexVar] === < span class = "literal" > true< / span > ) {
< span class = "keyword" > this< / span > [index](column);
< span class = "keyword" > continue< / span > continueIndex;< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-132" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-132" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > If the index has been specified on the column and it is something
2013-03-12 11:52:08 -04:00
other than boolean true, we will assume a name was provided on
2013-03-19 20:28:03 -04:00
the index specification, and pass in the name to the method.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > } < span class = "keyword" > else< / span > < span class = "keyword" > if< / span > (_.has(column, indexVar)) {
< span class = "keyword" > this< / span > [index](column.name, column[indexVar]);
< span class = "keyword" > continue< / span > continueIndex;
}
}
}
< span class = "keyword" > var< / span > statements = [];< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-133" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-133" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Each type of command has a corresponding compiler function on the schema
2013-03-12 11:52:08 -04:00
grammar which is used to build the necessary SQL statements to build
2013-03-19 20:28:03 -04:00
the blueprint element, so we' ll just call that compilers function.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > for< / span > (i = < span class = "number" > 0< / span > , l = < span class = "keyword" > this< / span > .commands.length; i < l; i++) {
< span class = "keyword" > var< / span > command = < span class = "keyword" > this< / span > .commands[i];
< span class = "keyword" > var< / span > method = < span class = "string" > 'compile'< / span > + capitalize(command.name);
< span class = "keyword" > if< / span > (_.has(grammar, method)) {
< span class = "keyword" > var< / span > sql = grammar[method](< span class = "keyword" > this< / span > , command);
statements.push(sql);
}
}
< span class = "keyword" > return< / span > statements;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-134" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-134" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Determine if the blueprint has a create command.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > creating: < span class = "keyword" > function< / span > () {
< span class = "keyword" > var< / span > command;
< span class = "keyword" > for< / span > (< span class = "keyword" > var< / span > i = < span class = "number" > 0< / span > , l = < span class = "keyword" > this< / span > .commands.length; i < l; i++) {
command = < span class = "keyword" > this< / span > .commands[i];
< span class = "keyword" > if< / span > (command.name == < span class = "string" > 'createTable'< / span > ) < span class = "keyword" > return< / span > < span class = "literal" > true< / span > ;
}
< span class = "keyword" > return< / span > < span class = "literal" > false< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-135" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-135" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the table needs to be created.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > createTable: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(< span class = "string" > 'createTable'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-136" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-136" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the table should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropTable: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(< span class = "string" > 'dropTable'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-137" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-137" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the table should be dropped if it exists.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropTableIfExists: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(< span class = "string" > 'dropTableIfExists'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-138" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-138" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given columns should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropColumn: < span class = "keyword" > function< / span > (columns) {
2013-04-01 00:50:50 -04:00
< span class = "keyword" > if< / span > (!_.isArray(columns)) columns = columns ? [columns] : [];
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(< span class = "string" > 'dropColumn'< / span > , {columns: columns});
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-139" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-139" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given columns should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropColumns: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .dropColumn(arguments);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-140" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-140" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given primary key should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropPrimary: < span class = "keyword" > function< / span > (index) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._dropIndexCommand(< span class = "string" > 'dropPrimary'< / span > , index);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-141" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-141" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given unique key should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropUnique: < span class = "keyword" > function< / span > (index) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._dropIndexCommand(< span class = "string" > 'dropUnique'< / span > , index);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-142" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-142" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given index should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropIndex: < span class = "keyword" > function< / span > (index) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._dropIndexCommand(< span class = "string" > 'dropIndex'< / span > , index);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-143" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-143" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Indicate that the given foreign key should be dropped.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dropForeign: < span class = "keyword" > function< / span > (index) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._dropIndexCommand(< span class = "string" > 'dropForeign'< / span > , index);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-144" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-144" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Rename the table to a given name.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > renameTable: < span class = "keyword" > function< / span > (to) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(< span class = "string" > 'renameTable'< / span > , {to: to});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-145" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-145" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Specify the primary key(s) for the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > primary: < span class = "keyword" > function< / span > (columns, name) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._indexCommand(< span class = "string" > 'primary'< / span > , columns, name);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-146" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-146" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Specify a unique index for the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > unique: < span class = "keyword" > function< / span > (columns, name) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._indexCommand(< span class = "string" > 'unique'< / span > , columns, name);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-147" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-147" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Specify an index for the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > index: < span class = "keyword" > function< / span > (columns, name) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._indexCommand(< span class = "string" > 'index'< / span > , columns, name);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-148" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-148" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Specify a foreign key for the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > foreign: < span class = "keyword" > function< / span > (columns, name) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._indexCommand(< span class = "string" > 'foreign'< / span > , columns, name);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-149" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-149" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new auto-incrementing column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > increments: < span class = "keyword" > function< / span > (column) {
2013-04-25 21:05:15 -04:00
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'integer'< / span > , (column || < span class = "string" > 'id'< / span > ), {autoIncrement: < span class = "literal" > true< / span > , length: < span class = "number" > 11< / span > });
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-150" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-150" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new string column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > string: < span class = "keyword" > function< / span > (column, length) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'string'< / span > , column, {length: (length || < span class = "number" > 255< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-151" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-151" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-21 18:26:39 -04:00
< p > Alias varchar to string< / p >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-21 18:26:39 -04:00
< div class = "content" > < div class = 'highlight' > < pre > varchar: < span class = "keyword" > function< / span > (column, length) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .string(column, length);
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-152" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-152" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-21 18:26:39 -04:00
< p > Create a new text column on the table.< / p >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-21 18:26:39 -04:00
< div class = "content" > < div class = 'highlight' > < pre > text: < span class = "keyword" > function< / span > (column, length) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'text'< / span > , column, {length: (length || < span class = "literal" > false< / span > )});
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-153" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-153" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-21 18:26:39 -04:00
< p > Create a new integer column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > integer: < span class = "keyword" > function< / span > (column, length) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'integer'< / span > , column, {length: (length || < span class = "number" > 11< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-154" >
2013-04-21 18:26:39 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-154" > ¶ < / a >
2013-04-21 18:26:39 -04:00
< / div >
< p > Create a new tinyinteger column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > tinyInteger: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'tinyInteger'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-155" >
2013-04-21 18:26:39 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-155" > ¶ < / a >
2013-04-21 18:26:39 -04:00
< / div >
2013-04-22 09:06:07 -04:00
< p > Alias for tinyinteger column.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > tinyint: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'tinyInteger'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-156" >
2013-04-22 09:06:07 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-156" > ¶ < / a >
2013-04-22 09:06:07 -04:00
< / div >
2013-03-19 20:28:03 -04:00
< p > Create a new float column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > float: < span class = "keyword" > function< / span > (column, total, places) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'float'< / span > , column, {total: (total || < span class = "number" > 8< / span > ), places: (places || < span class = "number" > 2< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-157" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-157" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new decimal column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > decimal: < span class = "keyword" > function< / span > (column, precision, scale) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'decimal'< / span > , column, {precision: (precision || < span class = "number" > 8< / span > ), scale: (scale || < span class = "number" > 2< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-158" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-158" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new boolean column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > boolean: < span class = "keyword" > function< / span > (column) {
2013-04-21 18:26:39 -04:00
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'boolean'< / span > , column);
2013-03-19 20:28:03 -04:00
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-159" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-159" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Alias to " boolean" .< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > bool: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'boolean'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-160" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-160" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new date column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > date: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'date'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-161" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-161" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new date-time column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > dateTime: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'dateTime'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-162" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-162" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new time column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > time: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'time'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-163" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-163" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new timestamp column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > timestamp: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'timestamp'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-164" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-164" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add creation and update timestamps to the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > timestamps: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .timestamp(< span class = "string" > 'created_at'< / span > );
< span class = "keyword" > this< / span > .timestamp(< span class = "string" > 'updated_at'< / span > );
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-165" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-165" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new enum column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "string" > "enum"< / span > : < span class = "keyword" > function< / span > (column, allowed) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > .enu.apply(< span class = "keyword" > this< / span > , arguments);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-166" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-166" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Alias to enum.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > enu: < span class = "keyword" > function< / span > () {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'enum'< / span > , column, {allowed: allowed});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-167" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-167" > ¶ < / a >
2013-04-21 18:26:39 -04:00
< / div >
< p > Create a new bit column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > bit: < span class = "keyword" > function< / span > (column, length) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'bit'< / span > , column, {length: (length || < span class = "literal" > false< / span > )});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-168" >
2013-04-21 18:26:39 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-168" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new binary column on the table.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > binary: < span class = "keyword" > function< / span > (column) {
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addColumn(< span class = "string" > 'binary'< / span > , column);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-169" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-169" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< hr >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-170" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-170" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Create a new drop index command on the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _dropIndexCommand: < span class = "keyword" > function< / span > (type, index) {
< span class = "keyword" > var< / span > columns = [];
< span class = "keyword" > if< / span > (_.isArray(index)) {
columns = index;
index = < span class = "literal" > null< / span > ;
}
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._indexCommand(type, columns, index);
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-171" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-171" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add a new index command to the blueprint.
2013-03-12 11:52:08 -04:00
If no name was specified for this index, we will create one using a basic
convention of the table name, followed by the columns, followed by an
2013-03-19 20:28:03 -04:00
index type, such as primary or index, which makes the index unique.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _indexCommand: < span class = "keyword" > function< / span > (type, columns, index) {
index || (index = < span class = "literal" > null< / span > );
2013-04-01 00:50:50 -04:00
< span class = "keyword" > if< / span > (!_.isArray(columns)) columns = columns ? [columns] : [];
2013-03-19 20:28:03 -04:00
< span class = "keyword" > if< / span > (index === < span class = "literal" > null< / span > ) {
< span class = "keyword" > var< / span > table = < span class = "keyword" > this< / span > .table.replace(< span class = "regexp" > /\.|-/g< / span > , < span class = "string" > '_'< / span > );
2013-04-29 10:44:16 -04:00
index = (table + < span class = "string" > '_'< / span > + _.map(columns, < span class = "keyword" > function< / span > (col) { < span class = "keyword" > return< / span > col.name; }).join(< span class = "string" > '_'< / span > ) + < span class = "string" > '_'< / span > + type).toLowerCase();
2013-03-19 20:28:03 -04:00
}
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ._addCommand(type, {index: index, columns: columns});
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-172" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-172" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add a new column to the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _addColumn: < span class = "keyword" > function< / span > (type, name, parameters) {
2013-04-01 00:50:50 -04:00
< span class = "keyword" > if< / span > (!name) < span class = "keyword" > throw< / span > < span class = "keyword" > new< / span > Error(< span class = "string" > 'A `name` must be defined to add a column'< / span > );
2013-03-19 20:28:03 -04:00
< span class = "keyword" > var< / span > attrs = _.extend({type: type, name: name}, parameters);
< span class = "keyword" > var< / span > column = < span class = "keyword" > new< / span > Chainable(attrs);
< span class = "keyword" > this< / span > .columns.push(column);
< span class = "keyword" > return< / span > column;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-173" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-173" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Add a new command to the blueprint.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _addCommand: < span class = "keyword" > function< / span > (name, parameters) {
< span class = "keyword" > var< / span > command = < span class = "keyword" > new< / span > Chainable(_.extend({name: name}, parameters));
< span class = "keyword" > this< / span > .commands.push(command);
< span class = "keyword" > return< / span > command;
}
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-174" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-174" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Chainable object used in creating SchemaBuilder commands.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "keyword" > var< / span > Chainable = < span class = "keyword" > function< / span > (obj) {
_.extend(< span class = "keyword" > this< / span > , obj);
};
Chainable.prototype = {< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-175" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-175" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Sets the default value for a column.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > defaultTo: < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > this< / span > .defaultValue = value;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-176" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-176" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Sets an integer as unsigned, is a no-op
if the column type is not an integer.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > unsigned: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .isUnsigned = < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-177" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-177" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Allows the column to contain null values.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > nullable: < span class = "keyword" > function< / span > () {
< span class = "keyword" > this< / span > .isNullable = < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
2013-04-29 10:44:16 -04:00
index: < span class = "keyword" > function< / span > (name) {
2013-03-19 20:28:03 -04:00
< span class = "keyword" > this< / span > .isIndex = name || < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
2013-04-29 10:44:16 -04:00
primary: < span class = "keyword" > function< / span > (name) {
2013-03-19 20:28:03 -04:00
< span class = "keyword" > this< / span > .isPrimary = name || < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
},
2013-04-29 10:44:16 -04:00
unique: < span class = "keyword" > function< / span > (name) {
2013-03-19 20:28:03 -04:00
< span class = "keyword" > this< / span > .isUnique = name || < span class = "literal" > true< / span > ;
< span class = "keyword" > return< / span > < span class = "keyword" > this< / span > ;
}
2013-04-01 00:50:50 -04:00
};
< span class = "keyword" > var< / span > capitalize = < span class = "keyword" > function< / span > (word) {
< span class = "keyword" > return< / span > word.charAt(< span class = "number" > 0< / span > ).toUpperCase() + word.slice(< span class = "number" > 1< / span > );
2013-04-29 10:44:16 -04:00
};
< span class = "keyword" > var< / span > sortObject = < span class = "keyword" > function< / span > (obj) {
< span class = "keyword" > return< / span > _.sortBy(_.pairs(obj), < span class = "keyword" > function< / span > (a) {
< span class = "keyword" > return< / span > a[< span class = "number" > 0< / span > ];
});
2013-03-19 20:28:03 -04:00
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-178" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-178" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
2013-04-01 00:50:50 -04:00
< h2 > Knex.Raw< / h2 >
2013-03-19 20:28:03 -04:00
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-179" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-179" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > Knex.Raw = < span class = "keyword" > function< / span > (value) {
< span class = "keyword" > this< / span > .value = value;
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-180" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap for-h2" >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-180" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< h2 > Knex.runQuery< / h2 >
< / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-181" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-181" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Query runner, the context of this function is set to the caller,
2013-03-12 11:52:08 -04:00
(either Builder or SchemaBuilder). Checks and fails on an already
resolved transaction, otherwise calls the query on the specified client
2013-03-19 20:28:03 -04:00
and returns a deferred promise.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > Knex.runQuery = < span class = "keyword" > function< / span > (builder, data) {
2013-04-29 10:44:16 -04:00
< span class = "keyword" > if< / span > (builder.transaction) {
< span class = "keyword" > if< / span > (!builder.transaction.connection) < span class = "keyword" > return< / span > Q.reject(< span class = "keyword" > new< / span > Error(< span class = "string" > 'The transaction has already completed.'< / span > ));
builder.connection = builder.transaction.connection;
2013-03-19 20:28:03 -04:00
}
< span class = "keyword" > var< / span > deferred = Q.defer();
Knex.client.query(data.sql, (data.bindings || []), < span class = "keyword" > function< / span > (err, resp) {
Knex.lastQuery = data.sql;
< span class = "keyword" > if< / span > (err) < span class = "keyword" > return< / span > deferred.reject(err);
deferred.resolve(resp);
2013-04-01 00:50:50 -04:00
}, builder.connection, data.type);
2013-03-19 20:28:03 -04:00
< span class = "keyword" > return< / span > deferred.promise;
};< / pre > < / div > < / div >
< / li >
2013-04-29 10:44:16 -04:00
< li id = "section-182" >
2013-03-19 20:28:03 -04:00
< div class = "annotation" >
< div class = "pilwrap " >
2013-04-29 10:44:16 -04:00
< a class = "pilcrow" href = "#section-182" > ¶ < / a >
2013-03-19 20:28:03 -04:00
< / div >
< p > Export the Knex module< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > module.exports = Knex;
}).call(< span class = "keyword" > this< / span > );< / pre > < / div > < / div >
< / li >
< / ul >
< / div >
< / body >
< / html >
