elasticsearch 脚本排序

最新推荐文章于 2024-04-23 10:27:29 发布
最新推荐文章于 2024-04-23 10:27:29 发布
阅读量2.1k 收藏 4
点赞数 1
分类专栏： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oBoySen/article/details/99123029
版权

elasticsearch 脚本排序主要用于复杂场景的综合排序，脚本语言有 java ,painless,groovy,目前调研的为painless。

 

  • kibana 脚本创建mapping
DELETE ksc.metadata
PUT ksc.metadata
{
  "mappings": {
    "doc": {
      "properties": {
        "hotnum": {
          "type": "long"
        },
        "ds": {
          "type": "object",
          "properties": {
            "dsid": {
              "type": "long"
            },
            "dsname": {
              "type": "text",
              "fielddata": true
            }
          }
        },
        "tlbtype": {
          "type":"keyword"
        },
        "dbname": {
          "type": "text",
          "fielddata": true
        },
        "createdate": {
          "type": "date",
          "format": "yyyy-MM-dd HH:mm:ss"
        }
      }
    }
  }
}

 

  • java 代码倒入数据
package com.hys.es;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.hys.Application;
import javafx.scene.input.DataFormat;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.apache.http.HttpHost;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.lucene.search.function.CombineFunction;
import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.Index;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientProperties;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.annotations.DateFormat;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * es 的测试单元
 */
