index.js

1. (function() {
2. var query, queryType, _i, _len, _ref;
3. exports.dialects = require('./dialects');
4. exports.DEFAULT = require('./dialects/common').DEFAULT;
5. String.prototype.ucfirst = function() {
6. return this[0].toUpperCase() + this.slice(1);
7. };
8. _ref = ['select', 'insert'];
9. for (_i = 0, _len = _ref.length; _i < _len; _i++) {
10. queryType = _ref[_i];
11. query = require("./" + queryType);
12. exports[queryType] = exports[queryType.toUpperCase()] = exports[queryType.ucfirst()] = query;
13. }
14. }).call(this);

dialects/index.js

1. (function() {
2. module.exports = {
3. mysql: require('./mysql'),
4. "default": require('./mysql'),
5. JOIN_TYPES: require('./common').JOIN_TYPES
6. };
7. }).call(this);

dialects/mysql.js

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

dialects/common.js

1. (function() {
2. exports.JOIN_TYPES = ['INNER', 'LEFT INNER', 'RIGHT INNER', 'OUTER', 'LEFT OUTER', 'RIGHT OUTER', 'FULL OUTER', 'NATURAL'];
3. exports.DEFAULT = "I'll be a UUID one day";
4. }).call(this);

select.js

1. (function() {
2. var SUDQuery, Select, fluid, normalize;
3. var __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. SUDQuery = require('./sud-query');
13. normalize = require('./normalize');
14. module.exports = Select = (function() {
15. __extends(Select, SUDQuery);
16. function Select(table, opts) {
17. if (opts == null) {
18. opts = {};
19. }
20. Select.__super__.constructor.call(this, table, opts);
21. this.s.queryType = 'Select';
22. this.s.order = [];
23. this.s.groupings = [];
24. }
25. Select.prototype.orderBy = fluid(function() {
26. var args, orderings, _ref;
27. args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
28. orderings = normalize.orderings(args, this.lastTable(), this.dialect.order);
29. return (_ref = this.s.order).push.apply(_ref, orderings);
30. });
31. Select.prototype.groupBy = function() {
32. var field, fields, groupings, _ref;
33. fields = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
34. groupings = (function() {
35. var _i, _len, _results;
36. _results = [];
37. for (_i = 0, _len = fields.length; _i < _len; _i++) {
38. field = fields[_i];
39. _results.push(normalize.fieldAndTable({
40. table: this.lastTable(),
41. field: field
42. }));
43. }
44. return _results;
45. }).call(this);
46. return (_ref = this.s.groupings).push.apply(_ref, groupings);
47. };
48. Select.prototype.limit = fluid(function(l) {
49. return this.s.limit = l;
50. });
51. return Select;
52. })();
53. Select.from = function(tbl, fields, opts) {
54. var select, _ref;
55. if (tbl.constructor === Select) {
56. throw new Error("Inner queries not supported yet");
57. }
58. if ((fields != null) && ((_ref = fields.constructor) !== String && _ref !== Array)) {
59. opts = fields;
60. fields = null;
61. }
62. select = new Select(tbl, opts);
63. if (fields != null) {
64. switch (fields.constructor) {
65. case String:
66. select.fields(fields);
67. break;
68. case Array:
69. select.fields.apply(select, fields);
70. }
71. }
72. return select;
73. };
74. }).call(this);

fluid.js

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

sud-query.js

