Refine search
public static GetFieldMappingsResponse fromXContent(XContentParser parser) throws IOException { ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.nextToken(), parser::getTokenLocation); final Map<String, Map<String, Map<String, FieldMappingMetaData>>> mappings = new HashMap<>(); if (parser.nextToken() == XContentParser.Token.FIELD_NAME) { while (parser.currentToken() == XContentParser.Token.FIELD_NAME) { final String index = parser.currentName(); final Map<String, Map<String, FieldMappingMetaData>> typeMappings = PARSER.parse(parser, index); mappings.put(index, typeMappings); parser.nextToken(); } } return new GetFieldMappingsResponse(mappings); }
public static Aggregator.Parser getParser( ParseFieldRegistry<SignificanceHeuristicParser> significanceHeuristicParserRegistry) { ObjectParser<SignificantTextAggregationBuilder, Void> PARSER = new ObjectParser<>( SignificantTextAggregationBuilder.NAME); PARSER.declareInt(SignificantTextAggregationBuilder::shardSize, TermsAggregationBuilder.SHARD_SIZE_FIELD_NAME); PARSER.declareLong(SignificantTextAggregationBuilder::minDocCount, TermsAggregationBuilder.MIN_DOC_COUNT_FIELD_NAME); PARSER.declareLong(SignificantTextAggregationBuilder::shardMinDocCount, TermsAggregationBuilder.SHARD_MIN_DOC_COUNT_FIELD_NAME); PARSER.declareInt(SignificantTextAggregationBuilder::size, TermsAggregationBuilder.REQUIRED_SIZE_FIELD_NAME); PARSER.declareString(SignificantTextAggregationBuilder::fieldName, FIELD_NAME); PARSER.declareStringArray(SignificantTextAggregationBuilder::sourceFieldNames, SOURCE_FIELDS_NAME); PARSER.declareBoolean(SignificantTextAggregationBuilder::filterDuplicateText, FILTER_DUPLICATE_TEXT_FIELD_NAME); PARSER.declareObject(SignificantTextAggregationBuilder::backgroundFilter, (p, context) -> AbstractQueryBuilder.parseInnerQueryBuilder(p), SignificantTermsAggregationBuilder.BACKGROUND_FILTER); PARSER.declareField((b, v) -> b.includeExclude(IncludeExclude.merge(v, b.includeExclude())), IncludeExclude::parseInclude, IncludeExclude.INCLUDE_FIELD,
Objects.requireNonNull(defaultLang); Token token = parser.currentToken(); token = parser.nextToken(); return new Script(ScriptType.INLINE, defaultLang, parser.text(), Collections.emptyMap()); return PARSER.apply(parser, null).build(defaultLang);
protected static <T extends Builder<?>> ObjectParser<T, Void> createAllocateParser(String command) { ObjectParser<T, Void> parser = new ObjectParser<>(command); parser.declareString(Builder::setIndex, new ParseField(INDEX_FIELD)); parser.declareInt(Builder::setShard, new ParseField(SHARD_FIELD)); parser.declareString(Builder::setNode, new ParseField(NODE_FIELD)); return parser; }
protected static void declareSingleValueFields(ObjectParser<? extends ParsedSingleValueNumericMetricsAggregation, Void> objectParser, double defaultNullValue) { declareAggregationFields(objectParser); objectParser.declareField(ParsedSingleValueNumericMetricsAggregation::setValue, (parser, context) -> parseDouble(parser, defaultNullValue), CommonFields.VALUE, ValueType.DOUBLE_OR_NULL); objectParser.declareString(ParsedSingleValueNumericMetricsAggregation::setValueAsString, CommonFields.VALUE_AS_STRING); } }
static <HB extends AbstractHighlighterBuilder<HB>> BiFunction<XContentParser, HB, HB> setupParser( ObjectParser<HB, Void> parser) { parser.declareStringArray(fromList(String.class, HB::preTags), PRE_TAGS_FIELD); parser.declareStringArray(fromList(String.class, HB::postTags), POST_TAGS_FIELD); parser.declareString(HB::order, ORDER_FIELD); parser.declareBoolean(HB::highlightFilter, HIGHLIGHT_FILTER_FIELD); parser.declareInt(HB::fragmentSize, FRAGMENT_SIZE_FIELD); parser.declareInt(HB::numOfFragments, NUMBER_OF_FRAGMENTS_FIELD); parser.declareBoolean(HB::requireFieldMatch, REQUIRE_FIELD_MATCH_FIELD); parser.declareString(HB::boundaryScannerType, BOUNDARY_SCANNER_FIELD); parser.declareInt(HB::boundaryMaxScan, BOUNDARY_MAX_SCAN_FIELD); parser.declareString((HB hb, String bc) -> hb.boundaryChars(bc.toCharArray()) , BOUNDARY_CHARS_FIELD); parser.declareString(HB::boundaryScannerLocale, BOUNDARY_SCANNER_LOCALE_FIELD); parser.declareString(HB::highlighterType, TYPE_FIELD); parser.declareString(HB::fragmenter, FRAGMENTER_FIELD); parser.declareInt(HB::noMatchSize, NO_MATCH_SIZE_FIELD); parser.declareBoolean(HB::forceSource, FORCE_SOURCE_FIELD); parser.declareInt(HB::phraseLimit, PHRASE_LIMIT_FIELD); parser.declareObject(HB::options, (XContentParser p, Void c) -> { try { return p.map(); } catch (IOException e) { throw new RuntimeException("Error parsing options", e); parser.declareObject(HB::highlightQuery, (XContentParser p, Void c) -> { try { return parseInnerQueryBuilder(p); return (XContentParser p, HB hb) -> { try {
protected static void declarePercentilesFields(ObjectParser<? extends ParsedPercentiles, Void> objectParser) { ParsedAggregation.declareAggregationFields(objectParser); objectParser.declareField((parser, aggregation, context) -> { XContentParser.Token token = parser.currentToken(); if (token == XContentParser.Token.START_OBJECT) { aggregation.setKeyed(true); while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { if (token.isValue()) { if (token == XContentParser.Token.VALUE_NUMBER) { aggregation.addPercentile(Double.valueOf(parser.currentName()), parser.doubleValue()); } else if (token == XContentParser.Token.VALUE_STRING) { int i = parser.currentName().indexOf("_as_string");
XContentParser parser = xContentType.xContent() .createParser(NamedXContentRegistry.EMPTY, LoggingDeprecationHandler.INSTANCE, stream)) { Token token = parser.nextToken(); throw new ParsingException(parser.getTokenLocation(), "unexpected token [" + token + "], expected [{]"); token = parser.nextToken(); return PARSER.apply(parser, null).build(false); } else { throw new ParsingException(parser.getTokenLocation(), "unexpected token [" + token + "], expected [{, <source>]");
public static GeoQueryContext fromXContent(XContentParser parser) throws IOException { XContentParser.Token token = parser.currentToken(); GeoQueryContext.Builder builder = new Builder(); if (token == XContentParser.Token.START_OBJECT) { GEO_CONTEXT_PARSER.parse(parser, builder, null); } else if (token == XContentParser.Token.VALUE_STRING) { builder.setGeoPoint(GeoPoint.fromGeohash(parser.text())); } else { throw new ElasticsearchParseException("geo context must be an object or string"); } return builder.build(); }
protected static void declareMultiBucketAggregationFields(final ObjectParser<? extends ParsedMultiBucketAggregation, Void> objectParser, final CheckedFunction<XContentParser, ParsedBucket, IOException> bucketParser, final CheckedFunction<XContentParser, ParsedBucket, IOException> keyedBucketParser) { declareAggregationFields(objectParser); objectParser.declareField((parser, aggregation, context) -> { XContentParser.Token token = parser.currentToken(); if (token == XContentParser.Token.START_OBJECT) { aggregation.keyed = true; while (parser.nextToken() != XContentParser.Token.END_OBJECT) { aggregation.buckets.add(keyedBucketParser.apply(parser)); } } else if (token == XContentParser.Token.START_ARRAY) { aggregation.keyed = false; while (parser.nextToken() != XContentParser.Token.END_ARRAY) { aggregation.buckets.add(bucketParser.apply(parser)); } } }, CommonFields.BUCKETS, ObjectParser.ValueType.OBJECT_ARRAY); }
public <T> void declareObjectOrDefault(BiConsumer<Value, T> consumer, BiFunction<XContentParser, Context, T> objectParser, Supplier<T> defaultValue, ParseField field) { declareField((p, v, c) -> { if (p.currentToken() == XContentParser.Token.VALUE_BOOLEAN) { if (p.booleanValue()) { consumer.accept(v, defaultValue.get()); } } else { consumer.accept(v, objectParser.apply(p, c)); } }, field, ValueType.OBJECT_OR_BOOLEAN); }
public static void declareInnerHitsParseFields(ObjectParser<Map<String, Object>, Void> parser) { declareMetaDataFields(parser); parser.declareString((map, value) -> map.put(Fields._TYPE, new Text(value)), new ParseField(Fields._TYPE)); parser.declareString((map, value) -> map.put(Fields._INDEX, value), new ParseField(Fields._INDEX)); parser.declareString((map, value) -> map.put(Fields._ID, value), new ParseField(Fields._ID)); parser.declareString((map, value) -> map.put(Fields._NODE, value), new ParseField(Fields._NODE)); parser.declareField((map, value) -> map.put(Fields._SCORE, value), SearchHit::parseScore, new ParseField(Fields._SCORE), ValueType.FLOAT_OR_NULL); parser.declareLong((map, value) -> map.put(Fields._VERSION, value), new ParseField(Fields._VERSION)); parser.declareField((map, value) -> map.put(Fields._SHARD, value), (p, c) -> ShardId.fromString(p.text()), new ParseField(Fields._SHARD), ValueType.STRING); parser.declareObject((map, value) -> map.put(SourceFieldMapper.NAME, value), (p, c) -> parseSourceBytes(p), new ParseField(SourceFieldMapper.NAME)); parser.declareObject((map, value) -> map.put(Fields.HIGHLIGHT, value), (p, c) -> parseHighlightFields(p), new ParseField(Fields.HIGHLIGHT)); parser.declareObject((map, value) -> { Map<String, DocumentField> fieldMap = get(Fields.FIELDS, map, new HashMap<String, DocumentField>()); fieldMap.putAll(value); map.put(Fields.FIELDS, fieldMap); }, (p, c) -> parseFields(p), new ParseField(Fields.FIELDS)); parser.declareObject((map, value) -> map.put(Fields._EXPLANATION, value), (p, c) -> parseExplanation(p), new ParseField(Fields._EXPLANATION)); parser.declareObject((map, value) -> map.put(NestedIdentity._NESTED, value), NestedIdentity::fromXContent, new ParseField(NestedIdentity._NESTED)); parser.declareObject((map, value) -> map.put(Fields.INNER_HITS, value), (p,c) -> parseInnerHits(p), new ParseField(Fields.INNER_HITS)); parser.declareStringArray((map, list) -> map.put(Fields.MATCHED_QUERIES, list), new ParseField(Fields.MATCHED_QUERIES)); parser.declareField((map, list) -> map.put(Fields.SORT, list), SearchSortValues::fromXContent, new ParseField(Fields.SORT), ValueType.OBJECT_ARRAY); }
public static Aggregator.Parser getParser(ParseFieldRegistry<SignificanceHeuristicParser> significanceHeuristicParserRegistry) { ObjectParser<SignificantTermsAggregationBuilder, Void> aggregationParser = new ObjectParser<>(SignificantTermsAggregationBuilder.NAME); ValuesSourceParserHelper.declareAnyFields(aggregationParser, true, true); aggregationParser.declareInt(SignificantTermsAggregationBuilder::shardSize, TermsAggregationBuilder.SHARD_SIZE_FIELD_NAME); aggregationParser.declareLong(SignificantTermsAggregationBuilder::minDocCount, TermsAggregationBuilder.MIN_DOC_COUNT_FIELD_NAME); aggregationParser.declareLong(SignificantTermsAggregationBuilder::shardMinDocCount, TermsAggregationBuilder.SHARD_MIN_DOC_COUNT_FIELD_NAME); aggregationParser.declareInt(SignificantTermsAggregationBuilder::size, TermsAggregationBuilder.REQUIRED_SIZE_FIELD_NAME); aggregationParser.declareString(SignificantTermsAggregationBuilder::executionHint, TermsAggregationBuilder.EXECUTION_HINT_FIELD_NAME); aggregationParser.declareObject(SignificantTermsAggregationBuilder::backgroundFilter, (p, context) -> parseInnerQueryBuilder(p), SignificantTermsAggregationBuilder.BACKGROUND_FILTER); aggregationParser.declareField((b, v) -> b.includeExclude(IncludeExclude.merge(v, b.includeExclude())), IncludeExclude::parseInclude, IncludeExclude.INCLUDE_FIELD, ObjectParser.ValueType.OBJECT_ARRAY_OR_STRING); aggregationParser.declareField((b, v) -> b.includeExclude(IncludeExclude.merge(b.includeExclude(), v)), IncludeExclude::parseExclude, IncludeExclude.EXCLUDE_FIELD, ObjectParser.ValueType.STRING_ARRAY); aggregationParser.declareObject(SignificantTermsAggregationBuilder::significanceHeuristic, (p, context) -> { SignificanceHeuristicParser significanceHeuristicParser = significanceHeuristicParserRegistry
public static ParsedRange fromXContent(XContentParser parser, String name) throws IOException { ParsedRange aggregation = PARSER.parse(parser, null); aggregation.setName(name); return aggregation; }
public static IdsQueryBuilder fromXContent(XContentParser parser) { try { return PARSER.apply(parser, null); } catch (IllegalArgumentException e) { throw new ParsingException(parser.getTokenLocation(), e.getMessage(), e); } }
private static ObjectParser<AliasActions, Void> parser(String name, Supplier<AliasActions> supplier) { ObjectParser<AliasActions, Void> parser = new ObjectParser<>(name, supplier); parser.declareString((action, index) -> { if (action.indices() != null) { throw new IllegalArgumentException("Only one of [index] and [indices] is supported"); } action.index(index); }, INDEX); parser.declareStringArray(fromList(String.class, (action, indices) -> { if (action.indices() != null) { throw new IllegalArgumentException("Only one of [index] and [indices] is supported"); } action.indices(indices); }), INDICES); parser.declareString((action, alias) -> { if (action.aliases() != null && action.aliases().length != 0) { throw new IllegalArgumentException("Only one of [alias] and [aliases] is supported"); } action.alias(alias); }, ALIAS); parser.declareStringArray(fromList(String.class, (action, aliases) -> { if (action.aliases() != null && action.aliases().length != 0) { throw new IllegalArgumentException("Only one of [alias] and [aliases] is supported"); } action.aliases(aliases); }), ALIASES); return parser; }
public static void declareFields(ObjectParser<? extends StatusBuilder, Void> parser) { parser.declareInt(StatusBuilder::setSliceId, new ParseField(SLICE_ID_FIELD)); parser.declareLong(StatusBuilder::setTotal, new ParseField(TOTAL_FIELD)); parser.declareLong(StatusBuilder::setUpdated, new ParseField(UPDATED_FIELD)); parser.declareLong(StatusBuilder::setCreated, new ParseField(CREATED_FIELD)); parser.declareLong(StatusBuilder::setDeleted, new ParseField(DELETED_FIELD)); parser.declareInt(StatusBuilder::setBatches, new ParseField(BATCHES_FIELD)); parser.declareLong(StatusBuilder::setVersionConflicts, new ParseField(VERSION_CONFLICTS_FIELD)); parser.declareLong(StatusBuilder::setNoops, new ParseField(NOOPS_FIELD)); parser.declareObject(StatusBuilder::setRetries, RETRIES_PARSER, new ParseField(RETRIES_FIELD)); parser.declareLong(StatusBuilder::setThrottled, new ParseField(THROTTLED_RAW_FIELD)); parser.declareFloat(StatusBuilder::setRequestsPerSecond, new ParseField(REQUESTS_PER_SEC_FIELD)); parser.declareString(StatusBuilder::setReasonCancelled, new ParseField(CANCELED_FIELD)); parser.declareLong(StatusBuilder::setThrottledUntil, new ParseField(THROTTLED_UNTIL_RAW_FIELD)); parser.declareObjectArray( StatusBuilder::setSliceStatuses, (p, c) -> StatusOrException.fromXContent(p), new ParseField(SLICES_FIELD) ); }
/** * Creates a new {@link ScoreSortBuilder} from the query held by the {@link XContentParser} in * {@link org.elasticsearch.common.xcontent.XContent} format. * * @param parser the input parser. The state on the parser contained in this context will be changed as a side effect of this * method call * @param fieldName in some sort syntax variations the field name precedes the xContent object that specifies further parameters, e.g. * in '{Â "foo": { "order" : "asc"} }'. When parsing the inner object, the field name can be passed in via this argument */ public static ScoreSortBuilder fromXContent(XContentParser parser, String fieldName) { return PARSER.apply(parser, null); }
protected static void declareStatsFields(ObjectParser<? extends ParsedStats, Void> objectParser) { declareAggregationFields(objectParser); objectParser.declareLong((agg, value) -> agg.count = value, new ParseField(Fields.COUNT)); objectParser.declareField((agg, value) -> agg.min = value, (parser, context) -> parseDouble(parser, Double.POSITIVE_INFINITY), new ParseField(Fields.MIN), ValueType.DOUBLE_OR_NULL); objectParser.declareField((agg, value) -> agg.max = value, (parser, context) -> parseDouble(parser, Double.NEGATIVE_INFINITY), new ParseField(Fields.MAX), ValueType.DOUBLE_OR_NULL); objectParser.declareField((agg, value) -> agg.avg = value, (parser, context) -> parseDouble(parser, 0), new ParseField(Fields.AVG), ValueType.DOUBLE_OR_NULL); objectParser.declareField((agg, value) -> agg.sum = value, (parser, context) -> parseDouble(parser, 0), new ParseField(Fields.SUM), ValueType.DOUBLE_OR_NULL); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.MIN_AS_STRING, value), new ParseField(Fields.MIN_AS_STRING)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.MAX_AS_STRING, value), new ParseField(Fields.MAX_AS_STRING)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.AVG_AS_STRING, value), new ParseField(Fields.AVG_AS_STRING)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.SUM_AS_STRING, value), new ParseField(Fields.SUM_AS_STRING)); }
protected static void declareExtendedStatsFields(ObjectParser<? extends ParsedExtendedStats, Void> objectParser) { declareAggregationFields(objectParser); declareStatsFields(objectParser); objectParser.declareField((agg, value) -> agg.sumOfSquares = value, (parser, context) -> parseDouble(parser, 0), new ParseField(Fields.SUM_OF_SQRS), ValueType.DOUBLE_OR_NULL); objectParser.declareField((agg, value) -> agg.variance = value, (parser, context) -> parseDouble(parser, 0), new ParseField(Fields.VARIANCE), ValueType.DOUBLE_OR_NULL); objectParser.declareField((agg, value) -> agg.stdDeviation = value, (parser, context) -> parseDouble(parser, 0), new ParseField(Fields.STD_DEVIATION), ValueType.DOUBLE_OR_NULL); objectParser.declareObject(ParsedExtendedStats::setStdDeviationBounds, STD_BOUNDS_PARSER, new ParseField(Fields.STD_DEVIATION_BOUNDS)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.SUM_OF_SQRS_AS_STRING, value), new ParseField(Fields.SUM_OF_SQRS_AS_STRING)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.VARIANCE_AS_STRING, value), new ParseField(Fields.VARIANCE_AS_STRING)); objectParser.declareString((agg, value) -> agg.valueAsString.put(Fields.STD_DEVIATION_AS_STRING, value), new ParseField(Fields.STD_DEVIATION_AS_STRING)); objectParser.declareObject(ParsedExtendedStats::setStdDeviationBoundsAsString, STD_BOUNDS_AS_STRING_PARSER, new ParseField(Fields.STD_DEVIATION_BOUNDS_AS_STRING)); }