464 lines
16 KiB
JavaScript
464 lines
16 KiB
JavaScript
this.recline = this.recline || {};
|
|
this.recline.Backend = this.recline.Backend || {};
|
|
this.recline.Backend.CouchDB = this.recline.Backend.CouchDB || {};
|
|
|
|
(function($, my) {
|
|
// ## CouchDB Wrapper
|
|
//
|
|
// Connecting to [CouchDB] (http://www.couchdb.apache.org/) endpoints.
|
|
// @param {String} endpoint: url for CouchDB database, e.g. for Couchdb running
|
|
// on localhost:5984 with database // ckan-std it would be:
|
|
//
|
|
// <pre>http://localhost:5984/ckan-std</pre>
|
|
//
|
|
// TODO Add user/password arguments for couchdb authentication support.
|
|
my.CouchDBWrapper = function(db_url, view_url, options) {
|
|
var self = this;
|
|
this.endpoint = db_url;
|
|
this.view_url = (view_url) ? view_url : db_url+'/'+'_all_docs';
|
|
this.options = _.extend({
|
|
dataType: 'json'
|
|
},
|
|
options);
|
|
|
|
this._makeRequest = function(data, headers) {
|
|
var extras = {};
|
|
if (headers) {
|
|
extras = {
|
|
beforeSend: function(req) {
|
|
_.each(headers, function(value, key) {
|
|
req.setRequestHeader(key, value);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
var data = _.extend(extras, data);
|
|
return $.ajax(data);
|
|
};
|
|
|
|
// ### mapping
|
|
//
|
|
// Get mapping for this database.
|
|
// Assume all docs in the view have the same schema so
|
|
// limit query to single result.
|
|
//
|
|
// @return promise compatible deferred object.
|
|
this.mapping = function() {
|
|
var schemaUrl = self.view_url + '?limit=1&include_docs=true';
|
|
var jqxhr = this._makeRequest({
|
|
url: schemaUrl,
|
|
dataType: this.options.dataType
|
|
});
|
|
return jqxhr;
|
|
};
|
|
|
|
// ### get
|
|
//
|
|
// Get record corresponding to specified id
|
|
//
|
|
// @return promise compatible deferred object.
|
|
this.get = function(_id) {
|
|
var base = this.endpoint + '/' + _id;
|
|
return this._makeRequest({
|
|
url: base,
|
|
dataType: 'json'
|
|
});
|
|
};
|
|
|
|
// ### upsert
|
|
//
|
|
// create / update a record to CouchDB backend
|
|
//
|
|
// @param {Object} doc an object to insert to the index.
|
|
// @return deferred supporting promise API
|
|
this.upsert = function(doc) {
|
|
var data = JSON.stringify(doc);
|
|
url = this.endpoint;
|
|
if (doc._id) {
|
|
url += '/' + doc._id;
|
|
}
|
|
// use a PUT, not a POST to update the document:
|
|
// http://wiki.apache.org/couchdb/HTTP_Document_API#POST
|
|
return this._makeRequest({
|
|
url: url,
|
|
type: 'PUT',
|
|
data: data,
|
|
dataType: 'json',
|
|
contentType: 'application/json'
|
|
});
|
|
};
|
|
|
|
// ### delete
|
|
//
|
|
// Delete a record from the CouchDB backend.
|
|
//
|
|
// @param {Object} id id of object to delete
|
|
// @return deferred supporting promise API
|
|
this.delete = function(_id) {
|
|
url = this.endpoint;
|
|
url += '/' + _id;
|
|
return this._makeRequest({
|
|
url: url,
|
|
type: 'DELETE',
|
|
dataType: 'json'
|
|
});
|
|
};
|
|
|
|
// ### _normalizeQuery
|
|
//
|
|
// Convert the query object from Elastic Search format to a
|
|
// Couchdb View API compatible format.
|
|
// See: http://wiki.apache.org/couchdb/HTTP_view_API
|
|
//
|
|
this._normalizeQuery = function(queryObj) {
|
|
var out = queryObj && queryObj.toJSON ? queryObj.toJSON() : _.extend({}, queryObj);
|
|
delete out.sort;
|
|
delete out.query;
|
|
delete out.filters;
|
|
delete out.fields;
|
|
delete out.facets;
|
|
out['skip'] = out.from || 0;
|
|
out['limit'] = out.size || 100;
|
|
delete out.from;
|
|
delete out.size;
|
|
out['include_docs'] = true;
|
|
return out;
|
|
};
|
|
|
|
// ### query
|
|
//
|
|
// @param {Object} recline.Query instance.
|
|
// @param {Object} additional couchdb view query options.
|
|
// @return deferred supporting promise API
|
|
this.query = function(query_object, query_options) {
|
|
var norm_q = this._normalizeQuery(query_object);
|
|
var url = this.view_url;
|
|
var q = _.extend(query_options, norm_q);
|
|
|
|
var jqxhr = this._makeRequest({
|
|
url: url,
|
|
data: JSON.stringify(q),
|
|
dataType: this.options.dataType,
|
|
});
|
|
return jqxhr;
|
|
}
|
|
};
|
|
|
|
// ## CouchDB Backend
|
|
//
|
|
// Backbone connector for a CouchDB backend.
|
|
//
|
|
// Usage:
|
|
//
|
|
// var backend = new recline.Backend.CouchDB({
|
|
// db_url: '/couchdb/mydb',
|
|
// view_url: '/couchdb/mydb/_design/design1/_views/view1',
|
|
// query_options: {
|
|
// 'key': 'some_document_key'
|
|
// }
|
|
// });
|
|
//
|
|
// If these options are not passed to the constructor, the model
|
|
// object is checked for the presence of these arguments.
|
|
//
|
|
// Additionally, the Dataset instance may define two methods:
|
|
// function record_update (record, document) { ... }
|
|
// function record_delete (record, document) { ... }
|
|
// Where `record` is the JSON representation of the Record/Document instance
|
|
// and `document` is the JSON document stored in couchdb.
|
|
// When _all_docs view is used (default), a record is the same as a document
|
|
// so these methods need not be defined.
|
|
// They are most useful when using a custom view that performs a map-reduce
|
|
// operation on each document to yield a record. Hence, when the record is
|
|
// updated or deleted, an inverse operation must be performed on the original
|
|
// document.
|
|
//
|
|
// @param {string} url of couchdb database.
|
|
// @param {string} (optional) url of couchdb view. default:`db_url`/_all_docs
|
|
// @param {Object} (optional) query options accepted by couchdb views.
|
|
// @param {string} (optional) url of Elastic Search engine.
|
|
//
|
|
my.Backbone = function(options) {
|
|
var self = this;
|
|
this.__type__ ='couchdb';
|
|
this.db_url = options['db_url'] || '';
|
|
this.view_url = options['view_url'] || this.db_url + '/_all_docs';
|
|
this.query_options = options['query_options'] || {};
|
|
|
|
// ### sync
|
|
//
|
|
// Backbone sync implementation for this backend.
|
|
//
|
|
this.sync = function (method, model, options) {
|
|
var dataset = null
|
|
if (model.__type__ == 'Dataset')
|
|
dataset = model;
|
|
else
|
|
dataset = model.dataset;
|
|
|
|
var db_url = dataset.get('db_url') || self.db_url;
|
|
var view_url = dataset.get('view_url') || self.view_url;
|
|
var query_options = dataset.get('query_options') || self.query_options;
|
|
|
|
var cdb = new my.CouchDBWrapper(db_url, view_url);
|
|
|
|
if (method === "read") {
|
|
if (model.__type__ == 'Dataset') {
|
|
var dfd = $.Deferred();
|
|
|
|
// if 'doc' attribute is present, return schema of that
|
|
// else return schema of 'value' attribute which contains
|
|
// the map-reduce document.
|
|
cdb.mapping().done(function(result) {
|
|
var row = result.rows[0];
|
|
var keys = [];
|
|
if (view_url.search("_all_docs") !== -1) {
|
|
keys = _.keys(row['doc']);
|
|
keys = _.filter(keys, function (k) { return k.charAt(0) !== '_' });
|
|
}
|
|
else {
|
|
keys = _.keys(row['value']);
|
|
}
|
|
|
|
var fieldData = _.map(keys, function(k) {
|
|
return { 'id' : k };
|
|
});
|
|
model.fields.reset(fieldData);
|
|
|
|
dfd.resolve(model);
|
|
})
|
|
.fail(function(arguments) {
|
|
dfd.reject(arguments);
|
|
});
|
|
return dfd.promise();
|
|
} else if (model.__type__ == 'Record' || model.__type__ == 'Document') {
|
|
if (view_url.search("_all_docs") !== -1) {
|
|
return cdb.get(model.get('_id'));
|
|
}
|
|
else {
|
|
var dfd = $.Deferred();
|
|
// decompose _id
|
|
var id = model.get('_id').split('__')[0];
|
|
var key = model.get('_id').split('__')[1];
|
|
var jqxhr = cdb.query(model.dataset.get('query_options'));
|
|
|
|
jqxhr.done(function(records) {
|
|
var doc = {};
|
|
var rec = _.filter(records, function (record) {
|
|
record['id'] == id && record['key'] == key;
|
|
});
|
|
doc = rec[0]; // XXX check len first
|
|
doc['id'] = doc['_id'] = model.get('_id');
|
|
dfd.resolve(doc);
|
|
}).fail(function(args) {
|
|
dfd.reject(args);
|
|
});
|
|
return dfd.promise();
|
|
}
|
|
}
|
|
} else if (method === 'update') {
|
|
if (model.__type__ == 'Record' || model.__type__ == 'Document') {
|
|
var dfd = $.Deferred();
|
|
var _id = null;
|
|
var jqxhr;
|
|
var new_doc = model.toJSON();
|
|
// couchdb uses _id to identify documents, Backbone models use id.
|
|
// we should remove it before sending it to the server.
|
|
delete new_doc['id'];
|
|
if (view_url.search('_all_docs') !== -1) {
|
|
_id = model.get('_id');
|
|
jqxhr = cdb.get(_id);
|
|
}
|
|
else {
|
|
_id = model.get('_id').split('__')[0];
|
|
jqxhr = cdb.get(_id);
|
|
}
|
|
|
|
jqxhr.done(function(old_doc){
|
|
if (model.dataset.record_update)
|
|
new_doc = model.dataset.record_update(new_doc, old_doc);
|
|
new_doc = _.extend(old_doc, new_doc);
|
|
new_doc['_id'] = _id;
|
|
// XXX upsert can fail during a bulk column transform due to revision conflict.
|
|
// the correct way to handle bulk column transforms is to use
|
|
// a queue which is processed by a web worker.
|
|
dfd.resolve(cdb.upsert(new_doc));
|
|
}).fail(function(args){
|
|
dfd.reject(args);
|
|
});
|
|
|
|
return dfd.promise();
|
|
}
|
|
} else if (method === 'delete') {
|
|
if (model.__type__ == 'Record' || model.__type__ == 'Document') {
|
|
if (view_url.search('_all_docs') !== -1)
|
|
return cdb.delete(model.get('_id'));
|
|
else {
|
|
var dfd = $.Deferred();
|
|
var _id = model.get('_id').split('__')[0];
|
|
var new_doc = null;
|
|
var jqxhr = cdb.get(_id);
|
|
|
|
jqxhr.done(function(old_doc){
|
|
if (model.dataset.record_delete)
|
|
new_doc = model.dataset.record_delete(model.toJSON(), old_doc);
|
|
if (_.isNull(new_doc))
|
|
dfd.resolve(cdb.delete(_id)); // XXX is this the right thing to do?
|
|
else {
|
|
// couchdb uses _id to identify documents, Backbone models use id.
|
|
// we should remove it before sending it to the server.
|
|
new_doc['_id'] = _id;
|
|
delete new_doc['id'];
|
|
dfd.resolve(cdb.upsert(new_doc));
|
|
}
|
|
}).fail(function(args){
|
|
dfd.reject(args);
|
|
});
|
|
return dfd.promise();
|
|
}
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
// ### query
|
|
//
|
|
// fetch the data from the couchdb view and filter it.
|
|
// @param {Object} recline.Dataset instance
|
|
// @param {Object} recline.Query instance.
|
|
this.query = function(model, queryObj) {
|
|
var dfd = $.Deferred();
|
|
var db_url = model.get('db_url') || self.db_url;
|
|
var view_url = model.get('view_url') || self.view_url;
|
|
var query_options = model.get('query_options') || self.query_options;
|
|
|
|
var cdb = new my.CouchDBWrapper(db_url, view_url);
|
|
var cdb_q = cdb._normalizeQuery(queryObj, query_options);
|
|
|
|
cdb.query(queryObj, query_options).done(function(records){
|
|
|
|
var query_result = { hits: [], total: 0 };
|
|
_.each(records.rows, function(record) {
|
|
var doc = {};
|
|
if (record.hasOwnProperty('doc')) {
|
|
doc['_source'] = record['doc'];
|
|
// couchdb uses _id to identify documents, Backbone models use id.
|
|
// we add this fix so backbone.Model works correctly.
|
|
doc['_source']['id'] = doc['_source']['_id'];
|
|
}
|
|
else {
|
|
doc['_source'] = record['value'];
|
|
// using dunder to create compound id. need something more robust.
|
|
doc['_source']['_id'] = record['id'] + '__' + record['key'];
|
|
// couchdb uses _id to identify documents, Backbone models use id.
|
|
// we add this fix so backbone.Model works correctly.
|
|
doc['_source']['id'] = doc['_source']['_id'];
|
|
}
|
|
query_result.total += 1;
|
|
query_result.hits.push(doc);
|
|
});
|
|
|
|
// the following block is borrowed verbatim from recline.backend.Memory
|
|
// search (with filtering, faceting, and sorting) should be factored
|
|
// out into a separate library.
|
|
query_result.hits = self._applyFilters(query_result.hits, queryObj);
|
|
query_result.hits = self._applyFreeTextQuery(query_result.hits, queryObj);
|
|
// not complete sorting!
|
|
_.each(queryObj.sort, function(sortObj) {
|
|
var fieldName = _.keys(sortObj)[0];
|
|
query_result.hits = _.sortBy(query_result.hits, function(doc) {
|
|
var _out = doc[fieldName];
|
|
return (sortObj[fieldName].order == 'asc') ? _out : -1*_out;
|
|
});
|
|
});
|
|
query_result.total = query_result.hits.length;
|
|
query_result.facets = self.computeFacets(query_result.hits, queryObj);
|
|
query_result.hits = query_result.hits.slice(cdb_q.skip, cdb_q.skip + cdb_q.limit+1);
|
|
dfd.resolve(query_result);
|
|
|
|
});
|
|
|
|
return dfd.promise();
|
|
},
|
|
|
|
// in place filtering
|
|
_applyFilters: function(results, queryObj) {
|
|
_.each(queryObj.filters, function(filter) {
|
|
results = _.filter(results, function(doc) {
|
|
var fieldId = _.keys(filter.term)[0];
|
|
return (doc['_source'][fieldId] == filter.term[fieldId]);
|
|
});
|
|
});
|
|
return results;
|
|
},
|
|
|
|
// we OR across fields but AND across terms in query string
|
|
_applyFreeTextQuery: function(results, queryObj) {
|
|
if (queryObj.q) {
|
|
var terms = queryObj.q.split(' ');
|
|
results = _.filter(results, function(rawdoc) {
|
|
rawdoc = rawdoc['_source'];
|
|
var matches = true;
|
|
_.each(terms, function(term) {
|
|
var foundmatch = false;
|
|
//_.each(self.fields, function(field) {
|
|
_.each(_.keys(rawdoc), function(field) {
|
|
var value = rawdoc[field];
|
|
if (value !== null) { value = value.toString(); }
|
|
// TODO regexes?
|
|
foundmatch = foundmatch || (value === term);
|
|
// TODO: early out (once we are true should break to spare unnecessary testing)
|
|
// if (foundmatch) return true;
|
|
});
|
|
matches = matches && foundmatch;
|
|
// TODO: early out (once false should break to spare unnecessary testing)
|
|
// if (!matches) return false;
|
|
});
|
|
return matches;
|
|
});
|
|
}
|
|
return results;
|
|
},
|
|
|
|
computeFacets: function(records, queryObj) {
|
|
var facetResults = {};
|
|
if (!queryObj.facets) {
|
|
return facetResults;
|
|
}
|
|
_.each(queryObj.facets, function(query, facetId) {
|
|
// TODO: remove dependency on recline.Model
|
|
facetResults[facetId] = new recline.Model.Facet({id: facetId}).toJSON();
|
|
facetResults[facetId].termsall = {};
|
|
});
|
|
// faceting
|
|
_.each(records, function(doc) {
|
|
_.each(queryObj.facets, function(query, facetId) {
|
|
var fieldId = query.terms.field;
|
|
var val = doc['_source'][fieldId];
|
|
var tmp = facetResults[facetId];
|
|
if (val) {
|
|
tmp.termsall[val] = tmp.termsall[val] ? tmp.termsall[val] + 1 : 1;
|
|
} else {
|
|
tmp.missing = tmp.missing + 1;
|
|
}
|
|
});
|
|
});
|
|
_.each(queryObj.facets, function(query, facetId) {
|
|
var tmp = facetResults[facetId];
|
|
var terms = _.map(tmp.termsall, function(count, term) {
|
|
return { term: term, count: count };
|
|
});
|
|
tmp.terms = _.sortBy(terms, function(item) {
|
|
// want descending order
|
|
return -item.count;
|
|
});
|
|
tmp.terms = tmp.terms.slice(0, 10);
|
|
});
|
|
return facetResults;
|
|
},
|
|
|
|
|
|
});
|
|
|
|
}(jQuery, this.recline.Backend.CouchDB));
|