From fa9493e9e64d96e4dca2779ef90c053a6e2ae536 Mon Sep 17 00:00:00 2001 From: Binlong Gao Date: Tue, 21 Oct 2025 16:44:08 +0800 Subject: [PATCH 1/4] Replace explicit type conversion with instanceof pattern variable in org.opensearch.search package Signed-off-by: Binlong Gao --- CHANGELOG.md | 1 + .../org/opensearch/search/DocValueFormat.java | 3 +- .../org/opensearch/search/MultiValueMode.java | 4 +- .../org/opensearch/search/SearchService.java | 7 +- .../opensearch/search/SearchSortValues.java | 12 +-- .../aggregations/AggregatorFactories.java | 8 +- .../BucketCollectorProcessor.java | 80 +++++++++---------- .../InternalMultiBucketAggregation.java | 6 +- .../search/aggregations/InternalOrder.java | 14 ++-- .../aggregations/LeafBucketCollectorBase.java | 4 +- .../PipelineAggregationBuilder.java | 10 +-- .../bucket/terms/TermsAggregator.java | 11 ++- .../support/MultiValuesSource.java | 4 +- .../opensearch/search/fetch/FetchContext.java | 3 +- .../opensearch/search/fetch/FetchPhase.java | 6 +- .../search/fetch/ShardFetchRequest.java | 4 +- .../search/fetch/subphase/InnerHitsPhase.java | 3 +- .../subphase/highlight/CustomQueryScorer.java | 12 +-- .../highlight/FragmentBuilderHelper.java | 8 +- .../search/internal/ContextIndexSearcher.java | 12 +-- .../search/lookup/SourceLookup.java | 3 +- .../pipeline/PipelineConfiguration.java | 2 +- .../pipeline/ProcessorExecutionDetail.java | 19 +++-- .../pipeline/SearchPipelineService.java | 2 +- .../query/ConcurrentQueryPhaseSearcher.java | 9 ++- .../EarlyTerminatingCollectorManager.java | 4 +- .../search/query/QueryCollectorContext.java | 10 +-- .../opensearch/search/query/QueryPhase.java | 7 +- .../search/query/QuerySearchResult.java | 4 +- .../search/query/TopDocsCollectorContext.java | 21 +++-- .../rewriters/BooleanFlatteningRewriter.java | 23 +++--- .../rewriters/MatchAllRemovalRewriter.java | 20 ++--- .../rewriters/MustNotToShouldRewriter.java | 18 ++--- .../query/rewriters/MustToFilterRewriter.java | 11 +-- .../query/rewriters/TermsMergingRewriter.java | 35 ++++---- .../opensearch/search/slice/SliceBuilder.java | 4 +- .../search/sort/FieldSortBuilder.java | 22 +++-- .../search/startree/StarTreeQueryContext.java | 4 +- .../filter/DimensionFilterMergerUtils.java | 16 ++-- .../search/streaming/FlushModeResolver.java | 4 +- .../CompletionSuggestionBuilder.java | 3 +- .../completion/context/ContextMappings.java | 3 +- .../suggest/phrase/PhraseSuggestion.java | 3 +- .../phrase/PhraseSuggestionBuilder.java | 16 ++-- 44 files changed, 214 insertions(+), 261 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6b0c25ec65903..93c8c1ae70671 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), - Change implementation for `percentiles` aggregation for latency improvement ([#19648](https://github.com/opensearch-project/OpenSearch/pull/19648)) - Refactor the ThreadPoolStats.Stats class to use the Builder pattern instead of constructors ([#19306](https://github.com/opensearch-project/OpenSearch/pull/19306)) - Refactor the IndexingStats.Stats class to use the Builder pattern instead of constructors ([#19306](https://github.com/opensearch-project/OpenSearch/pull/19306)) +- Replace explicit type conversion with instanceof pattern variable in org.opensearch.search package ### Fixed - Fix Allocation and Rebalance Constraints of WeightFunction are incorrectly reset ([#19012](https://github.com/opensearch-project/OpenSearch/pull/19012)) diff --git a/server/src/main/java/org/opensearch/search/DocValueFormat.java b/server/src/main/java/org/opensearch/search/DocValueFormat.java index d2a627eda1d15..11c02c6d0eb8b 100644 --- a/server/src/main/java/org/opensearch/search/DocValueFormat.java +++ b/server/src/main/java/org/opensearch/search/DocValueFormat.java @@ -215,8 +215,7 @@ public BytesRef parseBytesRef(String value) { }; static DocValueFormat withNanosecondResolution(final DocValueFormat format) { - if (format instanceof DateTime) { - DateTime dateTime = (DateTime) format; + if (format instanceof DateTime dateTime) { return new DateTime(dateTime.formatter, dateTime.timeZone, DateFieldMapper.Resolution.NANOSECONDS); } else { throw new IllegalArgumentException("trying to convert a known date time formatter to a nanosecond one, wrong field used?"); diff --git a/server/src/main/java/org/opensearch/search/MultiValueMode.java b/server/src/main/java/org/opensearch/search/MultiValueMode.java index 930308abadca0..409a19b4b53ce 100644 --- a/server/src/main/java/org/opensearch/search/MultiValueMode.java +++ b/server/src/main/java/org/opensearch/search/MultiValueMode.java @@ -1244,8 +1244,8 @@ protected int pick(SortedDocValues values, DocIdSetIterator docItr, int startDoc */ public NumericDocValues select(final SortedNumericUnsignedLongValues values) { SortedNumericDocValues sortedNumericDocValues = null; - if (values instanceof LongToSortedNumericUnsignedLongValues) { - sortedNumericDocValues = ((LongToSortedNumericUnsignedLongValues) values).getNumericUnsignedLongValues(); + if (values instanceof LongToSortedNumericUnsignedLongValues longValues) { + sortedNumericDocValues = longValues.getNumericUnsignedLongValues(); } final NumericDocValues singleton = DocValues.unwrapSingleton(sortedNumericDocValues); diff --git a/server/src/main/java/org/opensearch/search/SearchService.java b/server/src/main/java/org/opensearch/search/SearchService.java index 9743f5103f4be..3360d5f68543b 100644 --- a/server/src/main/java/org/opensearch/search/SearchService.java +++ b/server/src/main/java/org/opensearch/search/SearchService.java @@ -1213,8 +1213,8 @@ public void updatePitIdAndKeepAlive(UpdatePitContextRequest request, ActionListe */ public PitReaderContext getPitReaderContext(ShardSearchContextId id) { ReaderContext context = activeReaders.get(id.getId()); - if (context instanceof PitReaderContext) { - return (PitReaderContext) context; + if (context instanceof PitReaderContext pitReaderContext) { + return pitReaderContext; } return null; } @@ -1225,8 +1225,7 @@ public PitReaderContext getPitReaderContext(ShardSearchContextId id) { public List getAllPITReaderContexts() { final List pitContextsInfo = new ArrayList<>(); for (ReaderContext ctx : activeReaders.values()) { - if (ctx instanceof PitReaderContext) { - final PitReaderContext context = (PitReaderContext) ctx; + if (ctx instanceof PitReaderContext context) { ListPitInfo pitInfo = new ListPitInfo(context.getPitId(), context.getCreationTime(), context.getKeepAlive()); pitContextsInfo.add(pitInfo); } diff --git a/server/src/main/java/org/opensearch/search/SearchSortValues.java b/server/src/main/java/org/opensearch/search/SearchSortValues.java index cbc3900f72f79..99a87914ff7e8 100644 --- a/server/src/main/java/org/opensearch/search/SearchSortValues.java +++ b/server/src/main/java/org/opensearch/search/SearchSortValues.java @@ -77,12 +77,12 @@ public SearchSortValues(Object[] rawSortValues, DocValueFormat[] sortValueFormat this.formattedSortValues = Arrays.copyOf(rawSortValues, rawSortValues.length); for (int i = 0; i < rawSortValues.length; ++i) { Object sortValue = rawSortValues[i]; - if (sortValue instanceof BytesRef) { - this.formattedSortValues[i] = sortValueFormats[i].format((BytesRef) sortValue); - } else if ((sortValue instanceof Long) && (sortValueFormats[i] == DocValueFormat.UNSIGNED_LONG_SHIFTED)) { - this.formattedSortValues[i] = sortValueFormats[i].format((Long) sortValue); - } else if ((sortValue instanceof Long) && (sortValueFormats[i] == DocValueFormat.UNSIGNED_LONG)) { - this.formattedSortValues[i] = sortValueFormats[i].format((Long) sortValue); + if (sortValue instanceof BytesRef bytesRef) { + this.formattedSortValues[i] = sortValueFormats[i].format(bytesRef); + } else if ((sortValue instanceof Long longValue) && (sortValueFormats[i] == DocValueFormat.UNSIGNED_LONG_SHIFTED)) { + this.formattedSortValues[i] = sortValueFormats[i].format(longValue); + } else if ((sortValue instanceof Long longValue) && (sortValueFormats[i] == DocValueFormat.UNSIGNED_LONG)) { + this.formattedSortValues[i] = sortValueFormats[i].format(longValue); } else { this.formattedSortValues[i] = sortValue; } diff --git a/server/src/main/java/org/opensearch/search/aggregations/AggregatorFactories.java b/server/src/main/java/org/opensearch/search/aggregations/AggregatorFactories.java index 720a24da1d9d4..be2a175478beb 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/AggregatorFactories.java +++ b/server/src/main/java/org/opensearch/search/aggregations/AggregatorFactories.java @@ -229,8 +229,8 @@ private static AggregatorFactories.Builder parseAggregators(XContentParser parse aggBuilder.subAggregations(subFactories); } - if (aggBuilder instanceof AggregationBuilder) { - factories.addAggregator((AggregationBuilder) aggBuilder); + if (aggBuilder instanceof AggregationBuilder aggregationBuilder) { + factories.addAggregator(aggregationBuilder); } else { factories.addPipelineAggregator((PipelineAggregationBuilder) aggBuilder); } @@ -388,8 +388,8 @@ public boolean mustVisitAllDocs() { for (AggregationBuilder builder : aggregationBuilders) { if (builder instanceof GlobalAggregationBuilder) { return true; - } else if (builder instanceof TermsAggregationBuilder) { - if (((TermsAggregationBuilder) builder).minDocCount() == 0) { + } else if (builder instanceof TermsAggregationBuilder termsAggregationBuilder) { + if (termsAggregationBuilder.minDocCount() == 0) { return true; } } diff --git a/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java b/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java index fbda705340342..ba91874c06c7a 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java +++ b/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java @@ -63,22 +63,22 @@ public void processPostCollection(Collector collectorTree) throws IOException { collectors.offer(collectorTree); while (!collectors.isEmpty()) { Collector currentCollector = collectors.poll(); - if (currentCollector instanceof InternalProfileCollector) { - collectors.offer(((InternalProfileCollector) currentCollector).getCollector()); - } else if (currentCollector instanceof MinimumScoreCollector) { - collectors.offer(((MinimumScoreCollector) currentCollector).getCollector()); - } else if (currentCollector instanceof MultiCollector) { - for (Collector innerCollector : ((MultiCollector) currentCollector).getCollectors()) { + if (currentCollector instanceof InternalProfileCollector internalProfileCollector) { + collectors.offer(internalProfileCollector.getCollector()); + } else if (currentCollector instanceof MinimumScoreCollector minimumScoreCollector) { + collectors.offer(minimumScoreCollector.getCollector()); + } else if (currentCollector instanceof MultiCollector multiCollector) { + for (Collector innerCollector : multiCollector.getCollectors()) { collectors.offer(innerCollector); } - } else if (currentCollector instanceof BucketCollector) { + } else if (currentCollector instanceof BucketCollector bucketCollector) { // Perform build aggregation during post collection - if (currentCollector instanceof Aggregator) { + if (currentCollector instanceof Aggregator aggregator) { // Do not perform postCollection for MultiBucketCollector as we are unwrapping that below - ((BucketCollector) currentCollector).postCollection(); - ((Aggregator) currentCollector).buildTopLevel(); - } else if (currentCollector instanceof MultiBucketCollector) { - for (Collector innerCollector : ((MultiBucketCollector) currentCollector).getCollectors()) { + bucketCollector.postCollection(); + aggregator.buildTopLevel(); + } else if (currentCollector instanceof MultiBucketCollector multiBucketCollector) { + for (Collector innerCollector : multiBucketCollector.getCollectors()) { collectors.offer(innerCollector); } } @@ -97,23 +97,23 @@ public List buildAggBatch(Collector collectorTree) throws I collectors.offer(collectorTree); while (!collectors.isEmpty()) { Collector currentCollector = collectors.poll(); - if (currentCollector instanceof InternalProfileCollector) { - collectors.offer(((InternalProfileCollector) currentCollector).getCollector()); - } else if (currentCollector instanceof MinimumScoreCollector) { - collectors.offer(((MinimumScoreCollector) currentCollector).getCollector()); - } else if (currentCollector instanceof MultiCollector) { - for (Collector innerCollector : ((MultiCollector) currentCollector).getCollectors()) { + if (currentCollector instanceof InternalProfileCollector internalProfileCollector) { + collectors.offer(internalProfileCollector.getCollector()); + } else if (currentCollector instanceof MinimumScoreCollector minimumScoreCollector) { + collectors.offer(minimumScoreCollector.getCollector()); + } else if (currentCollector instanceof MultiCollector multiCollector) { + for (Collector innerCollector : multiCollector.getCollectors()) { collectors.offer(innerCollector); } - } else if (currentCollector instanceof BucketCollector) { + } else if (currentCollector instanceof BucketCollector bucketCollector) { // Perform build aggregation during post collection - if (currentCollector instanceof Aggregator) { + if (currentCollector instanceof Aggregator aggregator) { // Call postCollection() before building to ensure collectors finalize their data // This is critical for aggregators like CardinalityAggregator that defer processing until postCollect() - ((BucketCollector) currentCollector).postCollection(); - aggregations.add(((Aggregator) currentCollector).buildTopLevelBatch()); - } else if (currentCollector instanceof MultiBucketCollector) { - for (Collector innerCollector : ((MultiBucketCollector) currentCollector).getCollectors()) { + bucketCollector.postCollection(); + aggregations.add(aggregator.buildTopLevelBatch()); + } else if (currentCollector instanceof MultiBucketCollector multiBucketCollector) { + for (Collector innerCollector : multiBucketCollector.getCollectors()) { collectors.offer(innerCollector); } } @@ -136,18 +136,16 @@ public List toAggregators(Collection collectors) { final Deque allCollectors = new LinkedList<>(collectors); while (!allCollectors.isEmpty()) { final Collector currentCollector = allCollectors.pop(); - if (currentCollector instanceof Aggregator) { - aggregators.add((Aggregator) currentCollector); - } else if (currentCollector instanceof InternalProfileCollector) { - if (((InternalProfileCollector) currentCollector).getCollector() instanceof Aggregator) { - aggregators.add((Aggregator) ((InternalProfileCollector) currentCollector).getCollector()); - } else if (((InternalProfileCollector) currentCollector).getCollector() instanceof MultiBucketCollector) { - allCollectors.addAll( - Arrays.asList(((MultiBucketCollector) ((InternalProfileCollector) currentCollector).getCollector()).getCollectors()) - ); + if (currentCollector instanceof Aggregator aggregator) { + aggregators.add(aggregator); + } else if (currentCollector instanceof InternalProfileCollector internalProfileCollector) { + if (internalProfileCollector.getCollector() instanceof Aggregator aggregator) { + aggregators.add(aggregator); + } else if (internalProfileCollector.getCollector() instanceof MultiBucketCollector multiBucketCollector) { + allCollectors.addAll(Arrays.asList(multiBucketCollector.getCollectors())); } - } else if (currentCollector instanceof MultiBucketCollector) { - allCollectors.addAll(Arrays.asList(((MultiBucketCollector) currentCollector).getCollectors())); + } else if (currentCollector instanceof MultiBucketCollector multiBucketCollector) { + allCollectors.addAll(Arrays.asList(multiBucketCollector.getCollectors())); } } return aggregators; @@ -167,14 +165,14 @@ public List toInternalAggregations(Collection co final Deque allCollectors = new LinkedList<>(collectors); while (!allCollectors.isEmpty()) { Collector currentCollector = allCollectors.pop(); - if (currentCollector instanceof InternalProfileCollector) { - currentCollector = ((InternalProfileCollector) currentCollector).getCollector(); + if (currentCollector instanceof InternalProfileCollector internalProfileCollector) { + currentCollector = internalProfileCollector.getCollector(); } - if (currentCollector instanceof Aggregator) { - internalAggregations.add(((Aggregator) currentCollector).getPostCollectionAggregation()); - } else if (currentCollector instanceof MultiBucketCollector) { - allCollectors.addAll(Arrays.asList(((MultiBucketCollector) currentCollector).getCollectors())); + if (currentCollector instanceof Aggregator aggregator) { + internalAggregations.add(aggregator.getPostCollectionAggregation()); + } else if (currentCollector instanceof MultiBucketCollector multiBucketCollector) { + allCollectors.addAll(Arrays.asList(multiBucketCollector.getCollectors())); } } return internalAggregations; diff --git a/server/src/main/java/org/opensearch/search/aggregations/InternalMultiBucketAggregation.java b/server/src/main/java/org/opensearch/search/aggregations/InternalMultiBucketAggregation.java index 1d9df65fee92d..4b5be1f2499ee 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/InternalMultiBucketAggregation.java +++ b/server/src/main/java/org/opensearch/search/aggregations/InternalMultiBucketAggregation.java @@ -145,16 +145,14 @@ public static int countInnerBucket(InternalBucket bucket) { */ public static int countInnerBucket(Aggregation agg) { int size = 0; - if (agg instanceof MultiBucketsAggregation) { - MultiBucketsAggregation multi = (MultiBucketsAggregation) agg; + if (agg instanceof MultiBucketsAggregation multi) { for (MultiBucketsAggregation.Bucket bucket : multi.getBuckets()) { ++size; for (Aggregation bucketAgg : bucket.getAggregations().asList()) { size += countInnerBucket(bucketAgg); } } - } else if (agg instanceof SingleBucketAggregation) { - SingleBucketAggregation single = (SingleBucketAggregation) agg; + } else if (agg instanceof SingleBucketAggregation single) { for (Aggregation bucketAgg : single.getAggregations().asList()) { size += countInnerBucket(bucketAgg); } diff --git a/server/src/main/java/org/opensearch/search/aggregations/InternalOrder.java b/server/src/main/java/org/opensearch/search/aggregations/InternalOrder.java index 13d0abd0176df..9d5f6b195c63c 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/InternalOrder.java +++ b/server/src/main/java/org/opensearch/search/aggregations/InternalOrder.java @@ -341,8 +341,8 @@ private static Comparator comparingCounts() { @SuppressWarnings("unchecked") private static Comparator comparingKeys() { return (b1, b2) -> { - if (b1 instanceof KeyComparable) { - return ((KeyComparable) b1).compareKey(b2); + if (b1 instanceof KeyComparable keyComparable) { + return keyComparable.compareKey(b2); } throw new IllegalStateException("Unexpected order bucket class [" + b1.getClass() + "]"); }; @@ -399,9 +399,9 @@ public static boolean isKeyDesc(BucketOrder order) { private static boolean isOrder(BucketOrder order, BucketOrder expected) { if (order == expected) { return true; - } else if (order instanceof CompoundOrder) { + } else if (order instanceof CompoundOrder compoundOrder) { // check if its a compound order with the first element that matches - List orders = ((CompoundOrder) order).orderElements; + List orders = compoundOrder.orderElements; if (orders.size() >= 1) { return isOrder(orders.get(0), expected); } @@ -472,12 +472,10 @@ public static BucketOrder readHistogramOrder(StreamInput in, boolean bwcOrderFla */ public static void writeOrder(BucketOrder order, StreamOutput out) throws IOException { out.writeByte(order.id()); - if (order instanceof Aggregation) { - Aggregation aggregationOrder = (Aggregation) order; + if (order instanceof Aggregation aggregationOrder) { out.writeBoolean(aggregationOrder.order == SortOrder.ASC); out.writeString(aggregationOrder.path().toString()); - } else if (order instanceof CompoundOrder) { - CompoundOrder compoundOrder = (CompoundOrder) order; + } else if (order instanceof CompoundOrder compoundOrder) { out.writeVInt(compoundOrder.orderElements.size()); for (BucketOrder innerOrder : compoundOrder.orderElements) { innerOrder.writeTo(out); diff --git a/server/src/main/java/org/opensearch/search/aggregations/LeafBucketCollectorBase.java b/server/src/main/java/org/opensearch/search/aggregations/LeafBucketCollectorBase.java index 5b5f2b7a6f8cb..4db45cf57756e 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/LeafBucketCollectorBase.java +++ b/server/src/main/java/org/opensearch/search/aggregations/LeafBucketCollectorBase.java @@ -55,8 +55,8 @@ public class LeafBucketCollectorBase extends LeafBucketCollector { */ public LeafBucketCollectorBase(LeafBucketCollector sub, Object values) { this.sub = sub; - if (values instanceof ScorerAware) { - this.values = (ScorerAware) values; + if (values instanceof ScorerAware scorerAware) { + this.values = scorerAware; } else { this.values = null; } diff --git a/server/src/main/java/org/opensearch/search/aggregations/PipelineAggregationBuilder.java b/server/src/main/java/org/opensearch/search/aggregations/PipelineAggregationBuilder.java index 7ff823dbe57f0..f0ae47a042f6d 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/PipelineAggregationBuilder.java +++ b/server/src/main/java/org/opensearch/search/aggregations/PipelineAggregationBuilder.java @@ -205,14 +205,12 @@ public void validateHasParent(String type, String name) { @Override public void validateParentAggSequentiallyOrdered(String type, String name) { - if (parent instanceof HistogramAggregationBuilder) { - HistogramAggregationBuilder histoParent = (HistogramAggregationBuilder) parent; - if (histoParent.minDocCount() != 0) { + if (parent instanceof HistogramAggregationBuilder histogramAggregationBuilder) { + if (histogramAggregationBuilder.minDocCount() != 0) { addValidationError("parent histogram of " + type + " aggregation [" + name + "] must have min_doc_count of 0"); } - } else if (parent instanceof DateHistogramAggregationBuilder) { - DateHistogramAggregationBuilder histoParent = (DateHistogramAggregationBuilder) parent; - if (histoParent.minDocCount() != 0) { + } else if (parent instanceof DateHistogramAggregationBuilder dateHistogramAggregationBuilder) { + if (dateHistogramAggregationBuilder.minDocCount() != 0) { addValidationError("parent histogram of " + type + " aggregation [" + name + "] must have min_doc_count of 0"); } } else if (parent instanceof AutoDateHistogramAggregationBuilder) { diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/TermsAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/TermsAggregator.java index e4ccc0549e4b5..41f92b6e9aaf2 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/TermsAggregator.java +++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/TermsAggregator.java @@ -256,14 +256,13 @@ public TermsAggregator( this.collectMode = collectMode; } // Don't defer any child agg if we are dependent on it for pruning results - if (order instanceof Aggregation) { - AggregationPath path = ((Aggregation) order).path(); + if (order instanceof Aggregation aggregation) { + AggregationPath path = aggregation.path(); aggsUsedForSorting.add(path.resolveTopmostAggregator(this)); - } else if (order instanceof CompoundOrder) { - CompoundOrder compoundOrder = (CompoundOrder) order; + } else if (order instanceof CompoundOrder compoundOrder) { for (BucketOrder orderElement : compoundOrder.orderElements()) { - if (orderElement instanceof Aggregation) { - AggregationPath path = ((Aggregation) orderElement).path(); + if (orderElement instanceof Aggregation aggregation) { + AggregationPath path = aggregation.path(); aggsUsedForSorting.add(path.resolveTopmostAggregator(this)); } } diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/MultiValuesSource.java b/server/src/main/java/org/opensearch/search/aggregations/support/MultiValuesSource.java index 0889a1c90d12d..53ad7fe9abae0 100644 --- a/server/src/main/java/org/opensearch/search/aggregations/support/MultiValuesSource.java +++ b/server/src/main/java/org/opensearch/search/aggregations/support/MultiValuesSource.java @@ -59,12 +59,12 @@ public NumericMultiValuesSource(Map valuesSourceConf values = new HashMap<>(valuesSourceConfigs.size()); for (Map.Entry entry : valuesSourceConfigs.entrySet()) { final ValuesSource valuesSource = entry.getValue().getValuesSource(); - if (valuesSource instanceof ValuesSource.Numeric == false) { + if (!(valuesSource instanceof ValuesSource.Numeric numericValuesSource)) { throw new AggregationExecutionException( "ValuesSource type " + valuesSource.toString() + "is not supported for multi-valued aggregation" ); } - values.put(entry.getKey(), (ValuesSource.Numeric) valuesSource); + values.put(entry.getKey(), numericValuesSource); } } diff --git a/server/src/main/java/org/opensearch/search/fetch/FetchContext.java b/server/src/main/java/org/opensearch/search/fetch/FetchContext.java index 5be3733106655..4c2a6f4887f4c 100644 --- a/server/src/main/java/org/opensearch/search/fetch/FetchContext.java +++ b/server/src/main/java/org/opensearch/search/fetch/FetchContext.java @@ -242,8 +242,7 @@ public SourceLookup getRootSourceLookup(FetchSubPhase.HitContext hitContext) { // Usually the root source simply belongs to the hit we're processing. But if // there are multiple layers of inner hits and we're in a nested context, then // the root source is found on the inner hits context. - if (searchContext instanceof InnerHitSubContext && hitContext.hit().getNestedIdentity() != null) { - InnerHitSubContext innerHitsContext = (InnerHitSubContext) searchContext; + if (searchContext instanceof InnerHitSubContext innerHitsContext && hitContext.hit().getNestedIdentity() != null) { return innerHitsContext.getRootLookup(); } else { return hitContext.sourceLookup(); diff --git a/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java b/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java index 88b8113721a91..22756432bd6b4 100644 --- a/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java +++ b/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java @@ -189,14 +189,13 @@ public void execute(SearchContext context, String profileDescription) { () -> context.searcher().getIndexReader().leaves().get(readerIndex) ); currentReaderIndex = readerIndex; - if (currentReaderContext.reader() instanceof SequentialStoredFieldsLeafReader + if (currentReaderContext.reader() instanceof SequentialStoredFieldsLeafReader lf && hasSequentialDocs && docs.length >= 10) { // All the docs to fetch are adjacent but Lucene stored fields are optimized // for random access and don't optimize for sequential access - except for merging. // So we do a little hack here and pretend we're going to do merges in order to // get better sequential access. - SequentialStoredFieldsLeafReader lf = (SequentialStoredFieldsLeafReader) currentReaderContext.reader(); fieldReader = lf.getSequentialStoredFieldsReader()::document; } else { fieldReader = currentReaderContext.reader().storedFields()::document; @@ -465,8 +464,7 @@ private HitContext prepareNestedHitContext( int nestedDocId = nestedTopDocId - subReaderContext.docBase; - if (context instanceof InnerHitsContext.InnerHitSubContext) { - InnerHitsContext.InnerHitSubContext innerHitsContext = (InnerHitsContext.InnerHitSubContext) context; + if (context instanceof InnerHitsContext.InnerHitSubContext innerHitsContext) { rootId = innerHitsContext.getId(); if (needSource) { diff --git a/server/src/main/java/org/opensearch/search/fetch/ShardFetchRequest.java b/server/src/main/java/org/opensearch/search/fetch/ShardFetchRequest.java index 8e6b2a3eef527..89f14e86c656d 100644 --- a/server/src/main/java/org/opensearch/search/fetch/ShardFetchRequest.java +++ b/server/src/main/java/org/opensearch/search/fetch/ShardFetchRequest.java @@ -102,9 +102,9 @@ public void writeTo(StreamOutput out) throws IOException { } if (lastEmittedDoc == null) { out.writeByte((byte) 0); - } else if (lastEmittedDoc instanceof FieldDoc) { + } else if (lastEmittedDoc instanceof FieldDoc fieldDoc) { out.writeByte((byte) 1); - Lucene.writeFieldDoc(out, (FieldDoc) lastEmittedDoc); + Lucene.writeFieldDoc(out, fieldDoc); } else { out.writeByte((byte) 2); Lucene.writeScoreDoc(out, lastEmittedDoc); diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/InnerHitsPhase.java b/server/src/main/java/org/opensearch/search/fetch/subphase/InnerHitsPhase.java index 0521cf936588b..1c670bbed5b78 100644 --- a/server/src/main/java/org/opensearch/search/fetch/subphase/InnerHitsPhase.java +++ b/server/src/main/java/org/opensearch/search/fetch/subphase/InnerHitsPhase.java @@ -109,8 +109,7 @@ private void hitExecute(Map innerHi ScoreDoc scoreDoc = topDoc.topDocs.scoreDocs[j]; SearchHit searchHitFields = internalHits[j]; searchHitFields.score(scoreDoc.score); - if (scoreDoc instanceof FieldDoc) { - FieldDoc fieldDoc = (FieldDoc) scoreDoc; + if (scoreDoc instanceof FieldDoc fieldDoc) { searchHitFields.sortValues(fieldDoc.fields, innerHitsContext.sort().formats); } } diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/CustomQueryScorer.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/CustomQueryScorer.java index 89c77b3cd403f..878ac1775b7ce 100644 --- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/CustomQueryScorer.java +++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/CustomQueryScorer.java @@ -101,12 +101,12 @@ protected void extract(Query query, float boost, Map t if (isChildOrParentQuery(query.getClass())) { // skip has_child or has_parent queries, see: https://github.com/elastic/elasticsearch/issues/14999 return; - } else if (query instanceof FunctionScoreQuery) { - super.extract(((FunctionScoreQuery) query).getSubQuery(), boost, terms); - } else if (query instanceof OpenSearchToParentBlockJoinQuery) { - super.extract(((OpenSearchToParentBlockJoinQuery) query).getChildQuery(), boost, terms); - } else if (query instanceof IndexOrDocValuesQuery) { - super.extract(((IndexOrDocValuesQuery) query).getIndexQuery(), boost, terms); + } else if (query instanceof FunctionScoreQuery functionScoreQuery) { + super.extract(functionScoreQuery.getSubQuery(), boost, terms); + } else if (query instanceof OpenSearchToParentBlockJoinQuery openSearchToParentBlockJoinQuery) { + super.extract(openSearchToParentBlockJoinQuery.getChildQuery(), boost, terms); + } else if (query instanceof IndexOrDocValuesQuery indexOrDocValuesQuery) { + super.extract(indexOrDocValuesQuery.getIndexQuery(), boost, terms); } else { super.extract(query, boost, terms); } diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FragmentBuilderHelper.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FragmentBuilderHelper.java index 2e94a7ba0b3f6..2eabaad0a0b0b 100644 --- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FragmentBuilderHelper.java +++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FragmentBuilderHelper.java @@ -97,11 +97,11 @@ private static int compare(int x, int y) { private static boolean containsBrokenAnalysis(Analyzer analyzer) { // TODO maybe we need a getter on Namedanalyzer that tells if this uses broken Analysis - if (analyzer instanceof NamedAnalyzer) { - analyzer = ((NamedAnalyzer) analyzer).analyzer(); + if (analyzer instanceof NamedAnalyzer namedAnalyzer) { + analyzer = namedAnalyzer.analyzer(); } - if (analyzer instanceof AnalyzerComponentsProvider) { - final TokenFilterFactory[] tokenFilters = ((AnalyzerComponentsProvider) analyzer).getComponents().getTokenFilters(); + if (analyzer instanceof AnalyzerComponentsProvider analyzerComponentsProvider) { + final TokenFilterFactory[] tokenFilters = analyzerComponentsProvider.getComponents().getTokenFilters(); for (TokenFilterFactory tokenFilterFactory : tokenFilters) { if (tokenFilterFactory.breaksFastVectorHighlighter()) { return true; diff --git a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java index 2391828886e42..0a3d894928121 100644 --- a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java +++ b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java @@ -202,8 +202,8 @@ public void setAggregatedDfs(AggregatedDfs aggregatedDfs) { @Override public Query rewrite(Query original) throws IOException { - if (original instanceof ApproximateScoreQuery) { - ((ApproximateScoreQuery) original).setContext(searchContext); + if (original instanceof ApproximateScoreQuery approximateScoreQuery) { + approximateScoreQuery.setContext(searchContext); } if (profiler != null) { profiler.startRewriteTime(); @@ -342,8 +342,8 @@ protected void searchLeaf(LeafReaderContext ctx, int minDocId, int maxDocId, Wei final LeafCollector leafCollector; try { cancellable.checkCancelled(); - if (weight instanceof ProfileWeight) { - ((ProfileWeight) weight).associateCollectorToLeaves(ctx, collector); + if (weight instanceof ProfileWeight profileWeight) { + profileWeight.associateCollectorToLeaves(ctx, collector); } weight = wrapWeight(weight); // See please https://github.com/apache/lucene/pull/964 @@ -501,9 +501,9 @@ public int count(LeafReaderContext context) throws IOException { private static BitSet getSparseBitSetOrNull(Bits liveDocs) { if (liveDocs instanceof SparseFixedBitSet) { return (BitSet) liveDocs; - } else if (liveDocs instanceof CombinedBitSet + } else if (liveDocs instanceof CombinedBitSet combinedBitSet // if the underlying role bitset is sparse - && ((CombinedBitSet) liveDocs).getFirst() instanceof SparseFixedBitSet) { + && combinedBitSet.getFirst() instanceof SparseFixedBitSet) { return (BitSet) liveDocs; } else { return null; diff --git a/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java b/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java index 4644bcb3d9b92..e6e1b2728e8fa 100644 --- a/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java +++ b/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java @@ -134,12 +134,11 @@ public void setSegmentAndDocument(LeafReaderContext context, int docId) { this.reader = context.reader(); // only reset reader and fieldReader when reader changes try { - if (context.reader() instanceof SequentialStoredFieldsLeafReader) { + if (context.reader() instanceof SequentialStoredFieldsLeafReader lf) { // All the docs to fetch are adjacent but Lucene stored fields are optimized // for random access and don't optimize for sequential access - except for merging. // So we do a little hack here and pretend we're going to do merges in order to // get better sequential access. - SequentialStoredFieldsLeafReader lf = (SequentialStoredFieldsLeafReader) context.reader(); fieldReader = lf.getSequentialStoredFieldsReader()::document; } else { fieldReader = context.reader().storedFields()::document; diff --git a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java index 2ed770be60458..5a81827b4343d 100644 --- a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java +++ b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java @@ -69,7 +69,7 @@ void setId(String id) { } void setConfig(BytesReference config, MediaType mediaType) { - if (mediaType instanceof XContentType == false) { + if (!(mediaType instanceof XContentType xContentType)) { throw new IllegalArgumentException("PipelineConfiguration does not support media type [" + mediaType.getClass() + "]"); } this.config = config; diff --git a/server/src/main/java/org/opensearch/search/pipeline/ProcessorExecutionDetail.java b/server/src/main/java/org/opensearch/search/pipeline/ProcessorExecutionDetail.java index 61c627c3dc54c..202323dfa8789 100644 --- a/server/src/main/java/org/opensearch/search/pipeline/ProcessorExecutionDetail.java +++ b/server/src/main/java/org/opensearch/search/pipeline/ProcessorExecutionDetail.java @@ -187,24 +187,23 @@ private void addFieldToXContent(XContentBuilder builder, String fieldName, Objec return; } - if (data instanceof List) { + if (data instanceof List list) { builder.startArray(fieldName); - for (Object item : (List) data) { + for (Object item : list) { writeItemToXContent(builder, item, params); } builder.endArray(); - } else if (data instanceof Map) { + } else if (data instanceof Map map) { builder.startObject(fieldName); - for (Map.Entry entry : ((Map) data).entrySet()) { + for (Map.Entry entry : map.entrySet()) { addFieldToXContent(builder, entry.getKey().toString(), entry.getValue(), params); } builder.endObject(); - } else if (data instanceof ToXContentObject) { + } else if (data instanceof ToXContentObject toXContentObject) { builder.field(fieldName); - ((ToXContentObject) data).toXContent(builder, params); - } else if (data instanceof String) { + toXContentObject.toXContent(builder, params); + } else if (data instanceof String jsonString) { // If the data is a String, attempt to parse it as JSON - String jsonString = (String) data; try { // check if its json string try ( @@ -229,8 +228,8 @@ private void addFieldToXContent(XContentBuilder builder, String fieldName, Objec } private void writeItemToXContent(XContentBuilder builder, Object item, Params params) throws IOException { - if (item instanceof ToXContentObject) { - ((ToXContentObject) item).toXContent(builder, params); + if (item instanceof ToXContentObject toXContentObject) { + toXContentObject.toXContent(builder, params); } else { builder.value(item); } diff --git a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java index 7bb3ea22c4d1a..647b251baae84 100644 --- a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java +++ b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java @@ -191,7 +191,7 @@ private static Map> processor Map> factories = collectProcessorFactories(searchPipelinePlugins, processorLoader, "Search processor"); // Sanity check: none of them should be system-generated for (Map.Entry> entry : factories.entrySet()) { - if (entry.getValue() instanceof SystemGeneratedProcessor.SystemGeneratedFactory) { + if (entry.getValue() instanceof SystemGeneratedProcessor.SystemGeneratedFactory systemGeneratedFactory) { throw new IllegalArgumentException( String.format(Locale.ROOT, "System generated factory [%s] should not be exposed to users.", entry.getKey()) ); diff --git a/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java b/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java index 771ac60dfb5e5..56596c5937d36 100644 --- a/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java +++ b/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java @@ -102,8 +102,8 @@ private static boolean searchWithCollectorManager( queryResult.terminatedEarly(false); } - if (queryCollectorContext instanceof RescoringQueryCollectorContext) { - return ((RescoringQueryCollectorContext) queryCollectorContext).shouldRescore(); + if (queryCollectorContext instanceof RescoringQueryCollectorContext rescoringContext) { + return rescoringContext.shouldRescore(); } return false; } @@ -115,12 +115,13 @@ public AggregationProcessor aggregationProcessor(SearchContext searchContext) { private static void rethrowCauseIfPossible(RuntimeException re, SearchContext searchContext) throws T { // Rethrow exception if cause is null or if it's an instance of OpenSearchException - if (re.getCause() == null || re instanceof OpenSearchException) { + if (re.getCause() == null || re instanceof OpenSearchException openSearchException) { throw re; } // Unwrap the RuntimeException and ExecutionException from Lucene concurrent search method and rethrow - if (re.getCause() instanceof ExecutionException || re.getCause() instanceof InterruptedException) { + if (re.getCause() instanceof ExecutionException executionException + || re.getCause() instanceof InterruptedException interruptedException) { Throwable t = re.getCause(); if (t.getCause() != null) { throw (T) t.getCause(); diff --git a/server/src/main/java/org/opensearch/search/query/EarlyTerminatingCollectorManager.java b/server/src/main/java/org/opensearch/search/query/EarlyTerminatingCollectorManager.java index e8153fd384b5d..4b16504eea84a 100644 --- a/server/src/main/java/org/opensearch/search/query/EarlyTerminatingCollectorManager.java +++ b/server/src/main/java/org/opensearch/search/query/EarlyTerminatingCollectorManager.java @@ -72,8 +72,8 @@ public void reduce(QuerySearchResult r) throws IOException { @Override public void onEarlyTermination(int maxCountHits, boolean forcedTermination) { - if (manager instanceof EarlyTerminatingListener) { - ((EarlyTerminatingListener) manager).onEarlyTermination(maxCountHits, forcedTermination); + if (manager instanceof EarlyTerminatingListener earlyTerminatingListener) { + earlyTerminatingListener.onEarlyTermination(maxCountHits, forcedTermination); } } } diff --git a/server/src/main/java/org/opensearch/search/query/QueryCollectorContext.java b/server/src/main/java/org/opensearch/search/query/QueryCollectorContext.java index 08b048cf682bb..70a4adb62670b 100644 --- a/server/src/main/java/org/opensearch/search/query/QueryCollectorContext.java +++ b/server/src/main/java/org/opensearch/search/query/QueryCollectorContext.java @@ -226,9 +226,9 @@ protected InternalProfileCollector createWithProfiler(InternalProfileCollector i for (CollectorManager manager : subs) { final Collector collector = manager.newCollector(); - if (collector instanceof BucketCollector) { + if (collector instanceof BucketCollector bucketCollector) { subCollectors.add( - new InternalProfileCollector(collector, CollectorResult.REASON_AGGREGATION, Collections.emptyList()) + new InternalProfileCollector(bucketCollector, CollectorResult.REASON_AGGREGATION, Collections.emptyList()) ); } else { subCollectors.add( @@ -249,10 +249,10 @@ protected InternalProfileCollectorManager createWithProfiler(InternalProfileColl children.add(in); for (CollectorManager manager : subs) { final InternalProfileCollectorManager subCollectorManager; - if (manager instanceof AggregationCollectorManager) { + if (manager instanceof AggregationCollectorManager aggregationCollectorManager) { subCollectorManager = new InternalProfileCollectorManager( - manager, - ((AggregationCollectorManager) manager).getCollectorReason(), + aggregationCollectorManager, + aggregationCollectorManager.getCollectorReason(), Collections.emptyList() ); } else { diff --git a/server/src/main/java/org/opensearch/search/query/QueryPhase.java b/server/src/main/java/org/opensearch/search/query/QueryPhase.java index f8427440a6c13..a1994803a71c6 100644 --- a/server/src/main/java/org/opensearch/search/query/QueryPhase.java +++ b/server/src/main/java/org/opensearch/search/query/QueryPhase.java @@ -290,8 +290,7 @@ static boolean executeInternal(SearchContext searchContext, QueryPhaseSearcher q ); ExecutorService executor = searchContext.indexShard().getThreadPool().executor(ThreadPool.Names.SEARCH); - if (executor instanceof EWMATrackingThreadPoolExecutor) { - final EWMATrackingThreadPoolExecutor rExecutor = (EWMATrackingThreadPoolExecutor) executor; + if (executor instanceof EWMATrackingThreadPoolExecutor rExecutor) { queryResult.nodeQueueSize(rExecutor.getCurrentQueueSize()); queryResult.serviceTimeEWMA((long) rExecutor.getTaskExecutionEWMA()); } @@ -373,8 +372,8 @@ private static boolean searchWithCollector( for (QueryCollectorContext ctx : collectors) { ctx.postProcess(queryResult); } - if (queryCollectorContext instanceof RescoringQueryCollectorContext) { - return ((RescoringQueryCollectorContext) queryCollectorContext).shouldRescore(); + if (queryCollectorContext instanceof RescoringQueryCollectorContext rescoringContext) { + return rescoringContext.shouldRescore(); } return false; } diff --git a/server/src/main/java/org/opensearch/search/query/QuerySearchResult.java b/server/src/main/java/org/opensearch/search/query/QuerySearchResult.java index f3ac953ab9d1d..aad1f31e4b0ab 100644 --- a/server/src/main/java/org/opensearch/search/query/QuerySearchResult.java +++ b/server/src/main/java/org/opensearch/search/query/QuerySearchResult.java @@ -185,8 +185,8 @@ public TopDocsAndMaxScore consumeTopDocs() { public void topDocs(TopDocsAndMaxScore topDocs, DocValueFormat[] sortValueFormats) { setTopDocs(topDocs); - if (topDocs.topDocs.scoreDocs.length > 0 && topDocs.topDocs.scoreDocs[0] instanceof FieldDoc) { - int numFields = ((FieldDoc) topDocs.topDocs.scoreDocs[0]).fields.length; + if (topDocs.topDocs.scoreDocs.length > 0 && topDocs.topDocs.scoreDocs[0] instanceof FieldDoc fieldDoc) { + int numFields = fieldDoc.fields.length; if (numFields != sortValueFormats.length) { throw new IllegalArgumentException( "The number of sort fields does not match: " + numFields + " != " + sortValueFormats.length diff --git a/server/src/main/java/org/opensearch/search/query/TopDocsCollectorContext.java b/server/src/main/java/org/opensearch/search/query/TopDocsCollectorContext.java index 97648db69bc77..67ece0f7e778e 100644 --- a/server/src/main/java/org/opensearch/search/query/TopDocsCollectorContext.java +++ b/server/src/main/java/org/opensearch/search/query/TopDocsCollectorContext.java @@ -639,8 +639,7 @@ TopDocsAndMaxScore newTopDocs(final TopDocs topDocs, final float maxScore, final } final TopDocs newTopDocs; - if (topDocs instanceof TopFieldDocs) { - TopFieldDocs fieldDocs = (TopFieldDocs) topDocs; + if (topDocs instanceof TopFieldDocs fieldDocs) { newTopDocs = new TopFieldDocs(totalHits, scoreDocs, fieldDocs.fields); } else { newTopDocs = new TopDocs(totalHits, scoreDocs); @@ -663,8 +662,7 @@ TopDocsAndMaxScore newTopDocs() { TopDocs in = topDocsSupplier.get(); float maxScore = maxScoreSupplier.get(); final TopDocs newTopDocs; - if (in instanceof TopFieldDocs) { - TopFieldDocs fieldDocs = (TopFieldDocs) in; + if (in instanceof TopFieldDocs fieldDocs) { newTopDocs = new TopFieldDocs(totalHitsSupplier.get(), fieldDocs.scoreDocs, fieldDocs.fields); } else { newTopDocs = new TopDocs(totalHitsSupplier.get(), in.scoreDocs); @@ -772,12 +770,12 @@ static int shortcutTotalHitCount(IndexReader reader, Query query) throws IOExcep // this is necessary so that we don't only optimize match_all // queries but also match_all queries that are nested in // a constant_score query - if (query instanceof ConstantScoreQuery) { - query = ((ConstantScoreQuery) query).getQuery(); - } else if (query instanceof BoostQuery) { - query = ((BoostQuery) query).getQuery(); - } else if (query instanceof ApproximateScoreQuery) { - query = ((ApproximateScoreQuery) query).getOriginalQuery(); + if (query instanceof ConstantScoreQuery constantScoreQuery) { + query = constantScoreQuery.getQuery(); + } else if (query instanceof BoostQuery boostQuery) { + query = boostQuery.getQuery(); + } else if (query instanceof ApproximateScoreQuery approximateScoreQuery) { + query = approximateScoreQuery.getOriginalQuery(); } else { break; } @@ -925,8 +923,7 @@ public QueryVisitor getSubVisitor(BooleanClause.Occur occur, Query parent) { void checkMaxScoreInfo(Query query) { if (query instanceof FunctionScoreQuery || query instanceof ScriptScoreQuery || query instanceof SpanQuery) { hasInfMaxScore = true; - } else if (query instanceof OpenSearchToParentBlockJoinQuery) { - OpenSearchToParentBlockJoinQuery q = (OpenSearchToParentBlockJoinQuery) query; + } else if (query instanceof OpenSearchToParentBlockJoinQuery q) { hasInfMaxScore |= (q.getScoreMode() != org.apache.lucene.search.join.ScoreMode.None); } } diff --git a/server/src/main/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriter.java b/server/src/main/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriter.java index 73a05888e384f..d0567af2b1119 100644 --- a/server/src/main/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriter.java +++ b/server/src/main/java/org/opensearch/search/query/rewriters/BooleanFlatteningRewriter.java @@ -44,12 +44,10 @@ private BooleanFlatteningRewriter() { @Override public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { - if (!(query instanceof BoolQueryBuilder)) { + if (!(query instanceof BoolQueryBuilder boolQuery)) { return query; } - BoolQueryBuilder boolQuery = (BoolQueryBuilder) query; - // First check if flattening is needed if (!needsFlattening(boolQuery)) { return query; @@ -73,8 +71,7 @@ private boolean needsFlattening(BoolQueryBuilder boolQuery) { private boolean hasFlattenableBool(List clauses, ClauseType parentType) { for (QueryBuilder clause : clauses) { - if (clause instanceof BoolQueryBuilder) { - BoolQueryBuilder nestedBool = (BoolQueryBuilder) clause; + if (clause instanceof BoolQueryBuilder nestedBool) { // Can flatten if nested bool only has one type of clause matching parent if (canFlatten(nestedBool, parentType)) { return true; @@ -86,22 +83,22 @@ private boolean hasFlattenableBool(List clauses, ClauseType parent private boolean hasNestedBoolThatNeedsFlattening(BoolQueryBuilder boolQuery) { for (QueryBuilder clause : boolQuery.must()) { - if (clause instanceof BoolQueryBuilder && needsFlattening((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsFlattening(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.filter()) { - if (clause instanceof BoolQueryBuilder && needsFlattening((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsFlattening(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.should()) { - if (clause instanceof BoolQueryBuilder && needsFlattening((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsFlattening(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.mustNot()) { - if (clause instanceof BoolQueryBuilder && needsFlattening((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsFlattening(boolQueryBuilder)) { return true; } } @@ -126,15 +123,13 @@ private BoolQueryBuilder flattenBoolQuery(BoolQueryBuilder original) { private void flattenClauses(List clauses, BoolQueryBuilder target, ClauseType clauseType) { for (QueryBuilder clause : clauses) { - if (clause instanceof BoolQueryBuilder) { - BoolQueryBuilder nestedBool = (BoolQueryBuilder) clause; - + if (clause instanceof BoolQueryBuilder nestedBool) { if (canFlatten(nestedBool, clauseType)) { // General flattening for same-clause-type nesting List nestedClauses = getClausesForType(nestedBool, clauseType); for (QueryBuilder nestedClause : nestedClauses) { - if (nestedClause instanceof BoolQueryBuilder) { - nestedClause = flattenBoolQuery((BoolQueryBuilder) nestedClause); + if (nestedClause instanceof BoolQueryBuilder nestedBoolQueryBuilder) { + nestedClause = flattenBoolQuery(nestedBoolQueryBuilder); } addClauseBasedOnType(target, nestedClause, clauseType); } diff --git a/server/src/main/java/org/opensearch/search/query/rewriters/MatchAllRemovalRewriter.java b/server/src/main/java/org/opensearch/search/query/rewriters/MatchAllRemovalRewriter.java index 39d2257e483bc..7cb31b15695d5 100644 --- a/server/src/main/java/org/opensearch/search/query/rewriters/MatchAllRemovalRewriter.java +++ b/server/src/main/java/org/opensearch/search/query/rewriters/MatchAllRemovalRewriter.java @@ -31,8 +31,8 @@ private MatchAllRemovalRewriter() { @Override public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { - if (query instanceof BoolQueryBuilder) { - return rewriteBoolQuery((BoolQueryBuilder) query); + if (query instanceof BoolQueryBuilder boolQueryBuilder) { + return rewriteBoolQuery(boolQueryBuilder); } return query; } @@ -126,22 +126,22 @@ private boolean hasMatchAll(List clauses) { private boolean hasNestedBoolThatNeedsRewrite(BoolQueryBuilder bool) { for (QueryBuilder q : bool.must()) { - if (q instanceof BoolQueryBuilder && shouldRewrite((BoolQueryBuilder) q)) { + if (q instanceof BoolQueryBuilder boolQueryBuilder && shouldRewrite(boolQueryBuilder)) { return true; } } for (QueryBuilder q : bool.filter()) { - if (q instanceof BoolQueryBuilder && shouldRewrite((BoolQueryBuilder) q)) { + if (q instanceof BoolQueryBuilder boolQueryBuilder && shouldRewrite(boolQueryBuilder)) { return true; } } for (QueryBuilder q : bool.should()) { - if (q instanceof BoolQueryBuilder && shouldRewrite((BoolQueryBuilder) q)) { + if (q instanceof BoolQueryBuilder boolQueryBuilder && shouldRewrite(boolQueryBuilder)) { return true; } } for (QueryBuilder q : bool.mustNot()) { - if (q instanceof BoolQueryBuilder && shouldRewrite((BoolQueryBuilder) q)) { + if (q instanceof BoolQueryBuilder boolQueryBuilder && shouldRewrite(boolQueryBuilder)) { return true; } } @@ -182,8 +182,8 @@ private void processClauses(List clauses, ClauseAdder adder, boole if (!removeMatchAll) { // For should/mustNot, don't remove match_all for (QueryBuilder clause : clauses) { - if (clause instanceof BoolQueryBuilder) { - adder.addClause(rewriteBoolQuery((BoolQueryBuilder) clause)); + if (clause instanceof BoolQueryBuilder boolQueryBuilder) { + adder.addClause(rewriteBoolQuery(boolQueryBuilder)); } else { adder.addClause(clause); } @@ -197,8 +197,8 @@ private void processClauses(List clauses, ClauseAdder adder, boole boolean hasOtherClauses = hasNonMatchAllInSameList(clauses) || hasClausesInOtherLists(original); for (QueryBuilder clause : clauses) { - if (clause instanceof BoolQueryBuilder) { - adder.addClause(rewriteBoolQuery((BoolQueryBuilder) clause)); + if (clause instanceof BoolQueryBuilder boolQueryBuilder) { + adder.addClause(rewriteBoolQuery(boolQueryBuilder)); } else if (clause instanceof MatchAllQueryBuilder && hasOtherClauses) { // Skip match_all continue; diff --git a/server/src/main/java/org/opensearch/search/query/rewriters/MustNotToShouldRewriter.java b/server/src/main/java/org/opensearch/search/query/rewriters/MustNotToShouldRewriter.java index ddcbea48b4b12..13745c7727d1b 100644 --- a/server/src/main/java/org/opensearch/search/query/rewriters/MustNotToShouldRewriter.java +++ b/server/src/main/java/org/opensearch/search/query/rewriters/MustNotToShouldRewriter.java @@ -57,12 +57,10 @@ private MustNotToShouldRewriter() { @Override public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { - if (!(query instanceof BoolQueryBuilder)) { + if (!(query instanceof BoolQueryBuilder boolQuery)) { return query; } - BoolQueryBuilder boolQuery = (BoolQueryBuilder) query; - // We need LeafReaderContexts to verify single-valued fields (only for must_not rewriting) List leafReaderContexts = null; List mustNotClausesToRewrite = new ArrayList<>(); @@ -75,16 +73,14 @@ public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { // Find complement-aware queries that can be rewritten for (QueryBuilder clause : boolQuery.mustNot()) { - if (clause instanceof ComplementAwareQueryBuilder && clause instanceof WithFieldName) { - WithFieldName wfn = (WithFieldName) clause; + if (clause instanceof ComplementAwareQueryBuilder complementAwareQueryBuilder && clause instanceof WithFieldName wfn) { fieldCounts.merge(wfn.fieldName(), 1, Integer::sum); } } // For now, only handle the case where there's exactly 1 complement-aware query per field for (QueryBuilder clause : boolQuery.mustNot()) { - if (clause instanceof ComplementAwareQueryBuilder && clause instanceof WithFieldName) { - WithFieldName wfn = (WithFieldName) clause; + if (clause instanceof ComplementAwareQueryBuilder complementAwareQueryBuilder && clause instanceof WithFieldName wfn) { String fieldName = wfn.fieldName(); if (fieldCounts.getOrDefault(fieldName, 0) == 1) { @@ -162,14 +158,14 @@ public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { // Check if any nested queries were rewritten boolean nestedQueriesChanged = false; for (QueryBuilder mustClause : boolQuery.must()) { - if (mustClause instanceof BoolQueryBuilder && rewritten.must().contains(mustClause) == false) { + if (mustClause instanceof BoolQueryBuilder boolQueryBuilder && rewritten.must().contains(mustClause) == false) { nestedQueriesChanged = true; break; } } if (!nestedQueriesChanged) { for (QueryBuilder filterClause : boolQuery.filter()) { - if (filterClause instanceof BoolQueryBuilder && rewritten.filter().contains(filterClause) == false) { + if (filterClause instanceof BoolQueryBuilder boolQueryBuilder && rewritten.filter().contains(filterClause) == false) { nestedQueriesChanged = true; break; } @@ -177,7 +173,7 @@ public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { } if (!nestedQueriesChanged) { for (QueryBuilder shouldClause : boolQuery.should()) { - if (shouldClause instanceof BoolQueryBuilder && rewritten.should().contains(shouldClause) == false) { + if (shouldClause instanceof BoolQueryBuilder boolQueryBuilder && rewritten.should().contains(shouldClause) == false) { nestedQueriesChanged = true; break; } @@ -185,7 +181,7 @@ public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { } if (!nestedQueriesChanged) { for (QueryBuilder mustNotClause : boolQuery.mustNot()) { - if (mustNotClause instanceof BoolQueryBuilder && rewritten.mustNot().contains(mustNotClause) == false) { + if (mustNotClause instanceof BoolQueryBuilder boolQueryBuilder && rewritten.mustNot().contains(mustNotClause) == false) { nestedQueriesChanged = true; break; } diff --git a/server/src/main/java/org/opensearch/search/query/rewriters/MustToFilterRewriter.java b/server/src/main/java/org/opensearch/search/query/rewriters/MustToFilterRewriter.java index 4960302d0c812..fa9c1e9f3645e 100644 --- a/server/src/main/java/org/opensearch/search/query/rewriters/MustToFilterRewriter.java +++ b/server/src/main/java/org/opensearch/search/query/rewriters/MustToFilterRewriter.java @@ -55,12 +55,10 @@ private MustToFilterRewriter() { @Override public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { - if (!(query instanceof BoolQueryBuilder)) { + if (!(query instanceof BoolQueryBuilder boolQuery)) { return query; } - BoolQueryBuilder boolQuery = (BoolQueryBuilder) query; - // If there are no must clauses, nothing to rewrite if (boolQuery.must().isEmpty()) { return query; @@ -131,8 +129,8 @@ public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { private QueryBuilder rewriteIfNeeded(QueryBuilder query, QueryShardContext context) { // Recursively rewrite nested boolean queries - if (query instanceof BoolQueryBuilder) { - return rewrite(query, context); + if (query instanceof BoolQueryBuilder boolQueryBuilder) { + return rewrite(boolQueryBuilder, context); } return query; } @@ -149,9 +147,8 @@ private boolean isClauseIrrelevantToScoring(QueryBuilder clause, QueryShardConte // Skip moving these clauses if we don't have the shard context. if (context == null) return false; - if (!(clause instanceof WithFieldName)) return false; + if (!(clause instanceof WithFieldName wfn)) return false; - WithFieldName wfn = (WithFieldName) clause; MappedFieldType fieldType = context.fieldMapper(wfn.fieldName()); if (!(fieldType instanceof NumberFieldMapper.NumberFieldType)) return false; diff --git a/server/src/main/java/org/opensearch/search/query/rewriters/TermsMergingRewriter.java b/server/src/main/java/org/opensearch/search/query/rewriters/TermsMergingRewriter.java index 9c4d863602091..6aac2580005a3 100644 --- a/server/src/main/java/org/opensearch/search/query/rewriters/TermsMergingRewriter.java +++ b/server/src/main/java/org/opensearch/search/query/rewriters/TermsMergingRewriter.java @@ -88,12 +88,10 @@ public void initialize(Settings settings, ClusterSettings clusterSettings) { @Override public QueryBuilder rewrite(QueryBuilder query, QueryShardContext context) { - if (!(query instanceof BoolQueryBuilder)) { + if (!(query instanceof BoolQueryBuilder boolQuery)) { return query; } - BoolQueryBuilder boolQuery = (BoolQueryBuilder) query; - // First check if merging is needed if (!needsMerging(boolQuery)) { return query; @@ -129,8 +127,7 @@ private boolean hasMergeableTerms(List clauses) { Map> fieldBoosts = new HashMap<>(); for (QueryBuilder clause : clauses) { - if (clause instanceof TermQueryBuilder) { - TermQueryBuilder termQuery = (TermQueryBuilder) clause; + if (clause instanceof TermQueryBuilder termQuery) { String field = termQuery.fieldName(); float boost = termQuery.boost(); @@ -145,15 +142,13 @@ private boolean hasMergeableTerms(List clauses) { return true; } } - } else if (clause instanceof TermsQueryBuilder) { + } else if (clause instanceof TermsQueryBuilder termsQuery) { // Check if there are enough term queries that can be merged with this terms query - TermsQueryBuilder termsQuery = (TermsQueryBuilder) clause; String field = termsQuery.fieldName(); int additionalTerms = 0; for (QueryBuilder other : clauses) { - if (other != clause && other instanceof TermQueryBuilder) { - TermQueryBuilder termQuery = (TermQueryBuilder) other; + if (other != clause && other instanceof TermQueryBuilder termQuery) { if (field.equals(termQuery.fieldName()) && termsQuery.boost() == termQuery.boost()) { additionalTerms++; } @@ -172,22 +167,22 @@ private boolean hasMergeableTerms(List clauses) { private boolean hasNestedBoolThatNeedsMerging(BoolQueryBuilder boolQuery) { for (QueryBuilder clause : boolQuery.must()) { - if (clause instanceof BoolQueryBuilder && needsMerging((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsMerging(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.filter()) { - if (clause instanceof BoolQueryBuilder && needsMerging((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsMerging(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.should()) { - if (clause instanceof BoolQueryBuilder && needsMerging((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsMerging(boolQueryBuilder)) { return true; } } for (QueryBuilder clause : boolQuery.mustNot()) { - if (clause instanceof BoolQueryBuilder && needsMerging((BoolQueryBuilder) clause)) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder && needsMerging(boolQueryBuilder)) { return true; } } @@ -200,8 +195,7 @@ private void rewriteClauses(List clauses, ClauseAdder adder) { // Group term queries by field for (QueryBuilder clause : clauses) { - if (clause instanceof TermQueryBuilder) { - TermQueryBuilder termQuery = (TermQueryBuilder) clause; + if (clause instanceof TermQueryBuilder termQuery) { String field = termQuery.fieldName(); float boost = termQuery.boost(); @@ -212,9 +206,8 @@ private void rewriteClauses(List clauses, ClauseAdder adder) { } else { termsMap.computeIfAbsent(field, k -> new TermsInfo(boost)).addValue(termQuery.value()); } - } else if (clause instanceof TermsQueryBuilder) { + } else if (clause instanceof TermsQueryBuilder termsQuery) { // Existing terms query - add to it - TermsQueryBuilder termsQuery = (TermsQueryBuilder) clause; String field = termsQuery.fieldName(); float boost = termsQuery.boost(); @@ -228,9 +221,9 @@ private void rewriteClauses(List clauses, ClauseAdder adder) { info.addValue(value); } } - } else if (clause instanceof BoolQueryBuilder) { + } else if (clause instanceof BoolQueryBuilder boolQueryBuilder) { // Recursively rewrite nested bool queries - nonTermClauses.add(rewrite(clause, null)); + nonTermClauses.add(rewrite(boolQueryBuilder, null)); } else { nonTermClauses.add(clause); } @@ -275,9 +268,9 @@ private void rewriteClauses(List clauses, ClauseAdder adder) { private void rewriteClausesNoMerge(List clauses, ClauseAdder adder) { for (QueryBuilder clause : clauses) { - if (clause instanceof BoolQueryBuilder) { + if (clause instanceof BoolQueryBuilder boolQueryBuilder) { // Recursively rewrite nested bool queries - adder.addClause(rewrite(clause, null)); + adder.addClause(rewrite(boolQueryBuilder, null)); } else { adder.addClause(clause); } diff --git a/server/src/main/java/org/opensearch/search/slice/SliceBuilder.java b/server/src/main/java/org/opensearch/search/slice/SliceBuilder.java index 691b829578e1f..257f8a8d2e39d 100644 --- a/server/src/main/java/org/opensearch/search/slice/SliceBuilder.java +++ b/server/src/main/java/org/opensearch/search/slice/SliceBuilder.java @@ -201,11 +201,9 @@ public static SliceBuilder fromXContent(XContentParser parser) throws IOExceptio @Override public boolean equals(Object other) { - if (!(other instanceof SliceBuilder)) { + if (!(other instanceof SliceBuilder o)) { return false; } - - SliceBuilder o = (SliceBuilder) other; return ((field == null && o.field == null) || field.equals(o.field)) && id == o.id && o.max == max; } diff --git a/server/src/main/java/org/opensearch/search/sort/FieldSortBuilder.java b/server/src/main/java/org/opensearch/search/sort/FieldSortBuilder.java index e592b2567d8ff..ea4efba7e49d3 100644 --- a/server/src/main/java/org/opensearch/search/sort/FieldSortBuilder.java +++ b/server/src/main/java/org/opensearch/search/sort/FieldSortBuilder.java @@ -427,20 +427,19 @@ public SortFieldAndFormat build(QueryShardContext context) throws IOException { final SortField field; boolean isNanosecond = false; if (numericType != null) { - if (fieldData instanceof IndexNumericFieldData == false) { + if (!(fieldData instanceof IndexNumericFieldData numericFieldData)) { throw new QueryShardException( context, "[numeric_type] option cannot be set on a non-numeric field, got " + fieldType.typeName() ); } - IndexNumericFieldData numericFieldData = (IndexNumericFieldData) fieldData; NumericType resolvedType = resolveNumericType(numericType); field = numericFieldData.sortField(resolvedType, missing, localSortMode(), nested, reverse); isNanosecond = resolvedType == NumericType.DATE_NANOSECONDS; } else { field = fieldData.sortField(missing, localSortMode(), nested, reverse); - if (fieldData instanceof IndexNumericFieldData) { - isNanosecond = ((IndexNumericFieldData) fieldData).getNumericType() == NumericType.DATE_NANOSECONDS; + if (fieldData instanceof IndexNumericFieldData numericFieldData) { + isNanosecond = numericFieldData.getNumericType() == NumericType.DATE_NANOSECONDS; } } DocValueFormat format = fieldType.docValueFormat(null, null); @@ -476,8 +475,8 @@ public boolean isBottomSortShardDisjoint(QueryShardContext context, SearchSortVa } DocValueFormat docValueFormat = bottomSortValues.getSortValueFormats()[0]; final DateMathParser dateMathParser; - if (docValueFormat instanceof DocValueFormat.DateTime) { - dateMathParser = ((DocValueFormat.DateTime) docValueFormat).getDateMathParser(); + if (docValueFormat instanceof DocValueFormat.DateTime dateTime) { + dateMathParser = dateTime.getDateMathParser(); } else { dateMathParser = null; } @@ -520,13 +519,12 @@ public BucketedSort buildBucketedSort(QueryShardContext context, int bucketSize, throw new QueryShardException(context, "we only support AVG, MEDIAN and SUM on number based fields"); } if (numericType != null) { - if (fieldData instanceof IndexNumericFieldData == false) { + if (!(fieldData instanceof IndexNumericFieldData numericFieldData)) { throw new QueryShardException( context, "[numeric_type] option cannot be set on a non-numeric field, got " + fieldType.typeName() ); } - IndexNumericFieldData numericFieldData = (IndexNumericFieldData) fieldData; NumericType resolvedType = resolveNumericType(numericType); return numericFieldData.newBucketedSort( resolvedType, @@ -609,7 +607,7 @@ public static FieldSortBuilder getPrimaryFieldSortOrNull(SearchSourceBuilder sou if (source == null || source.sorts() == null || source.sorts().isEmpty()) { return null; } - return source.sorts().get(0) instanceof FieldSortBuilder ? (FieldSortBuilder) source.sorts().get(0) : null; + return source.sorts().get(0) instanceof FieldSortBuilder fieldSortBuilder ? fieldSortBuilder : null; } /** @@ -680,8 +678,7 @@ private static MinAndMax extractNumericMinAndMax( if (PointValues.size(reader, fieldName) == 0) { return null; } - if (fieldType.unwrap() instanceof NumberFieldType) { - NumberFieldType numberFieldType = (NumberFieldType) fieldType; + if (fieldType.unwrap() instanceof NumberFieldType numberFieldType) { Number minPoint = numberFieldType.parsePoint(PointValues.getMinPackedValue(reader, fieldName)); Number maxPoint = numberFieldType.parsePoint(PointValues.getMaxPackedValue(reader, fieldName)); switch (IndexSortConfig.getSortFieldType(sortField)) { @@ -701,8 +698,7 @@ private static MinAndMax extractNumericMinAndMax( default: return null; } - } else if (fieldType.unwrap() instanceof DateFieldType) { - DateFieldType dateFieldType = (DateFieldType) fieldType; + } else if (fieldType.unwrap() instanceof DateFieldType dateFieldType) { Function dateConverter = createDateConverter(sortBuilder, dateFieldType); Long min = dateConverter.apply(PointValues.getMinPackedValue(reader, fieldName)); Long max = dateConverter.apply(PointValues.getMaxPackedValue(reader, fieldName)); diff --git a/server/src/main/java/org/opensearch/search/startree/StarTreeQueryContext.java b/server/src/main/java/org/opensearch/search/startree/StarTreeQueryContext.java index 639825c1ee3dd..80b016e69cfaf 100644 --- a/server/src/main/java/org/opensearch/search/startree/StarTreeQueryContext.java +++ b/server/src/main/java/org/opensearch/search/startree/StarTreeQueryContext.java @@ -200,8 +200,8 @@ private static boolean validateDateHistogramSupport( // Find the DateDimension in the dimensions list DateDimension starTreeDateDimension = null; for (Dimension dimension : compositeIndexFieldInfo.getDimensions()) { - if (dimension instanceof DateDimension) { - starTreeDateDimension = (DateDimension) dimension; + if (dimension instanceof DateDimension dateDimension) { + starTreeDateDimension = dateDimension; break; } } diff --git a/server/src/main/java/org/opensearch/search/startree/filter/DimensionFilterMergerUtils.java b/server/src/main/java/org/opensearch/search/startree/filter/DimensionFilterMergerUtils.java index cd2db2a533c1c..082447c278dc4 100644 --- a/server/src/main/java/org/opensearch/search/startree/filter/DimensionFilterMergerUtils.java +++ b/server/src/main/java/org/opensearch/search/startree/filter/DimensionFilterMergerUtils.java @@ -42,23 +42,23 @@ public static DimensionFilter intersect(DimensionFilter filter1, DimensionFilter } // Handle Range + Range combination - if (filter1 instanceof RangeMatchDimFilter && filter2 instanceof RangeMatchDimFilter) { - return intersectRangeFilters((RangeMatchDimFilter) filter1, (RangeMatchDimFilter) filter2, mapper); + if (filter1 instanceof RangeMatchDimFilter rangeFilter1 && filter2 instanceof RangeMatchDimFilter rangeFilter2) { + return intersectRangeFilters(rangeFilter1, rangeFilter2, mapper); } // Handle ExactMatch + ExactMatch combination - if (filter1 instanceof ExactMatchDimFilter && filter2 instanceof ExactMatchDimFilter) { - return intersectExactMatchFilters((ExactMatchDimFilter) filter1, (ExactMatchDimFilter) filter2); + if (filter1 instanceof ExactMatchDimFilter exactFilter1 && filter2 instanceof ExactMatchDimFilter exactFilter2) { + return intersectExactMatchFilters(exactFilter1, exactFilter2); } // Handle Range + ExactMatch combination - if (filter1 instanceof RangeMatchDimFilter && filter2 instanceof ExactMatchDimFilter) { - return intersectRangeWithExactMatch((RangeMatchDimFilter) filter1, (ExactMatchDimFilter) filter2, mapper); + if (filter1 instanceof RangeMatchDimFilter rangeFilter && filter2 instanceof ExactMatchDimFilter exactFilter) { + return intersectRangeWithExactMatch(rangeFilter, exactFilter, mapper); } // Handle ExactMatch + Range combination - if (filter1 instanceof ExactMatchDimFilter && filter2 instanceof RangeMatchDimFilter) { - return intersectRangeWithExactMatch((RangeMatchDimFilter) filter2, (ExactMatchDimFilter) filter1, mapper); + if (filter1 instanceof ExactMatchDimFilter exactFilter && filter2 instanceof RangeMatchDimFilter rangeFilter) { + return intersectRangeWithExactMatch(rangeFilter, exactFilter, mapper); } // throw exception for unsupported exception diff --git a/server/src/main/java/org/opensearch/search/streaming/FlushModeResolver.java b/server/src/main/java/org/opensearch/search/streaming/FlushModeResolver.java index b03cff1a30caf..d06d533f5f960 100644 --- a/server/src/main/java/org/opensearch/search/streaming/FlushModeResolver.java +++ b/server/src/main/java/org/opensearch/search/streaming/FlushModeResolver.java @@ -120,8 +120,8 @@ private static StreamingCostMetrics collectMetrics(Collector collector) { return StreamingCostMetrics.nonStreamable(); } StreamingCostMetrics nodeMetrics; - if (collector instanceof Streamable) { - nodeMetrics = ((Streamable) collector).getStreamingCostMetrics(); + if (collector instanceof Streamable streamable) { + nodeMetrics = streamable.getStreamingCostMetrics(); if (!nodeMetrics.isStreamable()) { return StreamingCostMetrics.nonStreamable(); } diff --git a/server/src/main/java/org/opensearch/search/suggest/completion/CompletionSuggestionBuilder.java b/server/src/main/java/org/opensearch/search/suggest/completion/CompletionSuggestionBuilder.java index 98f33cdb89616..1455bb14ba5e4 100644 --- a/server/src/main/java/org/opensearch/search/suggest/completion/CompletionSuggestionBuilder.java +++ b/server/src/main/java/org/opensearch/search/suggest/completion/CompletionSuggestionBuilder.java @@ -311,8 +311,7 @@ public SuggestionContext build(QueryShardContext context) throws IOException { if (mappedFieldType == null || mappedFieldType.unwrap() instanceof CompletionFieldMapper.CompletionFieldType == false) { throw new IllegalArgumentException("Field [" + suggestionContext.getField() + "] is not a completion suggest field"); } - if (mappedFieldType.unwrap() instanceof CompletionFieldMapper.CompletionFieldType) { - CompletionFieldMapper.CompletionFieldType type = (CompletionFieldMapper.CompletionFieldType) mappedFieldType; + if (mappedFieldType.unwrap() instanceof CompletionFieldMapper.CompletionFieldType type) { suggestionContext.setFieldType(type); if (type.hasContextMappings() && contextBytes != null) { Map> queryContexts = parseContextBytes( diff --git a/server/src/main/java/org/opensearch/search/suggest/completion/context/ContextMappings.java b/server/src/main/java/org/opensearch/search/suggest/completion/context/ContextMappings.java index cff5a901a473f..3bbcdb7ed05ca 100644 --- a/server/src/main/java/org/opensearch/search/suggest/completion/context/ContextMappings.java +++ b/server/src/main/java/org/opensearch/search/suggest/completion/context/ContextMappings.java @@ -306,10 +306,9 @@ public int hashCode() { @Override public boolean equals(Object obj) { - if (obj == null || (obj instanceof ContextMappings) == false) { + if (!(obj instanceof ContextMappings other)) { return false; } - ContextMappings other = ((ContextMappings) obj); return contextMappings.equals(other.contextMappings); } diff --git a/server/src/main/java/org/opensearch/search/suggest/phrase/PhraseSuggestion.java b/server/src/main/java/org/opensearch/search/suggest/phrase/PhraseSuggestion.java index b342f628aa4ac..9d10ebe0eadc7 100644 --- a/server/src/main/java/org/opensearch/search/suggest/phrase/PhraseSuggestion.java +++ b/server/src/main/java/org/opensearch/search/suggest/phrase/PhraseSuggestion.java @@ -126,10 +126,9 @@ protected void merge(Suggestion.Entry