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, []);

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