@ActiveProfiles("es")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class,webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class EsTest {


    @Autowired
    ElasticsearchTemplate elasticsearchTemplate;

    @Autowired
    RestClientProperties restClientProperties;

    RestHighLevelClient restHighLevelClient = null;

    String index = "test";

    Client client = null;

    String type = "student";

    @Before
    public void inserIndexIfNotExist(){
        if(!elasticsearchTemplate.indexExists(index)){
             elasticsearchTemplate.createIndex(this.index);
        }
        client = elasticsearchTemplate.getClient();
        HttpHost[] httpHosts = new HttpHost[restClientProperties.getUris().size()];
        int index = 0;
        restClientProperties.getUris().forEach(uri->{
            httpHosts[index] = HttpHost.create(uri);
        });
        restHighLevelClient = new RestHighLevelClient(
                RestClient.builder(
                        httpHosts
                ));
    }

    /**
     * 插入模板
     */
    @Test
    public void insertTemplate(){
        String setting = "{\n" +
                "    \"template\" : \"te*\",\n" +
                "    \"order\" : 1,\n" +
                "    \"settings\" : {\n" +
                "        \"number_of_shards\" : 1\n" +
                "    },\n" +
                "    \"mappings\" : {\n" +
                "        \"type1\" : {\n" +
                "            \"_source\" : { \"enabled\" : true }\n" +
                "        }\n" +
                "    }\n" +
                "}";
        boolean ok = elasticsearchTemplate.createIndex(this.index, setting);
        System.out.println(ok);

    }

    @Test
    public void insertTemplate2() throws IOException {
        String setting = "{\n" +
                "    \"template\" : \"te*\",\n" +
                "    \"order\" : 1,\n" +
                "    \"settings\" : {\n" +
                "        \"number_of_shards\" : 1\n" +
                "    },\n" +
                "    \"mappings\" : {\n" +
                "        \"type1\" : {\n" +
                "            \"_source\" : { \"enabled\" : true }\n" +
                "        }\n" +
                "    }\n" +
                "}";


        CreateIndexRequest request = new CreateIndexRequest(index);//创建索引
        //创建的每个索引都可以有与之关联的特定设置。
        request.settings(Settings.builder().loadFromSource(setting,XContentType.JSON)
        );
        //创建索引时创建文档类型映射
        request.mapping("tweet",//类型定义
                "  {\n" +
                        "    \"tweet\": {\n" +
                        "      \"properties\": {\n" +
                        "        \"message\": {\n" +
                        "          \"type\": \"text\"\n" +
                        "        }\n" +
                        "      }\n" +
                        "    }\n" +
                        "  }",//类型映射，需要的是一个JSON字符串
                XContentType.JSON);

        //为索引设置一个别名
        request.alias(
                new Alias("twitter_alias")
        );
        //可选参数
        request.timeout(TimeValue.timeValueMinutes(2));//超时,等待所有节点被确认(使用TimeValue方式)
        //request.timeout("2m");//超时,等待所有节点被确认(使用字符串方式)

        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));//连接master节点的超时时间(使用TimeValue方式)
        //request.masterNodeTimeout("1m");//连接master节点的超时时间(使用字符串方式)

        request.waitForActiveShards(2);//在创建索引API返回响应之前等待的活动分片副本的数量，以int形式表示。
        //request.waitForActiveShards(ActiveShardCount.DEFAULT);//在创建索引API返回响应之前等待的活动分片副本的数量，以ActiveShardCount形式表示。

        //同步执行
        CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request);
        //异步执行
        //异步执行创建索引请求需要将CreateIndexRequest实例和ActionListener实例传递给异步方法：
        //CreateIndexResponse的典型监听器如下所示：
        //异步方法不会阻塞并立即返回。
        ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
            @Override
            public void onResponse(CreateIndexResponse createIndexResponse) {
                //如果执行成功，则调用onResponse方法;
            }
            @Override
            public void onFailure(Exception e) {
                //如果失败，则调用onFailure方法。
            }
        };
        restHighLevelClient.indices().createAsync(request, listener);//要执行的CreateIndexRequest和执行完成时要使用的ActionListener

        //返回的CreateIndexResponse允许检索有关执行的操作的信息，如下所示：
        boolean acknowledged = createIndexResponse.isAcknowledged();//指示是否所有节点都已确认请求
        boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();//指示是否在超时之前为索引中的每个分片启动了必需的分片副本数
        System.out.println(acknowledged);

    }

    @Test
    public void insertTemplate3() throws IOException {


        PutIndexTemplateRequest putIndexTemplateRequest = new PutIndexTemplateRequest("templateahys");

        List<String> indexPatterns = new ArrayList<String>();
        indexPatterns.add("ubi*");
        putIndexTemplateRequest.patterns(indexPatterns);
        Map<String, Object> settings = new HashMap<>();
        settings.put("number_of_shards", 1);
        putIndexTemplateRequest.settings(settings);
        PutIndexTemplateResponse putIndexTemplateResponse = restHighLevelClient.indices().putTemplate(putIndexTemplateRequest, RequestOptions.DEFAULT);


        System.out.println(putIndexTemplateResponse.isAcknowledged());
    }


    @Test
    public void insertTemplate4() throws IOException {


        PutIndexTemplateRequest putIndexTemplateRequest = new PutIndexTemplateRequest("templateahys1");
        putIndexTemplateRequest.source("{\n" +
                "    \"template\" : \"*\",\n" +
                "    \"order\" : 0,\n" +
                "    \"settings\" : {\n" +
                "        \"number_of_shards\" : 1\n" +
                "    },\n" +
                "    \"mappings\" : {\n" +
                "        \"type1\" : {\n" +
                "            \"_source\" : { \"enabled\" : false }\n" +
                "        }\n" +
                "    }\n" +
                "}",XContentType.JSON);
        PutIndexTemplateResponse putIndexTemplateResponse = restHighLevelClient.indices().putTemplate(putIndexTemplateRequest, RequestOptions.DEFAULT);


        System.out.println(putIndexTemplateResponse.isAcknowledged());
    }


    @Test
    public void validate(){
        PutIndexTemplateRequest putIndexTemplateRequest = new PutIndexTemplateRequest("templateahys1");
        putIndexTemplateRequest.source("{\n" +
                "    \"template\" : \"*\",\n" +
                "    \"order\" : 0,\n" +
                "    \"settings1\" : {\n" +
                "        \"number_of_shards\" : 1\n" +
                "    },\n" +
                "    \"mappings\" : {\n" +
                "        \"type1\" : {\n" +
                "            \"_source\" : { \"enabled\" : false }\n" +
                "        }\n" +
                "    }\n" +
                "}",XContentType.JSON);
        System.out.println("ok");
    }

    //插入type
    @Test
    public void querySoreSingle() throws IOException {

        //https://blog.csdn.net/u012270682/article/details/80165836

        String index = "ksc.metadata";
        String type = "doc";
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        queryBuilder.must(QueryBuilders.multiMatchQuery("ds62","ds.dsname"));

       // String idOrCode = "params.current1-doc['createdate'].date";
        //根据热度排序

        String hotNumCode = "long hotscore = doc['hotnum'].value/params['hotnumSize']*10;if(hotscore < params['hotnumMinscore']){hotscore =params['hotnumMinscore'];}" +
                "else if(hotscore > params['hotnumMaxscore']){hotscore =params['hotnumMaxscore'];}return hotscore;";
        Map<String,Object> params = new HashMap<>();
       // params.put("current1",new SimpleDateFormat("yyyy-MM-dd").format(LocalDateTime.now()));
        params.put("current1",new Date());
        params.put("hotnumSize",100);
        params.put("hotnumMinscore",10);
        params.put("hotnumMaxscore",100);
        //params.put("hotnumsize",100);
        Script script = new Script(ScriptType.INLINE,"painless",hotNumCode,params);
        ScoreFunctionBuilder scoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(script);
        FunctionScoreQueryBuilder scoreQueryBuilder = new FunctionScoreQueryBuilder(queryBuilder,scoreFunctionBuilder)
                .scoreMode(FunctionScoreQuery.ScoreMode.SUM).boostMode(CombineFunction.REPLACE);
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        builder.withQuery(scoreQueryBuilder).withIndices(index).withTypes(type);
        NativeSearchQuery nativeSearchQuery = builder.build();
        String queryc = nativeSearchQuery.getQuery().toString();
        System.out.println(queryc);
        List<Map> maps = elasticsearchTemplate.queryForList(nativeSearchQuery, Map.class);
        System.out.println(maps);


    }


    @Test
    public void querySoreMult() throws IOException {

        //https://blog.csdn.net/u012270682/article/details/80165836

        String index = "ksc.metadata";
        String type = "doc";
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        queryBuilder.must(QueryBuilders.multiMatchQuery("ds62","ds.dsname"));

        // String idOrCode = "params.current1-doc['createdate'].date";
        //根据热度排序
        String hotNumCode = "long hotscore = doc['hotnum'].value/params['hotnumSize']*10;if(hotscore < params['hotnumMinscore']){hotscore =params['hotnumMinscore'];}" +
                "else if(hotscore > params['hotnumMaxscore']){hotscore =params['hotnumMaxscore'];}return hotscore;";
        Map<String,Object> params = new HashMap<>();
        // params.put("current1",new SimpleDateFormat("yyyy-MM-dd").format(LocalDateTime.now()));
        params.put("current1",new Date());
        params.put("hotnumSize",100);
        params.put("hotnumMinscore",10);
        params.put("hotnumMaxscore",100);
        Script hotScript = new Script(ScriptType.INLINE,"painless",hotNumCode,params);
        ScoreFunctionBuilder hotScriptScoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(hotScript);


        //时间排序
        String timeCode = "Calendar c = Calendar.getInstance(); c.setTime(new Date());c.add(Calendar.DATE, - 7);long beforeNowSeven = c.getTimeInMillis();long differ = (doc['createdate'].value.millis - beforeNowSeven)/86400000;if(differ> 7){differ = 1;}return differ;";
        Script timeScript = new Script(ScriptType.INLINE,"painless",timeCode,params);
        ScoreFunctionBuilder timeScriptScoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(timeScript);


        //类型排序
        String tlbTypeCode = "if(doc['tlbtype'].value=='table'){return 2;}else{return 1;}";
        Script tlbTypeScript = new Script(ScriptType.INLINE,"painless",tlbTypeCode,params);
        ScoreFunctionBuilder tlbScriptScoreFunctionBuilder = ScoreFunctionBuilders.scriptFunction(tlbTypeScript);

        FunctionScoreQueryBuilder.FilterFunctionBuilder[] filterFunctionBuilders = new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
            new FunctionScoreQueryBuilder.FilterFunctionBuilder(hotScriptScoreFunctionBuilder),
                new FunctionScoreQueryBuilder.FilterFunctionBuilder(timeScriptScoreFunctionBuilder),
                new FunctionScoreQueryBuilder.FilterFunctionBuilder(tlbScriptScoreFunctionBuilder)
        };
        FunctionScoreQueryBuilder scoreQueryBuilder = new FunctionScoreQueryBuilder(queryBuilder,filterFunctionBuilders)
                .scoreMode(FunctionScoreQuery.ScoreMode.SUM).boostMode(CombineFunction.REPLACE);
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        builder.withQuery(scoreQueryBuilder).withIndices(index).withTypes(type);
        NativeSearchQuery nativeSearchQuery = builder.build();
        String queryc = nativeSearchQuery.getQuery().toString();
        System.out.println(queryc);
        List<Map> maps = elasticsearchTemplate.queryForList(nativeSearchQuery, Map.class);
        System.out.println(maps);


    }




    
    @Test
    public void batchData() throws IOException {
        String index = "ksc.metadata";
        String type = "doc";
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout(TimeValue.timeValueMinutes(2));
        bulkRequest.timeout("2m");
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        for (int i = 0;i<1000;i++) {
            int r = new Random().nextInt(50);
            int d = new Random().nextInt(100);
            Ds ds = new Ds();
            ds.setDsid(d);
            ds.setDsname("ds"+d);
            LocalDateTime dateTime = LocalDateTime.of(2019, 8,getZ(10) , getZ(24) ,getZ(60) );

            Doc doc = new Doc();
            doc.setCreatedate(dateTime.format(formatter));
            doc.setHotnum(new Random().nextInt(1000));
            doc.setDbname("db"+r);
            doc.setTlbtype();
            doc.setDs(ds);
            bulkRequest.add(new IndexRequest(index, type, UUID.randomUUID().toString())
                    .source(JSONObject.toJSONString(doc),XContentType.JSON));

        }
        BulkResponse response = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        //response.hasFailures()
        System.out.println(response.status());
    }

    private int getZ(int seed){
        int i = 0;
        for(;;){
            i=new Random().nextInt(seed);
            if (i > 0){
                return  i;
            }
        }

    }

    @Test
    public void batch100Minlin() throws IOException {

        for (int i = 0;i<2;i++){
            batchData();
        }
    }

    @Test
    public void queryScript(){

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Calendar c = Calendar.getInstance();
        //过去七天
        c.setTime(new Date());
        c.add(Calendar.DATE, - 7);
        Date d = c.getTime();
        long time = d.getTime();
        //86400000
        System.out.println(24*60*60*1000);

        String day = format.format(d);
        System.out.println("过去七天："+day);
        
    }

    @After
    public void  close() throws IOException {

        if(client!=null){
            client.close();
        }

        if(restHighLevelClient!=null){
            restHighLevelClient.close();
        }
    }
    
    
    @Document(indexName = "test", type = "student", createIndex = false)
    public static class Student {

        @Field
        String id;

        @Field
        String name;

        @Field
        Long age;


        @Field(format = DateFormat.year_month_day)
        Date birthDay;


    }


    @Data
    public static class Doc{

        Integer hotnum;

        String dbname;

        //@JsonFormat (shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd HH:mm:ss")
        //LocalDateTime createdate;
        String createdate;

        String tlbtype;

        public void setTlbtype(){
            boolean aBoolean = new Random().nextBoolean();
            if(aBoolean){
                tlbtype = "table";
            }else {
                tlbtype = "col";
            }
        }

        Ds ds;


    }

    @Data
    public static class  Ds{

        Integer dsid;

        String dsname;
    }



}

 

  • kibana脚本查询
