index.js

1. (function() {
2. var Query, Select, copy, dialects, fluid, normalize, passthrough_resolver, sys, unknown;
3. var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
4. for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
5. function ctor() { this.constructor = child; }
6. ctor.prototype = parent.prototype;
7. child.prototype = new ctor;
8. child.__super__ = parent.prototype;
9. return child;
10. }, __slice = Array.prototype.slice;
11. fluid = require('./fluid');
12. sys = require('sys');
13. unknown = function(type, val) {
14. throw new Error("Unknown " + type + ": " + val);
15. };
16. copy = function(thing) {
17. var c, k, obj, v;
18. if (thing.constructor === Array) {
19. c = [];
20. c.push.apply(c, thing);
21. return c;
22. } else if ('object' === typeof thing) {
23. obj = {};
24. for (k in thing) {
25. v = thing[k];
26. obj[k] = copy(v);
27. }
28. return obj;
29. } else {
30. return thing;
31. }
32. };
33. dialects = exports.dialects = {
34. "default": 'mysql',
35. mysql: require('./mysql')
36. };
37. passthrough_resolver = {
38. table: function(n) {
39. return n;
40. },
41. field: function(n) {
42. return n;
43. }
44. };
45. exports.Query = Query = (function() {
46. function Query(opts) {
47. this.dialect = opts.dialect || dialects["default"];
48. this.resolve = opts.resolver || passthrough_resolver;
49. if ('string' === typeof this.dialect) {
50. this.dialect = dialects[this.dialect];
51. }
52. this.s = {
53. includedAliases: {},
54. fields: {},
55. tableStack: [],
56. where: [],
57. order: [],
58. groupings: [],
59. parameters: [],
60. raw_where: []
61. };
62. }
63. Query.prototype.clone = function() {
64. var child, firstTable;
65. firstTable = this.s.tableStack[0][0];
66. child = new this.constructor(firstTable);
67. child.dialect = this.dialect;
68. child.resolve = this.resolve;
69. child.s = copy(this.s);
70. return child;
71. };
72. Query.prototype.aliasPair = function(table) {
73. var a, t;
74. if ('object' === typeof table && Object.keys(table).length === 1) {
75. return ((function() {
76. var _results;
77. _results = [];
78. for (a in table) {
79. t = table[a];
80. _results.push([t, a]);
81. }
82. return _results;
83. })())[0];
84. } else {
85. return [table, table];
86. }
87. };
88. Query.prototype.pushTable = function(table, alias, type, clause) {
89. var _base, _ref;
90. if (table === "t1t1") {
91. throw new Error("here");
92. }
93. if (type !== 'NOP') {
94. this.s.includedAliases[alias] = table;
95. if ((_ref = (_base = this.s.fields)[alias]) == null) {
96. _base[alias] = [];
97. }
98. }
99. return this.s.tableStack.push([table, alias, type, clause]);
100. };
101. Query.prototype.lastTable = function() {
102. return this.s.tableStack[this.s.tableStack.length - 1][1];
103. };
104. Query.prototype.includesAlias = function(a) {
105. return this.s.includedAliases[a];
106. };
107. Query.prototype.pushParams = function(clauses) {
108. var clause, _i, _len, _ref, _results;
109. _results = [];
110. for (_i = 0, _len = clauses.length; _i < _len; _i++) {
111. clause = clauses[_i];
112. _results.push(clause.op === 'multi' ? (sys.puts("pushParam recursing" + clause.clauses), this.pushParams(clause.clauses)) : clause.op === 'IN' ? (_ref = this.s.parameters).push.apply(_ref, clause.value) : this.s.parameters.push(clause.value));
113. }
114. return _results;
115. };
116. Query.prototype.visit = fluid(function(fn) {
117. if (fn != null) {
118. return fn.call(this, this);
119. }
120. });
121. Query.prototype.toSql = function() {
122. return this.dialect["render" + this.s.queryType](this.s);
123. };
124. Query.prototype.toString = function() {
125. return "[Query \"" + (this.toSql().substring(0, 20)) + "\"]";
126. };
127. Query.prototype.execute = function(conn, cb) {
128. if (conn['acquire'] != null) {
129. return conn.acquire(__bind(function(c) {
130. return this.execute(c, cb);
131. }, this));
132. } else {
133. return conn.query(this.toSql(), this.s.parameters, cb);
134. }
135. };
136. return Query;
137. })();
138. exports.Select = Select = (function() {
139. __extends(Select, Query);
140. function Select(table, opts) {
141. var alias, _ref;
142. if (opts == null) {
143. opts = {};
144. }
145. Select.__super__.constructor.call(this, opts);
146. this.s.queryType = 'Select';
147. _ref = this.aliasPair(table), table = _ref[0], alias = _ref[1];
148. this.pushTable(table, alias);
149. }
150. Select.prototype.from = fluid(function(alias) {
151. var table;
152. if (table = this.includesAlias(alias)) {
153. return this.pushTable(table, alias, 'NOP');
154. } else {
155. return unknown('table', table);
156. }
157. });
158. Select.prototype.fields = fluid(function() {
159. var alias, f, fields, _i, _len, _results;
160. fields = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
161. alias = this.lastTable();
162. _results = [];
163. for (_i = 0, _len = fields.length; _i < _len; _i++) {
164. f = fields[_i];
165. _results.push(this.s.fields[alias].push(f));
166. }
167. return _results;
168. });
169. Select.prototype.field = Select.fields;
170. Select.prototype.join = fluid(function(tbl, opts) {
171. var alias, clause, table, type, _ref;
172. if (opts == null) {
173. opts = {};
174. }
175. _ref = this.aliasPair(tbl), table = _ref[0], alias = _ref[1];
176. if (this.includesAlias(alias)) {
177. throw new Error("Table alias is not unique: " + alias);
178. }
179. type = this.dialect.joinType(opts.type);
180. clause = opts.on;
181. if (clause != null) {
182. if (clause.constructor !== Array) {
183. clause = [clause];
184. }
185. clause = normalize.clauses(clause, alias, this.dialect.joinOp);
186. if (clause.length > 1) {
187. clause = {
188. op: 'multi',
189. glue: ' AND ',
190. clauses: clause
191. };
192. } else {
193. clause = clause[0];
194. }
195. }
196. return this.pushTable(table, alias, type, clause);
197. });
198. Select.prototype.where = fluid(function(tbl, clause) {
199. var normalized, _ref;
200. if (!(clause != null)) {
201. clause = tbl;
202. tbl = this.lastTable();
203. }
204. if (this.includesAlias(tbl) == null) {
205. unknown('table', tbl);
206. }
207. normalized = normalize.clauses([clause], tbl, this.dialect.whereOp);
208. (_ref = this.s.where).push.apply(_ref, normalized);
209. return this.pushParams(normalized);
210. });
211. Select.prototype.or = fluid(function() {
212. var args, clauses;
213. args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
214. clauses = normalize.clauses(args, this.lastTable(), this.dialect.whereOp);
215. this.s.where.push({
216. op: 'multi',
217. glue: ' OR ',
218. clauses: clauses
219. });
220. return this.pushParams(clauses);
221. });
222. Select.prototype.orderBy = fluid(function() {
223. var args, orderings, _ref;
224. args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
225. orderings = normalize.orderings(args, this.lastTable(), this.dialect.order);
226. return (_ref = this.s.order).push.apply(_ref, orderings);
227. });
228. Select.prototype.groupBy = function() {
229. var field, fields, groupings, _ref;
230. fields = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
231. groupings = (function() {
232. var _i, _len, _results;
233. _results = [];
234. for (_i = 0, _len = fields.length; _i < _len; _i++) {
235. field = fields[_i];
236. _results.push(normalize.fieldAndTable({
237. table: this.lastTable(),
238. field: field
239. }));
240. }
241. return _results;
242. }).call(this);
243. return (_ref = this.s.groupings).push.apply(_ref, groupings);
244. };
245. Select.prototype.limit = fluid(function(l) {
246. return this.s.limit = l;
247. });
248. return Select;
249. })();
250. exports.normalize = normalize = {
251. clauses: function(clauses, table, normalizeOp) {
252. var clause, constraint, fld, normalized, op, val, _i, _len;
253. normalized = [];
254. for (_i = 0, _len = clauses.length; _i < _len; _i++) {
255. clause = clauses[_i];
256. for (fld in clause) {
257. constraint = clause[fld];
258. if ('object' === typeof constraint) {
259. for (op in constraint) {
260. val = constraint[op];
261. op = normalizeOp(op);
262. normalized.push(normalize.fieldAndTable({
263. field: fld,
264. op: op,
265. value: val,
266. table: table
267. }));
268. }
269. } else {
270. normalized.push(normalize.fieldAndTable({
271. field: fld,
272. op: '=',
273. value: constraint,
274. table: table
275. }));
276. }
277. }
278. }
279. return normalized;
280. },
281. orderings: function(orderings, table) {
282. var add, direction, field, normalized, ordering, _i, _len, _ref;
283. normalized = [];
284. add = function(field, direction) {
285. direction = (function() {
286. switch ((direction || '').toLowerCase()) {
287. case 'asc':
288. case 'ascending':
289. return 'ASC';
290. case 'desc':
291. case 'descending':
292. return 'DESC';
293. case '':
294. return '';
295. default:
296. throw new Error("Unsupported ordering direction " + direction);
297. }
298. })();
299. return normalized.push(normalize.fieldAndTable({
300. field: field,
301. table: table,
302. direction: direction
303. }));
304. };
305. for (_i = 0, _len = orderings.length; _i < _len; _i++) {
306. ordering = orderings[_i];
307. if ('string' === typeof ordering) {
308. _ref = ordering.split(/\ +/), field = _ref[0], direction = _ref[1];
309. add(field, direction);
310. } else {
311. for (field in ordering) {
312. direction = ordering[field];
313. add(field, direction);
314. }
315. }
316. }
317. return normalized;
318. },
319. fieldAndTable: function(normalized) {
320. var field, table, _ref;
321. _ref = normalized.field.split('.'), table = _ref[0], field = _ref[1];
322. if (field != null) {
323. normalized.table = table;
324. normalized.field = field;
325. }
326. return normalized;
327. }
328. };
329. exports.from = function(tbl, fields, opts) {
330. var select;
331. if (tbl.constructor === Select) {
332. throw new Error("Inner queries not supported yet");
333. }
334. if (!(opts != null) && (fields != null) && fields.constructor !== Array) {
335. opts = fields;
336. fields = null;
337. }
338. select = new Select(tbl, opts);
339. if (fields != null) {
340. select.fields.apply(select, fields);
341. }
342. return select;
343. };
344. }).call(this);