1. (function() {
2. var Query, SUDQuery, fluid, normalize, unknown;
3. var __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. Query = require('./base-query');
13. normalize = require('./normalize');
14. module.exports = SUDQuery = (function() {
15. __extends(SUDQuery, Query);
16. function SUDQuery(table, opts) {
17. var alias, _ref;
18. SUDQuery.__super__.constructor.call(this, opts);
19. this.s.fields = {};
20. this.s.includedAliases = {};
21. this.s.tableStack = [];
22. this.s.where = [];
23. this.s.parameters = [];
24. if (table != null) {
25. _ref = this.aliasPair(table), table = _ref[0], alias = _ref[1];
26. this.s.fields[alias] = [];
27. this.pushTable(table, alias);
28. }
29. }
30. SUDQuery.prototype.fields = fluid(function() {
31. var al, alias, f, field, fields, n, table, _base, _i, _len, _name, _ref, _ref2, _results;
32. fields = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
33. alias = !(fields[1] && fields[1].constructor === Array) ? this.lastTable() : ((_ref = this.aliasPair(fields.shift()), table = _ref[0], al = _ref[1], _ref), !this.includesAlias(al) ? unknown('table', table) : void 0);
34. if (fields.length === 0) {
35. return this.s.fields[alias] = null;
36. }
37. _results = [];
38. for (_i = 0, _len = fields.length; _i < _len; _i++) {
39. f = fields[_i];
40. n = normalize.fieldAndTable({
41. table: alias,
42. field: f
43. });
44. field = this.resolve.field(n.table, n.field);
45. if ((_ref2 = (_base = this.s.fields)[_name = n.table]) == null) {
46. _base[_name] = [];
47. }
48. _results.push(this.s.fields[n.table].push(field));
49. }
50. return _results;
51. });
52. SUDQuery.prototype.field = SUDQuery.fields;
53. SUDQuery.prototype.join = fluid(function(tbl, opts) {
54. var alias, clause, table, type, _ref;
55. if (opts == null) {
56. opts = {};
57. }
58. _ref = this.aliasPair(tbl), table = _ref[0], alias = _ref[1];
59. if (this.includesAlias(alias)) {
60. throw new Error("Table alias is not unique: " + alias);
61. }
62. type = this.dialect.joinType(opts.type);
63. if ((clause = opts.on) != null) {
64. if (clause.constructor !== Array) {
65. clause = [clause];
66. }
67. clause = normalize.clauses(clause, alias, this.dialect.joinOp);
68. if (clause.length > 1) {
69. clause = {
70. op: 'multi',
71. glue: ' AND ',
72. clauses: clause
73. };
74. } else {
75. clause = clause[0];
76. }
77. }
78. this.pushTable(table, alias, type, clause);
79. if (opts.fields != null) {
80. return this.fields.apply(this, opts.fields);
81. }
82. });
83. SUDQuery.prototype.from = fluid(function(alias) {
84. var table;
85. if (table = this.includesAlias(alias)) {
86. return this.pushTable(table, alias, 'NOP');
87. } else {
88. return unknown('table', table);
89. }
90. });
91. SUDQuery.prototype.where = fluid(function(alias, clause) {
92. var normalized, table, _ref, _ref2;
93. if (!(clause != null)) {
94. clause = alias;
95. alias = this.lastTable();
96. } else {
97. _ref = this.aliasPair(alias), table = _ref[0], alias = _ref[1];
98. }
99. if (this.includesAlias(alias) == null) {
100. unknown('table', tbl);
101. }
102. normalized = normalize.clauses([clause], alias, this.dialect.whereOp);
103. (_ref2 = this.s.where).push.apply(_ref2, normalized);
104. return this.pushParams(normalized);
105. });
106. SUDQuery.prototype.or = fluid(function() {
107. var args, clauses;
108. args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
109. clauses = normalize.clauses(args, this.lastTable(), this.dialect.whereOp);
110. this.s.where.push({
111. op: 'multi',
112. glue: ' OR ',
113. clauses: clauses
114. });
115. return this.pushParams(clauses);
116. });
117. SUDQuery.prototype.aliasPair = function(table) {
118. var a, t;
119. if ('object' === typeof table && Object.keys(table).length === 1) {
120. return ((function() {
121. var _results;
122. _results = [];
123. for (a in table) {
124. t = table[a];
125. _results.push([this.resolve.table(t), a]);
126. }
127. return _results;
128. }).call(this))[0];
129. } else {
130. t = this.resolve.table(table);
131. return [t, t];
132. }
133. };
134. SUDQuery.prototype.pushTable = function(table, alias, type, clause) {
135. if (table === "t1t1") {
136. throw new Error("here");
137. }
138. if (type !== 'NOP') {
139. this.s.includedAliases[alias] = table;
140. }
141. return this.s.tableStack.push([table, alias, type, clause]);
142. };
143. SUDQuery.prototype.pushParams = function(clauses) {
144. var clause, _i, _len, _ref, _results;
145. _results = [];
146. for (_i = 0, _len = clauses.length; _i < _len; _i++) {
147. clause = clauses[_i];
148. _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));
149. }
150. return _results;
151. };
152. SUDQuery.prototype.lastTable = function() {
153. return this.s.tableStack[this.s.tableStack.length - 1][1];
154. };
155. SUDQuery.prototype.includesAlias = function(a) {
156. return this.s.includedAliases[a];
157. };
158. return SUDQuery;
159. })();
160. unknown = function(type, val) {
161. throw new Error("Unknown " + type + ": " + val);
162. };
163. }).call(this);