GET ksc.metadata/_search
{
  "from": 0,
  "size": 50,
  "query": {
    "function_score": {
      "query": {
        "multi_match": {
          "query": "ds62",
          "fields": [
            "ds.dsname"
          ]
        }
      },
      "score_mode": "sum",
      "boost_mode" : "replace",
      "functions": [
        {
          "script_score": {
            "script": {
              "inline": "if(doc['tlbtype'].value=='table'){return 2;}else{return 1;}",
              "params": {

              },
              "lang": "painless"
            }
          }
        },
        {
          "script_score": {
            "script": {
              "inline": "Calendar c = Calendar.getInstance(); c.setTime(new Date());c.add(Calendar.DATE, - 7);long beforeNowSeven = c.getTimeInMillis();long differ = (doc['createdate'].value.millis - beforeNowSeven)/86400000;if(differ> 7){differ = 1;}return differ;",
              "params": {

              }
              , "lang": "painless"
            }
          }
        },
        {
          "script_score": {
            "script": {
              "inline": "long hotscore = doc['hotnum'].value/params['hotnumSize']*10;if(hotscore < params['hotnumMinscore']){hotscore =params['hotnumMinscore'];}else if(hotscore > params['hotnumMaxscore']){hotscore =params['hotnumMaxscore'];}return hotscore;",
              "lang": "painless",
              "params": {
                "current1": "2019-08-10T10:33:53.470Z",
                "hotnumSize": 100,
                "hotnumMinscore": 10,
                "hotnumMaxscore": 100
              }
            }
          }
        }
      ]
    }
  }
}

