Пример #1
0
 /**
  * Parse a string GapPolicy into the byte enum
  *
  * @param context SearchContext this is taking place in
  * @param text GapPolicy in string format (e.g. "ignore")
  * @return GapPolicy enum
  */
 public static GapPolicy parse(
     QueryParseContext context, String text, XContentLocation tokenLocation) {
   GapPolicy result = null;
   for (GapPolicy policy : values()) {
     if (context.getParseFieldMatcher().match(text, policy.parseField)) {
       if (result == null) {
         result = policy;
       } else {
         throw new IllegalStateException(
             "Text can be parsed to 2 different gap policies: text=["
                 + text
                 + "], "
                 + "policies="
                 + Arrays.asList(result, policy));
       }
     }
   }
   if (result == null) {
     final List<String> validNames = new ArrayList<>();
     for (GapPolicy policy : values()) {
       validNames.add(policy.getName());
     }
     throw new ParsingException(
         tokenLocation, "Invalid gap policy: [" + text + "], accepted values: " + validNames);
   }
   return result;
 }
Пример #2
0
 public static IncludeExclude parseInclude(XContentParser parser, QueryParseContext context)
     throws IOException {
   XContentParser.Token token = parser.currentToken();
   if (token == XContentParser.Token.VALUE_STRING) {
     return new IncludeExclude(parser.text(), null);
   } else if (token == XContentParser.Token.START_ARRAY) {
     return new IncludeExclude(new TreeSet<>(parseArrayToSet(parser)), null);
   } else if (token == XContentParser.Token.START_OBJECT) {
     ParseFieldMatcher parseFieldMatcher = context.getParseFieldMatcher();
     String currentFieldName = null;
     Integer partition = null, numPartitions = null;
     while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
       if (token == XContentParser.Token.FIELD_NAME) {
         currentFieldName = parser.currentName();
       } else
       // This "include":{"pattern":"foo.*"} syntax is undocumented since 2.0
       // Regexes should be "include":"foo.*"
       if (parseFieldMatcher.match(currentFieldName, PATTERN_FIELD)) {
         return new IncludeExclude(parser.text(), null);
       } else if (parseFieldMatcher.match(currentFieldName, NUM_PARTITIONS_FIELD)) {
         numPartitions = parser.intValue();
       } else if (parseFieldMatcher.match(currentFieldName, PARTITION_FIELD)) {
         partition = parser.intValue();
       } else {
         throw new ElasticsearchParseException(
             "Unknown parameter in Include/Exclude clause: " + currentFieldName);
       }
     }
     if (partition == null) {
       throw new IllegalArgumentException(
           "Missing ["
               + PARTITION_FIELD.getPreferredName()
               + "] parameter for partition-based include");
     }
     if (numPartitions == null) {
       throw new IllegalArgumentException(
           "Missing ["
               + NUM_PARTITIONS_FIELD.getPreferredName()
               + "] parameter for partition-based include");
     }
     return new IncludeExclude(partition, numPartitions);
   } else {
     throw new IllegalArgumentException("Unrecognized token for an include [" + token + "]");
   }
 }
  public static NestedAggregationBuilder parse(String aggregationName, QueryParseContext context)
      throws IOException {
    String path = null;

    XContentParser.Token token;
    String currentFieldName = null;
    XContentParser parser = context.parser();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
      if (token == XContentParser.Token.FIELD_NAME) {
        currentFieldName = parser.currentName();
      } else if (token == XContentParser.Token.VALUE_STRING) {
        if (context.getParseFieldMatcher().match(currentFieldName, NestedAggregator.PATH_FIELD)) {
          path = parser.text();
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unknown key for a "
                  + token
                  + " in ["
                  + aggregationName
                  + "]: ["
                  + currentFieldName
                  + "].");
        }
      } else {
        throw new ParsingException(
            parser.getTokenLocation(),
            "Unexpected token " + token + " in [" + aggregationName + "].");
      }
    }

    if (path == null) {
      // "field" doesn't exist, so we fall back to the context of the ancestors
      throw new ParsingException(
          parser.getTokenLocation(),
          "Missing [path] field for nested aggregation [" + aggregationName + "]");
    }

    return new NestedAggregationBuilder(aggregationName, path);
  }
  public static ScriptedMetricAggregationBuilder parse(
      String aggregationName, QueryParseContext context) throws IOException {
    Script initScript = null;
    Script mapScript = null;
    Script combineScript = null;
    Script reduceScript = null;
    Map<String, Object> params = null;
    XContentParser.Token token;
    String currentFieldName = null;
    Set<String> scriptParameters = new HashSet<>();
    scriptParameters.add(INIT_SCRIPT_FIELD.getPreferredName());
    scriptParameters.add(MAP_SCRIPT_FIELD.getPreferredName());
    scriptParameters.add(COMBINE_SCRIPT_FIELD.getPreferredName());
    scriptParameters.add(REDUCE_SCRIPT_FIELD.getPreferredName());

    XContentParser parser = context.parser();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
      if (token == XContentParser.Token.FIELD_NAME) {
        currentFieldName = parser.currentName();
      } else if (token == XContentParser.Token.START_OBJECT
          || token == XContentParser.Token.VALUE_STRING) {
        if (context.getParseFieldMatcher().match(currentFieldName, INIT_SCRIPT_FIELD)) {
          initScript =
              Script.parse(
                  parser, context.getParseFieldMatcher(), context.getDefaultScriptLanguage());
        } else if (context.getParseFieldMatcher().match(currentFieldName, MAP_SCRIPT_FIELD)) {
          mapScript =
              Script.parse(
                  parser, context.getParseFieldMatcher(), context.getDefaultScriptLanguage());
        } else if (context.getParseFieldMatcher().match(currentFieldName, COMBINE_SCRIPT_FIELD)) {
          combineScript =
              Script.parse(
                  parser, context.getParseFieldMatcher(), context.getDefaultScriptLanguage());
        } else if (context.getParseFieldMatcher().match(currentFieldName, REDUCE_SCRIPT_FIELD)) {
          reduceScript =
              Script.parse(
                  parser, context.getParseFieldMatcher(), context.getDefaultScriptLanguage());
        } else if (token == XContentParser.Token.START_OBJECT
            && context.getParseFieldMatcher().match(currentFieldName, PARAMS_FIELD)) {
          params = parser.map();
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unknown key for a "
                  + token
                  + " in ["
                  + aggregationName
                  + "]: ["
                  + currentFieldName
                  + "].");
        }
      } else {
        throw new ParsingException(
            parser.getTokenLocation(),
            "Unexpected token " + token + " in [" + aggregationName + "].");
      }
    }

    if (mapScript == null) {
      throw new ParsingException(
          parser.getTokenLocation(), "map_script field is required in [" + aggregationName + "].");
    }

    ScriptedMetricAggregationBuilder factory =
        new ScriptedMetricAggregationBuilder(aggregationName);
    if (initScript != null) {
      factory.initScript(initScript);
    }
    if (mapScript != null) {
      factory.mapScript(mapScript);
    }
    if (combineScript != null) {
      factory.combineScript(combineScript);
    }
    if (reduceScript != null) {
      factory.reduceScript(reduceScript);
    }
    if (params != null) {
      factory.params(params);
    }
    return factory;
  }
  public static BucketSelectorPipelineAggregationBuilder parse(
      String reducerName, QueryParseContext context) throws IOException {
    XContentParser parser = context.parser();
    XContentParser.Token token;
    Script script = null;
    String currentFieldName = null;
    Map<String, String> bucketsPathsMap = null;
    GapPolicy gapPolicy = null;

    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
      if (token == XContentParser.Token.FIELD_NAME) {
        currentFieldName = parser.currentName();
      } else if (token == XContentParser.Token.VALUE_STRING) {
        if (context.getParseFieldMatcher().match(currentFieldName, BUCKETS_PATH)) {
          bucketsPathsMap = new HashMap<>();
          bucketsPathsMap.put("_value", parser.text());
        } else if (context.getParseFieldMatcher().match(currentFieldName, GAP_POLICY)) {
          gapPolicy = GapPolicy.parse(context, parser.text(), parser.getTokenLocation());
        } else if (context.getParseFieldMatcher().match(currentFieldName, ScriptField.SCRIPT)) {
          script = Script.parse(parser, context.getParseFieldMatcher());
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unknown key for a "
                  + token
                  + " in ["
                  + reducerName
                  + "]: ["
                  + currentFieldName
                  + "].");
        }
      } else if (token == XContentParser.Token.START_ARRAY) {
        if (context.getParseFieldMatcher().match(currentFieldName, BUCKETS_PATH)) {
          List<String> paths = new ArrayList<>();
          while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
            String path = parser.text();
            paths.add(path);
          }
          bucketsPathsMap = new HashMap<>();
          for (int i = 0; i < paths.size(); i++) {
            bucketsPathsMap.put("_value" + i, paths.get(i));
          }
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unknown key for a "
                  + token
                  + " in ["
                  + reducerName
                  + "]: ["
                  + currentFieldName
                  + "].");
        }
      } else if (token == XContentParser.Token.START_OBJECT) {
        if (context.getParseFieldMatcher().match(currentFieldName, ScriptField.SCRIPT)) {
          script = Script.parse(parser, context.getParseFieldMatcher());
        } else if (context.getParseFieldMatcher().match(currentFieldName, BUCKETS_PATH)) {
          Map<String, Object> map = parser.map();
          bucketsPathsMap = new HashMap<>();
          for (Map.Entry<String, Object> entry : map.entrySet()) {
            bucketsPathsMap.put(entry.getKey(), String.valueOf(entry.getValue()));
          }
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unknown key for a "
                  + token
                  + " in ["
                  + reducerName
                  + "]: ["
                  + currentFieldName
                  + "].");
        }
      } else {
        throw new ParsingException(
            parser.getTokenLocation(), "Unexpected token " + token + " in [" + reducerName + "].");
      }
    }

    if (bucketsPathsMap == null) {
      throw new ParsingException(
          parser.getTokenLocation(),
          "Missing required field ["
              + BUCKETS_PATH.getPreferredName()
              + "] for bucket_selector aggregation ["
              + reducerName
              + "]");
    }

    if (script == null) {
      throw new ParsingException(
          parser.getTokenLocation(),
          "Missing required field ["
              + ScriptField.SCRIPT.getPreferredName()
              + "] for bucket_selector aggregation ["
              + reducerName
              + "]");
    }

    BucketSelectorPipelineAggregationBuilder factory =
        new BucketSelectorPipelineAggregationBuilder(reducerName, bucketsPathsMap, script);
    if (gapPolicy != null) {
      factory.gapPolicy(gapPolicy);
    }
    return factory;
  }
  static TermSuggestionBuilder innerFromXContent(QueryParseContext parseContext)
      throws IOException {
    XContentParser parser = parseContext.parser();
    TermSuggestionBuilder tmpSuggestion = new TermSuggestionBuilder("_na_");
    ParseFieldMatcher parseFieldMatcher = parseContext.getParseFieldMatcher();
    XContentParser.Token token;
    String currentFieldName = null;
    String fieldname = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
      if (token == XContentParser.Token.FIELD_NAME) {
        currentFieldName = parser.currentName();
      } else if (token.isValue()) {
        if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.ANALYZER_FIELD)) {
          tmpSuggestion.analyzer(parser.text());
        } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.FIELDNAME_FIELD)) {
          fieldname = parser.text();
        } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SIZE_FIELD)) {
          tmpSuggestion.size(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SHARDSIZE_FIELD)) {
          tmpSuggestion.shardSize(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, SUGGESTMODE_FIELD)) {
          tmpSuggestion.suggestMode(SuggestMode.resolve(parser.text()));
        } else if (parseFieldMatcher.match(currentFieldName, ACCURACY_FIELD)) {
          tmpSuggestion.accuracy(parser.floatValue());
        } else if (parseFieldMatcher.match(currentFieldName, SORT_FIELD)) {
          tmpSuggestion.sort(SortBy.resolve(parser.text()));
        } else if (parseFieldMatcher.match(currentFieldName, STRING_DISTANCE_FIELD)) {
          tmpSuggestion.stringDistance(StringDistanceImpl.resolve(parser.text()));
        } else if (parseFieldMatcher.match(currentFieldName, MAX_EDITS_FIELD)) {
          tmpSuggestion.maxEdits(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, MAX_INSPECTIONS_FIELD)) {
          tmpSuggestion.maxInspections(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, MAX_TERM_FREQ_FIELD)) {
          tmpSuggestion.maxTermFreq(parser.floatValue());
        } else if (parseFieldMatcher.match(currentFieldName, PREFIX_LENGTH_FIELD)) {
          tmpSuggestion.prefixLength(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, MIN_WORD_LENGTH_FIELD)) {
          tmpSuggestion.minWordLength(parser.intValue());
        } else if (parseFieldMatcher.match(currentFieldName, MIN_DOC_FREQ_FIELD)) {
          tmpSuggestion.minDocFreq(parser.floatValue());
        } else if (parseFieldMatcher.match(currentFieldName, EXACT_MATCH_FIELD)) {
          tmpSuggestion.exactMatch(parser.booleanValue());
        } else {
          throw new ParsingException(
              parser.getTokenLocation(),
              "suggester[term] doesn't support field [" + currentFieldName + "]");
        }
      } else {
        throw new ParsingException(
            parser.getTokenLocation(),
            "suggester[term] parsing failed on [" + currentFieldName + "]");
      }
    }

    // now we should have field name, check and copy fields over to the suggestion builder we return
    if (fieldname == null) {
      throw new ElasticsearchParseException(
          "the required field option [" + FIELDNAME_FIELD.getPreferredName() + "] is missing");
    }
    return new TermSuggestionBuilder(fieldname, tmpSuggestion);
  }
  @Override
  public final MultiValuesSourceAggregationBuilder<VS, ?> parse(
      String aggregationName, QueryParseContext context) throws IOException {

    XContentParser parser = context.parser();
    List<String> fields = null;
    ValueType valueType = null;
    String format = null;
    Map<String, Object> missingMap = null;
    Map<ParseField, Object> otherOptions = new HashMap<>();
    final ParseFieldMatcher parseFieldMatcher = context.getParseFieldMatcher();

    XContentParser.Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
      if (token == XContentParser.Token.FIELD_NAME) {
        currentFieldName = parser.currentName();
      } else if (token == XContentParser.Token.VALUE_STRING) {
        if (parseFieldMatcher.match(currentFieldName, CommonFields.FIELDS)) {
          fields = Collections.singletonList(parser.text());
        } else if (formattable && parseFieldMatcher.match(currentFieldName, CommonFields.FORMAT)) {
          format = parser.text();
        } else if (parseFieldMatcher.match(currentFieldName, CommonFields.VALUE_TYPE)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "]. "
                  + "Multi-field aggregations do not support scripts.");
        } else if (!token(
            aggregationName,
            currentFieldName,
            token,
            parser,
            context.getParseFieldMatcher(),
            otherOptions)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "].");
        }
      } else if (token == XContentParser.Token.START_OBJECT) {
        if (parseFieldMatcher.match(currentFieldName, CommonFields.MISSING)) {
          missingMap = new HashMap<>();
          while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
            parseMissingAndAdd(aggregationName, currentFieldName, parser, missingMap);
          }
        } else if (context.getParseFieldMatcher().match(currentFieldName, ScriptField.SCRIPT)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "]. "
                  + "Multi-field aggregations do not support scripts.");

        } else if (!token(
            aggregationName,
            currentFieldName,
            token,
            parser,
            context.getParseFieldMatcher(),
            otherOptions)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "].");
        }
      } else if (token == XContentParser.Token.START_ARRAY) {
        if (context.getParseFieldMatcher().match(currentFieldName, ScriptField.SCRIPT)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "]. "
                  + "Multi-field aggregations do not support scripts.");
        } else if (parseFieldMatcher.match(currentFieldName, CommonFields.FIELDS)) {
          fields = new ArrayList<>();
          while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
            if (token == XContentParser.Token.VALUE_STRING) {
              fields.add(parser.text());
            } else {
              throw new ParsingException(
                  parser.getTokenLocation(),
                  "Unexpected token "
                      + token
                      + " ["
                      + currentFieldName
                      + "] in ["
                      + aggregationName
                      + "].");
            }
          }
        } else if (!token(
            aggregationName,
            currentFieldName,
            token,
            parser,
            context.getParseFieldMatcher(),
            otherOptions)) {
          throw new ParsingException(
              parser.getTokenLocation(),
              "Unexpected token "
                  + token
                  + " ["
                  + currentFieldName
                  + "] in ["
                  + aggregationName
                  + "].");
        }
      } else if (!token(
          aggregationName,
          currentFieldName,
          token,
          parser,
          context.getParseFieldMatcher(),
          otherOptions)) {
        throw new ParsingException(
            parser.getTokenLocation(),
            "Unexpected token "
                + token
                + " ["
                + currentFieldName
                + "] in ["
                + aggregationName
                + "].");
      }
    }

    MultiValuesSourceAggregationBuilder<VS, ?> factory =
        createFactory(aggregationName, this.valuesSourceType, this.targetValueType, otherOptions);
    if (fields != null) {
      factory.fields(fields);
    }
    if (valueType != null) {
      factory.valueType(valueType);
    }
    if (format != null) {
      factory.format(format);
    }
    if (missingMap != null) {
      factory.missingMap(missingMap);
    }
    return factory;
  }