base-query.js

1. (function() {
2. var Query, copy, dialects, fluid, passthrough_resolver;
3. var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
4. fluid = require('./fluid');
5. dialects = require('./dialects');
6. module.exports = Query = (function() {
7. function Query(opts) {
8. this.dialect = opts.dialect || dialects["default"];
9. this.resolve = opts.resolver || passthrough_resolver;
10. this.s = {};
11. }
12. Query.prototype.clone = function() {
13. var child;
14. child = new this.constructor;
15. child.dialect = this.dialect;
16. child.resolve = this.resolve;
17. child.s = copy(this.s);
18. return child;
19. };
20. Query.prototype.visit = fluid(function(fn) {
21. if (fn != null) {
22. return fn.call(this, this);
23. }
24. });
25. Query.prototype.toSql = function() {
26. return this.dialect["render" + this.s.queryType](this.s);
27. };
28. Query.prototype.execute = function(conn, cb) {
29. if (conn['acquire'] != null) {
30. return conn.acquire(__bind(function(c) {
31. return this.execute(c, cb);
32. }, this));
33. } else {
34. return conn.query(this.toSql(), this.s.parameters, cb);
35. }
36. };
37. Query.prototype.toString = function() {
38. return "[Query \"" + (this.toSql().substring(0, 20)) + "\"]";
39. };
40. return Query;
41. })();
42. passthrough_resolver = {
43. table: function(n) {
44. return n;
45. },
46. field: function(t, n) {
47. return n;
48. }
49. };
50. copy = function(thing) {
51. var c, k, obj, v;
52. if (thing === null) {
53. return null;
54. } else if (thing.constructor === Array) {
55. c = [];
56. c.push.apply(c, thing);
57. return c;
58. } else if ('object' === typeof thing) {
59. obj = {};
60. for (k in thing) {
61. v = thing[k];
62. obj[k] = copy(v);
63. }
64. return obj;
65. } else {
66. return thing;
67. }
68. };
69. }).call(this);

normalize.js