文档批量更新接口

POST 1_test_metadata_index/_update_by_query
{
  "script": {
    "lang": "painless",
    "params": {
      "bizIds":[74]
    }, 
    "inline": "ctx._source.bizCatalogList = ctx._source.bizCatalogList.stream().filter(x -> !params.bizIds.contains(x.id)).collect(Collectors.toList());"
  },
  "query": {
    "term": {
      "id.keyword": {
        "value": "78013a35c69d28afcddc7b85c9c3b7da"
      }
    }
  }
}
  • java 代码实现搜索
ahys
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sort-script:elasticsearch排序脚本
04-07
排序脚本 SortScript是ElasticSearch的本机插件，用于实现自定义排名算法。
elasticsearch实现简单的脚本排序(script sort)
huan的学习记录
01-13 3519
我有一堆学生数据，其中`湖北省`的学生需要排在所有数据的最前面。`其余省`正序排序，对于`同一个省`的数据，按照`年龄`倒序排序。
Elasticsearch：如何基于Script实现按照text属性值的字符串长度排序
zhendeC1的博客
04-23 857
数组情形下，既然我们可以通过或者获取字段长度，那么需要修改mappings该属性的类型；字符串情形下,，但是需要注意，如果的值存在为null的情况，需要使用优先判空。最终的脚本为：“from”: 0,“query”: {“terms”: {“id”: [“66108”,“72221”},“sort”: [},},三、踩坑历史。
ElasticsearchUtils操作
杜海的博客
07-04 2326
package com.tools.es.util; import java.io.IOException; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.annotat...
数据库课堂笔记---索引
JIENIXIAOWU的博客
09-17 501
1，索引的分类 单值索引：一个索引值只包含三个列，一张表可以有多个单值索引。 唯一索引：索引的列的值必须是唯一的，但允许有空值。 复合索引：一个索引可以包含多个列。 主键索引：id不能重复，并且不允许出现空值 2，索引的含义 索引是一种单独的、物理的，对数据库表中一列或多列的值进行排序的一种存储结构。 为了加速表中数据行的检索而创建的一种分散的数据结构。 3，索引的优缺点 优点： 快速获取数据； 保证数据记录的唯一性； 实现表与表之间的参照完整性； 使用group by 和order by 进行检索时利用索
es数组内容排序；脚本排序
奔跑的菜鸡
08-17 1626
es数组内容排序
【elasticsearch】 ElasticSearch的其他脚本
最新发布
06-22
在描述中提到的 `es_precreate_indices.py` 是一个 Python 脚本，可能用于在 Elasticsearch 中预先创建索引。这个脚本可能是为了在系统启动前配置好索引结构，设置映射（mapping），或者执行初始化操作，如设置别名...
Elasticsearch全文检索
09-18
除了基础操作，Elasticsearch还提供许多高级特性，如聚合分析（Aggregations）用于统计分析，脚本字段（Script Fields）用于动态计算字段，以及实时数据分析（Real-time Analytics）等功能。 在` ESDemo `项目中，...
Elasticsearch 8.1.2 Linux版本
04-06
**Elasticsearch 8.1.2 Linux 版本详解** Elasticsearch 是一款高度可扩展的开源全文搜索引擎，广泛应用于大数据分析、日志聚合、实时搜索等场景。其8.1.2版本针对Linux操作系统进行了优化，为用户提供高效、稳定的...
springboot 集成elasticsearch ,api的使用
08-02
在本文中，我们将深入探讨如何将Spring Boot与Elasticsearch集成，并使用其API进行数据操作。Elasticsearch是一个流行的开源搜索引擎，它提供了实时、分布式、容错能力的搜索和数据分析功能。Spring Boot则是一个...
elecsearch java入门_java操作elecsearch
weixin_34463209的博客
02-25 431
importorg.elasticsearch.action.bulk.BulkRequestBuilder;importorg.elasticsearch.action.bulk.BulkResponse;importorg.elasticsearch.action.get.GetRequestBuilder;importorg.elasticsearch.action.get.GetRespo...
ElasticSearch之排序使用-ES常用排序方法
进击30K的专栏
09-11 7960
ElasticSearch之排序使用-ES常用排序方法 在搜索系统中，最常遇到的一个需求就是排序，同时排序也是搜索引擎需要改造最多的地方。 常见排序一般有如下两类： （1）按照相似度匹配得分排序 （2）按照指定字段排序 相似度得分排序是系统默认的排序方式，更多时候，我们需要按照指定字段排序。lucene中，基于字段内容的排序是由FieldComparator接口来实现的，在排序中又分为单字段排序和多字段排序。在排序速度方面，数值类型排序速度最快，在lucene中数值...
Elasticsearch 自定义排序脚本
jonssonyan
07-01 986
按照rooms字段的数组长度排序 { "query": {}, "sort": [ { "_script":{ "script":{ "inline": "doc['rooms'].values.size()" }, "type":"number", "order": "desc" } } ] } Java API Script script = new Script("
ElasticSearch学习笔记-相关度得分记录
PURSUE ONE PIECE
09-26 2494
最近想要修改调整一下ElasticSearch里面Doc的Score，于是在ES官网查阅了一下，相关的介绍和说明还是非常详细的，可以参考连接： https://www.elastic.co/guide/cn/elasticsearch/guide/current/controlling-relevance.html https://www.elastic.co/guide/cn/elast
ElasticSearch painless脚本实现自定义打分排序
qq_41935885的博客
04-04 570
自定义打分规则，其实就是可以根据打分规则进行排序。注意：只能对索引的keyword属性进行排序，TEXT类型的要加.keyWord，如：doc[‘索引列名.keyword’].value。
es使用painless脚本自定义排序
何超杰的博客
03-29 6954
源文档： { “groupName”: “北京的俱乐部”, “deleted”: 0, “groupId”: “g1”, “allowAccess”: 1, “notice”: “介绍” } 脚本代码： // 定义脚本 String scriptText =" def groupScore = params.groupMap[doc['groupId.keyword'].value];" + ...
es修改排序_ElasticSearch自定义排序（转载）
weixin_34698515的博客
02-23 2317
本文讨论ES的自定义排序的两种实现形式：基于groovy脚本的自定义排序和基于native script的自定义排序。1. 基于Groovy脚本的自定义排序ES的排序脚本必须放在config/scripts下面,ES能够自动发现这些脚本并提供对外使用， 例如编写脚本calculate-score.groovylog(_score*2)+my_modifier脚本中my_modifier是搜索请求中...
Elasticsearch(039)：es中搜索之排序
瘦子没有夏天
02-22 6973
一、概述 默认情况下，结果集会按照相关性进行排序 – 相关性越高，排名越靠前。为了使结果可以按照相关性进行排序，我们需要一个相关性的值。在ElasticSearch的查询结果中， 相关性分值会用_score字段来给出一个浮点型的数值，所以默认情况下，结果集以_score进行倒序排列. 二、Es中排序使用 2.1 简单排序 例如下面的按照创建时间的倒序排序。 GET example/docs/_search { "query": { "match_all": {} }, "sort": [
es自定义排序
weixin_32128491的博客
09-21 3999
## 排序 ### 一、默认排序规则 默认情况下，是按照_score降序排序。 _score使用的算法,计算出一个索引中的文本，与搜索文本，他们之间的关联匹配程度 es使用的是，term frequency和inverse documnet frequency算法，简称为TF/IDF算法 term frequency:搜索文本中的各个词条在field文本中出现了多少次，出现次数越多，分数越高 inverse documnet frequency：搜索文本中的各个词条在整个索引的所有文档中出现了多少次，出
es5.5.3 脚本排序
09-07
ES5.5.3的脚本排序是指在JavaScript代码中对脚本进行排序的方法。这个方法的目的是为了确保脚本的执行顺序，从而避免出现意外的bug或者不符合预期的结果。 ES5.5.3标准规定了以下几种方法来对脚本进行排序： 1. 内联脚本排序：在HTML文档中使用`<script>`标签嵌入JavaScript代码时，可以使用`defer`或者`async`属性来控制脚本的执行顺序。`defer`属性表示脚本将在文档解析完毕后执行，而`async`表示脚本将在其下载完成后立即执行。可以通过改变这两个属性的顺序来控制脚本的执行顺序。 2. 外部脚本排序：如果脚本是通过外部文件引入的，浏览器会按照引入的顺序进行加载和执行。所以，可以通过改变脚本的引入顺序来控制脚本的执行顺序。 3. 事件驱动的脚本排序：在JavaScript中，事件驱动的编程模式很常见。通过绑定事件处理函数，可以确保脚本在特定的事件发生时被执行。使用事件驱动的方式可以有效地控制脚本的执行顺序，使其按照预期的顺序执行。 总结来说，ES5.5.3的脚本排序可以通过改变脚本的属性、引入顺序或者事件绑定的方式来控制。这些方法都可以确保脚本的执行顺序按照预期进行，从而避免一些潜在的问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值