Elasticsearch Javascript API增删改查

查询

根据索引、类型、id进行查询：

client.get({
index:'myindex',
type:'mytype',
id:1
},function(error, response){// ...});

根据某个查询条件，查询某个索引的所有数据

client.search({
index:'myindex',
q:'title:test'
},function(error, response){// ...});

复杂一点的查询：

client.search({
index:'myindex',
body:{
query:{
match:{
title:'test'
}
},
facets:{
tags:{
terms:{
field:'tags'
}
}
}
}
},function(error, response){// ...});

新增

新增时，需要指定索引，类型，和id，还有保存的内容：

client.create({
index:'myindex',
type:'mytype',
id:'1',
body:{
title:'Test 1',
tags:['y','z'],
published:true,
published_at:'2013-01-01', counter:1
}
},function(error, response){// ...});

删除

按照索引，类型和id删除：

client.delete({
index:'myindex',
type:'mytype',
id:'1'
},function(error, response){// ...});

修改

修改操作通常使用update方法:

client.update({
index:'myindex',
type:'mytype',
id:'1',
body:{
// put the partial document under the `doc` key
doc:{
title:'Updated'
}
}
},function(error, response){// ...})

一次性执行多个操作

ESClient也支持一次性执行多个操作：

client.mget({
body:{
docs:[ {
_index:'indexA', _type:'typeA', _id:'1'
},{
_index:'indexB', _type:'typeB', _id:'1'
},{
_index:'indexC', _type:'typeC', _id:'1'
}]
}
},function(error, response){// ...});

也支持下面的风格：

client.mget({
index:'myindex',
type:'mytype',
body:{ ids:[1,2,3]}
},function(error, response){// ...});

类似的也可以同时执行多个查询：

client.msearch({
body:[
// match all query, on all indices and types
{},
{ query:{ match_all:{}}},
// query_string query, on index/mytype
{
_index:'myindex',
_type:'mytype'
},{
query:{
query_string:{ query:'"Test 1"'}
}
}]
});

扩展

通过上面基本API的使用，基本可以了解js端对ESclient的操作。当然也可以使用下面的变成风格调用方法：

es[method](params)
它类似
es.method(params,回调方法)

在kibana中的_doc_send_to_es.js，使用了如下的封装：

function (method, validateVersion, body, ignore) {
// debugger;
var doc = this;
// straight assignment will causes undefined values
var params = _.pick(this._state, ['id', 'type', 'index']);
params.body = body;
params.ignore = ignore || [409];

if (validateVersion && params.id) {
params.version = doc._getVersion();
}
// debugger;
return es[method](params)
.then(function (resp) {
// debugger;
if (resp.status === 409) throw new errors.VersionConflict(resp);

doc._storeVersion(resp._version);
doc.id(resp._id);

var docFetchProm;
if (method !== 'index') {
docFetchProm = doc.fetch();
} else {
// we already know what the response will be
docFetchProm = Promise.resolve({
_id: resp._id,
_index: params.index,
_source: body,
_type: params.type,
_version: doc._getVersion(),
found: true
});
}

// notify pending request for this same document that we have updates
docFetchProm.then(function (fetchResp) {
// use the key to compair sources
var key = doc._versionKey();

// clear the queue and filter out the removed items, pushing the
// unmatched ones back in.
var respondTo = requestQueue.splice(0).filter(function (req) {
var isDoc = req.source._getType() === 'doc';
var keyMatches = isDoc && req.source._versionKey() === key;
debugger;
// put some request back into the queue
if (!keyMatches) {
requestQueue.push(req);
return false;
}

return true;
});

return courierFetch.fakeFetchThese(respondTo, respondTo.map(function () {
return _.cloneDeep(fetchResp);
}));
});

return resp._id;
})
.catch(function (err) {
// cast the error
throw new errors.RequestFailure(err);
});
};

因此使用时，又变成了：

xxx.call(this, 'create', false, body, []);

一层一层封装了很多，但是只要慢慢屡清除，就知道怎么使用了。