1. (function() {
2. var norm;
3. module.exports = norm = {
4. clauses: function(clauses, table, normalizeOp) {
5. var clause, constraint, fld, normalized, op, val, _i, _len;
6. normalized = [];
7. for (_i = 0, _len = clauses.length; _i < _len; _i++) {
8. clause = clauses[_i];
9. for (fld in clause) {
10. constraint = clause[fld];
11. if ('object' === typeof constraint) {
12. for (op in constraint) {
13. val = constraint[op];
14. op = normalizeOp(op);
15. normalized.push(norm.fieldAndTable({
16. field: fld,
17. op: op,
18. value: val,
19. table: table
20. }));
21. }
22. } else {
23. normalized.push(norm.fieldAndTable({
24. field: fld,
25. op: '=',
26. value: constraint,
27. table: table
28. }));
29. }
30. }
31. }
32. return normalized;
33. },
34. orderings: function(orderings, table) {
35. var add, direction, field, normalized, ordering, _i, _len, _ref;
36. normalized = [];
37. add = function(field, direction) {
38. direction = (function() {
39. switch ((direction || '').toLowerCase()) {
40. case 'asc':
41. case 'ascending':
42. return 'ASC';
43. case 'desc':
44. case 'descending':
45. return 'DESC';
46. case '':
47. return '';
48. default:
49. throw new Error("Unsupported ordering direction " + direction);
50. }
51. })();
52. return normalized.push(norm.fieldAndTable({
53. field: field,
54. table: table,
55. direction: direction
56. }));
57. };
58. for (_i = 0, _len = orderings.length; _i < _len; _i++) {
59. ordering = orderings[_i];
60. if ('string' === typeof ordering) {
61. _ref = ordering.split(/\ +/), field = _ref[0], direction = _ref[1];
62. add(field, direction);
63. } else {
64. for (field in ordering) {
65. direction = ordering[field];
66. add(field, direction);
67. }
68. }
69. }
70. return normalized;
71. },
72. fieldAndTable: function(tableField) {
73. var field, table, _ref;
74. _ref = tableField.field.split('.'), table = _ref[0], field = _ref[1];
75. if (field != null) {
76. tableField.table = table;
77. tableField.field = field;
78. }
79. return tableField;
80. }
81. };
82. }).call(this);

insert.js

1. (function() {
2. var DEFAULT, Insert, Query, fluid;
3. var __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. Query = require('./base-query');
13. DEFAULT = require('./dialects/common').DEFAULT;
14. module.exports = Insert = (function() {
15. var reset;
16. __extends(Insert, Query);
17. reset = function(fn) {
18. return function() {
19. var args;
20. args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
21. this.s.fields = [];
22. this.s.parameters = [];
23. return fn.apply(null, args);
24. };
25. };
26. function Insert(table, opts) {
27. if (opts == null) {
28. opts = {};
29. }
30. Insert.__super__.constructor.call(this, opts);
31. this.s.queryType = 'Insert';
32. this.s.table = this.resolve.table(table);
33. this.s.fields = [];
34. this.s.parameters = [];
35. }
36. Insert.prototype.fields = fluid(function() {
37. var fields;
38. fields = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
39. return this.s.fields = fields;
40. });
41. Insert.prototype.addRows = fluid(function() {
42. var row, rows, _i, _len, _results;
43. rows = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
44. _results = [];
45. for (_i = 0, _len = rows.length; _i < _len; _i++) {
46. row = rows[_i];
47. _results.push(row.constructor === Array ? this.addRowArray(row) : this.addRowObject(row));
48. }
49. return _results;
50. });
51. Insert.prototype.addRow = function(row) {
52. return this.addRows(row);
53. };
54. Insert.prototype.addRowArray = function(row) {
55. var count, _ref;
56. if (this.s.fields != null) {
57. count = this.s.fields.length;
58. }
59. if (!count) {
60. throw new Error("Cannot insert from array without first setting fields");
61. }
62. if (row.length !== count) {
63. throw new Error("Wrong number of values in array, expected " + this.s.fields);
64. }
65. return (_ref = this.s.parameters).push.apply(_ref, row);
66. };
67. Insert.prototype.checkFields = function(cb) {};
68. Insert.prototype.addRowObject = function(row) {
69. var array, f, _ref;
70. if (!this.s.fields || this.s.fields.length === 0) {
71. this.s.fields = Object.keys(row);
72. }
73. array = (function() {
74. var _i, _len, _ref, _results;
75. _ref = this.s.fields;
76. _results = [];
77. for (_i = 0, _len = _ref.length; _i < _len; _i++) {
78. f = _ref[_i];
79. _results.push((row[f] != null) || row[f] === null ? row[f] : DEFAULT);
80. }
81. return _results;
82. }).call(this);
83. return (_ref = this.s.parameters).push.apply(_ref, array);
84. };
85. Insert.prototype.fromQuery = fluid(function(query) {
86. this.s.queryType = 'InsertSelect';
87. return this.s.fromQuery = query;
88. });
89. return Insert;
90. })();
91. Insert.into = function(tbl, opts) {
92. return new Insert(tbl, opts);
93. };
94. }).call(this);