Elasticsearch Javascript API增删改查

妖狐艹你老母 2022-11-17 05:17 149阅读 0赞

## 查询 ##

根据索引、类型、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, []);

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