yujunjun/knex
1
0
Fork 0
mirror of https://github.com/knex/knex.git synced 2025-11-02 02:40:13 +00:00
Code Issues Packages Projects Releases Wiki Activity
knex/docs/knex.html

3605 lines
144 KiB
HTML
Raw Blame History

<!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">&#182;</a>
</div>
<pre><code>Knex.js 0.1.0
(c) 2013 Tim Griesser
Bookshelf may be freely distributed under the MIT license.
For details and documentation:
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">&#182;</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">&#182;</a>
</div>
<p><code>Knex</code> is the root namespace and a chainable function where
<code>Knex(&#39;tableName&#39;)</code> is shorthand for <code>new Knex.Builder(&#39;tableName&#39;)</code>
or <code>new Knex.Builder().from(&#39;tableName&#39;)</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">&#182;</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">&#182;</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">&#182;</a>
</div>
<h2>Knex.Initialize</h2>
</div>
</li>
<li id="section-7">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-7">&#182;</a>
</div>
</div>
</li>
<li id="section-8">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-8">&#182;</a>
</div>
<p>Takes a hash of options to initialize the database
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
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">&#182;</a>
</div>
<p>Checks if this is a default client. If it&#39;s not,
require it as the path to the client if it&#39;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">&#182;</a>
</div>
<h2>Knex.Grammar</h2>
</div>
</li>
<li id="section-11">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-11">&#182;</a>
</div>
<p>Creates a new Grammar, with the mixins for the
specified query dialect, which are defined in each
client&#39;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">&#182;</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">&#182;</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 &lt; 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">&#182;</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 &amp;&amp; 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">&#182;</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">&#182;</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">&#182;</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 &lt; 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 &lt; 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">&#182;</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 &lt; 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 &gt; <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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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) {
<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>;
},</pre></div></div>
</li>
<li id="section-25">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-25">&#182;</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) {
<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>;
},</pre></div></div>
</li>
<li id="section-26">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-26">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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 &gt; <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">&#182;</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">&#182;</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">&#182;</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);
<span class="keyword">var</span> columns = <span class="keyword">this</span>.columnize(_.keys(values[<span class="number">0</span>]).sort());
<span class="keyword">var</span> parameters = <span class="keyword">this</span>.parameterize(_.values(values[<span class="number">0</span>]));
<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">&#182;</a>
</div>
<p>If there are any &quot;where&quot; 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 &gt; <span class="number">0</span>) <span class="keyword">this</span>._clearWhereBindings(qb);
<span class="keyword">for</span> (<span class="keyword">var</span> i = <span class="number">0</span>, l = values.length; i &lt; 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>
<li id="section-36">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-36">&#182;</a>
</div>
<p>Depending on the type of <code>where</code> clause, this will appropriately
remove any binding caused by &quot;where&quot; 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&lt;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">&#182;</a>
</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>
<li id="section-38">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-38">&#182;</a>
</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>
<li id="section-39">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-39">&#182;</a>
</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 &lt; l; i = ++i) {
value = segments[i];
<span class="keyword">if</span> (i === <span class="number">0</span> &amp;&amp; segments.length &gt; <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>
<li id="section-40">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-40">&#182;</a>
</div>
<h2>Knex.Builder</h2>
</div>
</li>
<li id="section-41">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-41">&#182;</a>
</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>
<li id="section-42">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-42">&#182;</a>
</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">'&lt;'</span>, <span class="string">'&gt;'</span>, <span class="string">'&lt;='</span>, <span class="string">'&gt;='</span>, <span class="string">'like'</span>, <span class="string">'not like'</span>, <span class="string">'between'</span>, <span class="string">'ilike'</span>];
Builder.prototype = {</pre></div></div>
</li>
<li id="section-43">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-43">&#182;</a>
</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>
<li id="section-44">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-44">&#182;</a>
</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>
<li id="section-45">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-45">&#182;</a>
</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 = [
<span class="string">'isDistinct'</span>, <span class="string">'joins'</span>,
<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 &lt; 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>
<li id="section-46">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-46">&#182;</a>
</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>;
},
toJSON: <span class="keyword">function</span>() {
<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
};
},</pre></div></div>
</li>
<li id="section-47">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-47">&#182;</a>
</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>
<li id="section-48">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-48">&#182;</a>
</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>
</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>
<li id="section-49">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-49">&#182;</a>
</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>
<li id="section-50">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-50">&#182;</a>
</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>
<li id="section-51">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-51">&#182;</a>
</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>
<li id="section-52">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-52">&#182;</a>
</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>
<li id="section-53">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-53">&#182;</a>
</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>
<li id="section-54">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-54">&#182;</a>
</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>
<li id="section-55">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-55">&#182;</a>
</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,
value: values,
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>
<li id="section-56">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-56">&#182;</a>
</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>
<li id="section-57">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-57">&#182;</a>
</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>
<li id="section-58">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-58">&#182;</a>
</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>
<li id="section-59">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-59">&#182;</a>
</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>
<li id="section-60">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-60">&#182;</a>
</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>
<li id="section-61">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-61">&#182;</a>
</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>
<li id="section-62">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-62">&#182;</a>
</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>
<li id="section-63">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-63">&#182;</a>
</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>
<li id="section-64">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-64">&#182;</a>
</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>
<li id="section-65">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-65">&#182;</a>
</div>
<hr>
</div>
</li>
<li id="section-66">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-66">&#182;</a>
</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>
<li id="section-67">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-67">&#182;</a>
</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>
<li id="section-68">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-68">&#182;</a>
</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>
<li id="section-69">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-69">&#182;</a>
</div>
<hr>
</div>
</li>
<li id="section-70">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-70">&#182;</a>
</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>
<li id="section-71">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-71">&#182;</a>
</div>
<hr>
</div>
</li>
<li id="section-72">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-72">&#182;</a>
</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 &gt; <span class="number">0</span>);
});
},</pre></div></div>
</li>
<li id="section-73">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-73">&#182;</a>
</div>
<p>Retrieve the &quot;count&quot; 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>
<li id="section-74">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-74">&#182;</a>
</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>
<li id="section-75">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-75">&#182;</a>
</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>
<li id="section-76">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-76">&#182;</a>
</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>
<li id="section-77">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-77">&#182;</a>
</div>
<p>Increments a column&#39;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>
<li id="section-78">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-78">&#182;</a>
</div>
<p>Decrements a column&#39;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>
<li id="section-79">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-79">&#182;</a>
</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>);
<span class="keyword">if</span> (!<span class="keyword">this</span>.isSubQuery &amp;&amp; !<span class="keyword">this</span>.isQueryString) {
<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>
<li id="section-80">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-80">&#182;</a>
</div>
<p>Performs an <code>insert</code> query, returning a promise.</p>
</div>
<div class="content"><div class='highlight'><pre> insert: <span class="keyword">function</span>(values, returning) {
<span class="keyword">if</span> (!_.isArray(values)) values = values ? [values] : [];
<span class="keyword">for</span> (<span class="keyword">var</span> i = <span class="number">0</span>, l = values.length; i&lt;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 &lt; l2; i2++) {
<span class="keyword">this</span>.bindings.push(obj[i2][<span class="number">1</span>]);
}
}
<span class="keyword">var</span> str = <span class="keyword">this</span>.grammar.compileInsert(<span class="keyword">this</span>, values);
<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>});
},</pre></div></div>
</li>
<li id="section-81">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-81">&#182;</a>
</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);
<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>});
},</pre></div></div>
</li>
<li id="section-82">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-82">&#182;</a>
</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>
<li id="section-83">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-83">&#182;</a>
</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>
<li id="section-84">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-84">&#182;</a>
</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>
<li id="section-85">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-85">&#182;</a>
</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>
<li id="section-86">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-86">&#182;</a>
</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>
<li id="section-87">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-87">&#182;</a>
</div>
<hr>
</div>
</li>
<li id="section-88">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-88">&#182;</a>
</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});
push.apply(<span class="keyword">this</span>.bindings, query.bindings);
<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>
<li id="section-89">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-89">&#182;</a>
</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>
<li id="section-90">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-90">&#182;</a>
</div>
<h2>Knex.JoinClause</h2>
</div>
</li>
<li id="section-91">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-91">&#182;</a>
</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>
<li id="section-92">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-92">&#182;</a>
</div>
<h2>Knex.Transaction</h2>
</div>
</li>
<li id="section-93">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-93">&#182;</a>
</div>
</div>
<div class="content"><div class='highlight'><pre> Knex.Transaction = <span class="keyword">function</span>(container) {</pre></div></div>
</li>
<li id="section-94">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-94">&#182;</a>
</div>
<p>Initiate a deferred object, so we know when the
transaction completes or fails, we know what to do.</p>
</div>
<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>
</li>
<li id="section-95">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-95">&#182;</a>
</div>
<p>Finish the transaction connection</p>
</div>
<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>
</li>
<li id="section-96">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-96">&#182;</a>
</div>
<p>Call the container with the transaction
commit &amp; rollback objects</p>
</div>
<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
});
});
<span class="keyword">return</span> deferred.promise;
};</pre></div></div>
</li>
<li id="section-97">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-97">&#182;</a>
</div>
<h2>Knex.Schema</h2>
</div>
</li>
<li id="section-98">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-98">&#182;</a>
</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>
<li id="section-99">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-99">&#182;</a>
</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>
<li id="section-100">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-100">&#182;</a>
</div>
<h2>Knex.SchemaBuilder</h2>
</div>
</li>
<li id="section-101">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-101">&#182;</a>
</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);
};
SchemaBuilder.prototype = {
_connection: <span class="literal">null</span>,
transaction: <span class="literal">false</span>,</pre></div></div>
</li>
<li id="section-102">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-102">&#182;</a>
</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>
<li id="section-103">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-103">&#182;</a>
</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>
<li id="section-104">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-104">&#182;</a>
</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 &gt; <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>
<li id="section-105">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-105">&#182;</a>
</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>
<li id="section-106">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-106">&#182;</a>
</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>
<li id="section-107">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-107">&#182;</a>
</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>
<li id="section-108">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-108">&#182;</a>
</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>
<li id="section-109">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-109">&#182;</a>
</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>
<li id="section-110">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-110">&#182;</a>
</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>
<li id="section-111">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-111">&#182;</a>
</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>
<li id="section-112">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-112">&#182;</a>
</div>
<h2>Knex.SchemaGrammar</h2>
</div>
</li>
<li id="section-113">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-113">&#182;</a>
</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>
<li id="section-114">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-114">&#182;</a>
</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>
<li id="section-115">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-115">&#182;</a>
</div>
<p>We need to prepare several of the elements of the foreign key definition
before we can create the SQL, such as wrapping the tables and convert
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);
<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>
<li id="section-116">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-116">&#182;</a>
</div>
<p>Once we have the basic foreign key creation statement constructed we can
build out the syntax for what should happen on an update or delete of
the affected columns, which will get something like &quot;cascade&quot;, etc.</p>
</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>
<li id="section-117">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-117">&#182;</a>
</div>
<p>Each of the column types have their own compiler functions which are
responsible for turning the column definition into its SQL format
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 &lt; 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>
<li id="section-118">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-118">&#182;</a>
</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 &lt; 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>
<li id="section-119">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-119">&#182;</a>
</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 &gt; <span class="number">0</span>) <span class="keyword">return</span> commands[<span class="number">0</span>];
},</pre></div></div>
</li>
<li id="section-120">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-120">&#182;</a>
</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>
<li id="section-121">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-121">&#182;</a>
</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>
<li id="section-122">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-122">&#182;</a>
</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>
<li id="section-123">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-123">&#182;</a>
</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>
<li id="section-124">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-124">&#182;</a>
</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>
<li id="section-125">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-125">&#182;</a>
</div>
<p>Format a value so that it can be used in &quot;default&quot; 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>
<li id="section-126">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-126">&#182;</a>
</div>
<h2>Knex.SchemaBlueprint</h2>
</div>
</li>
<li id="section-127">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-127">&#182;</a>
</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 = {
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 &lt; 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>
<li id="section-128">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-128">&#182;</a>
</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>
<li id="section-129">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-129">&#182;</a>
</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 &gt; <span class="number">0</span> &amp;&amp; !<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>
<li id="section-130">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-130">&#182;</a>
</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 &lt; 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 &lt; 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>
<li id="section-131">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-131">&#182;</a>
</div>
<p>If the index has been specified on the given column, but is simply
equal to &quot;true&quot; (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>
<li id="section-132">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-132">&#182;</a>
</div>
<p>If the index has been specified on the column and it is something
other than boolean true, we will assume a name was provided on
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>
<li id="section-133">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-133">&#182;</a>
</div>
<p>Each type of command has a corresponding compiler function on the schema
grammar which is used to build the necessary SQL statements to build
the blueprint element, so we&#39;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 &lt; 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>
<li id="section-134">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-134">&#182;</a>
</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 &lt; 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>
<li id="section-135">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-135">&#182;</a>
</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>
<li id="section-136">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-136">&#182;</a>
</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>
<li id="section-137">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-137">&#182;</a>
</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>
<li id="section-138">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-138">&#182;</a>
</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) {
<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});
},</pre></div></div>
</li>
<li id="section-139">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-139">&#182;</a>
</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>
<li id="section-140">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-140">&#182;</a>
</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>
<li id="section-141">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-141">&#182;</a>
</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>
<li id="section-142">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-142">&#182;</a>
</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>
<li id="section-143">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-143">&#182;</a>
</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>
<li id="section-144">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-144">&#182;</a>
</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>
<li id="section-145">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-145">&#182;</a>
</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>
<li id="section-146">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-146">&#182;</a>
</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>
<li id="section-147">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-147">&#182;</a>
</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>
<li id="section-148">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-148">&#182;</a>
</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>
<li id="section-149">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-149">&#182;</a>
</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) {
<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>});
},</pre></div></div>
</li>
<li id="section-150">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-150">&#182;</a>
</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>
<li id="section-151">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-151">&#182;</a>
</div>
<p>Alias varchar to string</p>
</div>
<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);
},</pre></div></div>
</li>
<li id="section-152">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-152">&#182;</a>
</div>
<p>Create a new text column on the table.</p>
</div>
<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>)});
},</pre></div></div>
</li>
<li id="section-153">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-153">&#182;</a>
</div>
<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>
<li id="section-154">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-154">&#182;</a>
</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>
<li id="section-155">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-155">&#182;</a>
</div>
<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>
<li id="section-156">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-156">&#182;</a>
</div>
<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>
<li id="section-157">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-157">&#182;</a>
</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>
<li id="section-158">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-158">&#182;</a>
</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) {
<span class="keyword">return</span> <span class="keyword">this</span>._addColumn(<span class="string">'boolean'</span>, column);
},</pre></div></div>
</li>
<li id="section-159">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-159">&#182;</a>
</div>
<p>Alias to &quot;boolean&quot;.</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>
<li id="section-160">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-160">&#182;</a>
</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>
<li id="section-161">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-161">&#182;</a>
</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>
<li id="section-162">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-162">&#182;</a>
</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>
<li id="section-163">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-163">&#182;</a>
</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>
<li id="section-164">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-164">&#182;</a>
</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>
<li id="section-165">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-165">&#182;</a>
</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>
<li id="section-166">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-166">&#182;</a>
</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>
<li id="section-167">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-167">&#182;</a>
</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>
<li id="section-168">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-168">&#182;</a>
</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>
<li id="section-169">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-169">&#182;</a>
</div>
<hr>
</div>
</li>
<li id="section-170">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-170">&#182;</a>
</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>
<li id="section-171">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-171">&#182;</a>
</div>
<p>Add a new index command to the blueprint.
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
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>);
<span class="keyword">if</span> (!_.isArray(columns)) columns = columns ? [columns] : [];
<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>);
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();
}
<span class="keyword">return</span> <span class="keyword">this</span>._addCommand(type, {index: index, columns: columns});
},</pre></div></div>
</li>
<li id="section-172">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-172">&#182;</a>
</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) {
<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>);
<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>
<li id="section-173">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-173">&#182;</a>
</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>
<li id="section-174">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-174">&#182;</a>
</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>
<li id="section-175">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-175">&#182;</a>
</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>
<li id="section-176">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-176">&#182;</a>
</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>
<li id="section-177">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-177">&#182;</a>
</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>;
},
index: <span class="keyword">function</span>(name) {
<span class="keyword">this</span>.isIndex = name || <span class="literal">true</span>;
<span class="keyword">return</span> <span class="keyword">this</span>;
},
primary: <span class="keyword">function</span>(name) {
<span class="keyword">this</span>.isPrimary = name || <span class="literal">true</span>;
<span class="keyword">return</span> <span class="keyword">this</span>;
},
unique: <span class="keyword">function</span>(name) {
<span class="keyword">this</span>.isUnique = name || <span class="literal">true</span>;
<span class="keyword">return</span> <span class="keyword">this</span>;
}
};
<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>);
};
<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>];
});
};</pre></div></div>
</li>
<li id="section-178">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-178">&#182;</a>
</div>
<h2>Knex.Raw</h2>
</div>
</li>
<li id="section-179">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-179">&#182;</a>
</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>
<li id="section-180">
<div class="annotation">
<div class="pilwrap for-h2">
<a class="pilcrow" href="#section-180">&#182;</a>
</div>
<h2>Knex.runQuery</h2>
</div>
</li>
<li id="section-181">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-181">&#182;</a>
</div>
<p>Query runner, the context of this function is set to the caller,
(either Builder or SchemaBuilder). Checks and fails on an already
resolved transaction, otherwise calls the query on the specified client
and returns a deferred promise.</p>
</div>
<div class="content"><div class='highlight'><pre> Knex.runQuery = <span class="keyword">function</span>(builder, data) {
<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;
}
<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);
}, builder.connection, data.type);
<span class="keyword">return</span> deferred.promise;
};</pre></div></div>
</li>
<li id="section-182">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-182">&#182;</a>
</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>
Reference in New Issue View Git Blame Copy Permalink