ElasticSearch无痛脚本：无法使用脚本分数访问嵌套对象

Question

我想从特定字段中搜索关键字并返回文档。在这些文档之上，我希望遍历每个嵌套对象，并从选定文档的同一特定字段中再次搜索关键字。

如果关键字存在，则检查:如果布尔isCurrent = True，则设置isCurrent=0，并将该值追加到列表中；否则，如果isCurrent = False，则取当前日期时间的差值，结束日期时间，并获得以月为单位的值，并将该值追加到列表中。

最后，从每个文档的列表中获取最小值，并根据最小值对文档进行排序。

我可以通过script_fields进行自定义登录，并根据最小值对文档进行排序。当我在script_score中使用相同的登录时，它不起作用。当我调试时，我看到使用参数访问嵌套字段时出现问题。_source。

任何帮助将不胜感激。

请使用script_fields查找以下弹性搜索查询。在这里，我从python脚本传递current_millizes值。

    query = {
        'query': {
            "nested": {
                "path": "person.experiences",
                "query": {
                    "query_string": {
                        "query": keywords,
                        "fields": ["person.experiences.description"],
                        "default_operator": "AND"
                    }
                }
            }
        },
        "script_fields": {
            "recency": {
                "script": {
                    "lang": "painless",
                    "inline": """
                            def myString = "";
                            def isCurrent = 0;
                            def isFound = false;
                            def index_position = 0;
                            def recency_num = 0;
                            def result = 0;
                            def list = new ArrayList();

                            // for loop starts here
                            for(int i=0; i<params._source.person.experiences.size(); i++){
                            myString = params._source.person.experiences[i].description;

                            // string match starts here
                            if(myString != null && myString != ''){
                            def matcher1 = /electric/.matcher(myString.toLowerCase());
                            def matcher2 = /vehicle/.matcher(myString.toLowerCase());                    
                            //if(wordMatcher.find()){
                            if (matcher1.find() || matcher2.find()){
                            isFound = true;
                            }

                            if (isFound == true){
                            // recency check starts here
                            isCurrent = params._source.person.experiences[i].isCurrent;
                            if(isCurrent == true){
                            isCurrent=0;
                            result+=isCurrent;
                            list.add(isCurrent);
                            } else{
                            ZonedDateTime now = ZonedDateTime.ofInstant(Instant.ofEpochMilli(params['current_datetime']), ZoneId.of('Z'));
                            ZonedDateTime end_date = ZonedDateTime.parse(params._source.person.experiences[i].end);
                            isCurrent = end_date.until(now, ChronoUnit.MONTHS);
                            list.add(isCurrent);
                            result+=isCurrent;
                            recency_num = isCurrent;
                            }
                            }

                            }
                            }
                            def min = list.get(0);
                            for (int i : list){
                            min = min < i ? min : i;
                            }
                            return min;
                            """,
                    "params": {
                        "search_keywords": "Machine Learning",
                        "current_datetime": current_milliseconds
                    }

                }
            }
        }
    }

提前感谢。

Answer 1

在您的情况下，有效的＜code＞script_score

GET my-index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "function_score": {
            "functions": [
              {
                "script_score": {
                  "script": {
                    "source": """
                      def myString = "";
                      def isCurrent = 0;
                      def isFound = false;
                      def index_position = 0;
                      def recency_num = 0;
                      def result = 0;
                      def list = new ArrayList();
          
                      def experiences = params._source.person.experiences;
          
                      // for loop starts here
                      for (int i=0; i<experiences.length; i++){
                        def experience = experiences[i];
                        
                        myString = experience.description;
            
                        // string match starts here
                        if(myString != null && myString != '') {
                          def matcher1 = /electric/.matcher(myString.toLowerCase());
                          def matcher2 = /vehicle/.matcher(myString.toLowerCase());                    
                          
                          if (matcher1.find() || matcher2.find()){
                            isFound = true;
                          }
            
                          if (isFound == true){
                            // recency check starts here
                            isCurrent = experience.isCurrent;
                        
                            if (isCurrent == true){
                              isCurrent=0;
                              result += isCurrent;
                              list.add(isCurrent);
                            } else {
                              def now = ZonedDateTime.ofInstant(Instant.ofEpochMilli(params['current_datetime']), ZoneId.of('Z'));
                              def end_date = ZonedDateTime.parse(experience.end);
                              isCurrent = end_date.until(now, ChronoUnit.MONTHS);
                              list.add(isCurrent);
                              result += isCurrent;
                              recency_num = isCurrent;
                            }
                          }
                        }
                      }
                      
                      if (list.length === 0) {
                        return 0;
                      }
                      
                      def min = list.get(0);
                      
                      for (int i : list){
                        min = min < i ? min : i;
                      }
                      
                      return min;
                    """,
                    "params": {
                        "search_keywords": "Machine Learning",
                        "current_datetime": 1643036066000
                    }
                  }
                }
              }
            ]
          }
        }
      ]
    }
  }
}

请注意，正则表达式、迭代和（日期）分析的负载可以大大提高查询分辨率。