fluid.js

1. module.exports = function (fn) {
2. return function() {
3. fn.apply(this, arguments)
4. return this
5. }
6. }

mysql.js

1. (function() {
2. var AND, BOUND_PARAM, DEFAULT_JOIN, JOIN_TYPES, LITERAL, OR, QUOTED, fieldList, group, joins, limit, order, renderBoundParam, renderClause, sys, where;
3. var __indexOf = Array.prototype.indexOf || function(item) {
4. for (var i = 0, l = this.length; i < l; i++) {
5. if (this[i] === item) return i;
6. }
7. return -1;
8. };
9. sys = require('sys');
10. AND = ' AND ';
11. OR = ' OR ';
12. JOIN_TYPES = ['INNER', 'CROSS', 'FULL OUTER', 'LEFT', 'LEFT INNER', 'LEFT OUTER', 'RIGHT', 'RIGHT INNER', 'RIGHT OUTER'];
13. QUOTED = 'quoted';
14. LITERAL = 'literal';
15. BOUND_PARAM = '?';
16. DEFAULT_JOIN = "INNER";
17. exports.renderSelect = function(qs) {
18. var ret;
19. ret = "SELECT " + (fieldList(qs)) + " FROM ";
20. ret += joins(qs);
21. ret += where(qs);
22. ret += group(qs);
23. ret += order(qs);
24. return ret += limit(qs);
25. };
26. fieldList = function(qs) {
27. var fields, tbl, tbl_fields, _ref;
28. fields = [];
29. _ref = qs.fields;
30. for (tbl in _ref) {
31. tbl_fields = _ref[tbl];
32. if (tbl_fields.length) {
33. tbl_fields.forEach(function(f) {
34. return fields.push("" + tbl + "." + f);
35. });
36. } else {
37. fields.push("" + tbl + ".*");
38. }
39. }
40. return fields.join(', ');
41. };
42. joins = exports.joins = function(qs) {
43. var alias, clause, i, ret, table, tables, type;
44. i = 0;
45. tables = (function() {
46. var _i, _len, _ref, _ref2, _results;
47. _ref = qs.tableStack;
48. _results = [];
49. for (_i = 0, _len = _ref.length; _i < _len; _i++) {
50. _ref2 = _ref[_i], table = _ref2[0], alias = _ref2[1], type = _ref2[2], clause = _ref2[3];
51. if (type === 'NOP') {
52. continue;
53. }
54. ret = i++ ? "" + (type.toUpperCase()) + " JOIN " + table : table;
55. if (table !== alias) {
56. ret += " AS " + alias;
57. }
58. if (clause != null) {
59. ret += " ON " + (renderClause(clause, function(v) {
60. return v;
61. }));
62. }
63. _results.push(ret);
64. }
65. return _results;
66. })();
67. return tables.join(' ');
68. };
69. where = exports.where = function(qs) {
70. if (qs.where.length) {
71. return " WHERE " + (renderClause(qs.where));
72. } else {
73. return "";
74. }
75. };
76. group = exports.group = function(qs) {
77. if (qs.groupings.length) {
78. return " GROUP BY " + (qs.groupings.map(function(g) {
79. return g.table + '.' + g.field;
80. }).join(', '));
81. } else {
82. return "";
83. }
84. };
85. order = exports.order = function(qs) {
86. if (qs.order.length) {
87. return ' ORDER BY ' + qs.order.map(function(o) {
88. return o.table + '.' + o.field + (o.direction ? ' ' + o.direction : '');
89. }).join(', ');
90. } else {
91. return "";
92. }
93. };
94. limit = function(qs) {
95. if (qs.limit != null) {
96. return " LIMIT " + qs.limit;
97. } else {
98. return "";
99. }
100. };
101. renderBoundParam = function(v) {
102. if (v && v.constructor === Array) {
103. return "(" + (v.map(function() {
104. return BOUND_PARAM;
105. }).join(', ')) + ")";
106. } else {
107. return BOUND_PARAM;
108. }
109. };
110. exports.renderClause = renderClause = function(input, renderValue) {
111. var render;
112. if (renderValue == null) {
113. renderValue = renderBoundParam;
114. }
115. render = function(clause) {
116. if ((clause != null) && clause.constructor === Array) {
117. return "" + (clause.map(render).join(' AND '));
118. } else if (typeof clause === 'object') {
119. if (clause.op === 'multi') {
120. return "(" + (clause.clauses.map(render).join(clause.glue)) + ")";
121. } else {
122. return "" + clause.table + "." + clause.field + " " + clause.op + " " + (renderValue(clause.value));
123. }
124. } else {
125. throw new Error("Unexpected clause type, this is probably a bug");
126. }
127. };
128. return render(input);
129. };
130. exports.joinOp = exports.whereOp = function(op) {
131. switch (op.toLowerCase()) {
132. case 'ne':
133. case '!=':
134. case '<>':
135. return '!=';
136. case 'eq':
137. case '=':
138. return '=';
139. case 'lt':
140. case '<':
141. return '<';
142. case 'gt':
143. case '>':
144. return '>';
145. case 'lte':
146. case '<=':
147. return '<=';
148. case 'gte':
149. case '>=':
150. return '>=';
151. case 'in':
152. return 'IN';
153. default:
154. throw new Error("Unsupported comparison operator: " + op);
155. }
156. };
157. exports.joinType = function(type) {
158. if (type == null) {
159. return DEFAULT_JOIN;
160. }
161. type = type.toUpperCase();
162. if (__indexOf.call(JOIN_TYPES, type) >= 0) {
163. return type;
164. }
165. throw new Error("Unsupported join type: " + type);
166. };
167. }).call(this);