From a4f4544381b0f80d4feafef226d72170ee5e95c7 Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Fri, 11 Apr 2025 15:46:48 +0530 Subject: [PATCH 1/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../opensearch/index/search/NestedHelper.java | 142 +++++++----------- 1 file changed, 56 insertions(+), 86 deletions(-) diff --git a/server/src/main/java/org/opensearch/index/search/NestedHelper.java b/server/src/main/java/org/opensearch/index/search/NestedHelper.java index fd8527924083a..4c5f7e7589e14 100644 --- a/server/src/main/java/org/opensearch/index/search/NestedHelper.java +++ b/server/src/main/java/org/opensearch/index/search/NestedHelper.java @@ -63,52 +63,37 @@ public NestedHelper(MapperService mapperService) { /** Returns true if the given query might match nested documents. */ public boolean mightMatchNestedDocs(Query query) { - if (query instanceof ConstantScoreQuery) { - return mightMatchNestedDocs(((ConstantScoreQuery) query).getQuery()); - } else if (query instanceof BoostQuery) { - return mightMatchNestedDocs(((BoostQuery) query).getQuery()); - } else if (query instanceof MatchAllDocsQuery) { - return true; - } else if (query instanceof MatchNoDocsQuery) { - return false; - } else if (query instanceof TermQuery) { - // We only handle term(s) queries and range queries, which should already - // cover a high majority of use-cases - return mightMatchNestedDocs(((TermQuery) query).getTerm().field()); - } else if (query instanceof TermInSetQuery) { - final TermInSetQuery termInSetQuery = (TermInSetQuery) query; - if (termInSetQuery.getTermsCount() > 0) { - return mightMatchNestedDocs(termInSetQuery.getField()); - } else { - return false; - } - } else if (query instanceof PointRangeQuery) { - return mightMatchNestedDocs(((PointRangeQuery) query).getField()); - } else if (query instanceof IndexOrDocValuesQuery) { - return mightMatchNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery()); - } else if (query instanceof ApproximateScoreQuery) { - return mightMatchNestedDocs(((ApproximateScoreQuery) query).getOriginalQuery()); - } else if (query instanceof BooleanQuery) { - final BooleanQuery bq = (BooleanQuery) query; - final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); - if (hasRequiredClauses) { - return bq.clauses() - .stream() - .filter(BooleanClause::isRequired) - .map(BooleanClause::query) - .allMatch(this::mightMatchNestedDocs); - } else { - return bq.clauses() - .stream() - .filter(c -> c.occur() == Occur.SHOULD) - .map(BooleanClause::query) - .anyMatch(this::mightMatchNestedDocs); + return switch (query) { + case ConstantScoreQuery csq -> mightMatchNestedDocs(csq.getQuery()); + case BoostQuery bq -> mightMatchNestedDocs(bq.getQuery()); + case MatchAllDocsQuery ignored -> true; + case MatchNoDocsQuery ignored -> false; + case TermQuery tq -> + // We only handle term(s) queries and range queries, which should already + // cover a high majority of use-cases + mightMatchNestedDocs(tq.getTerm().field()); + case TermInSetQuery tisq -> tisq.getTermsCount() > 0 && mightMatchNestedDocs(tisq.getField()); + case PointRangeQuery prq -> mightMatchNestedDocs(prq.getField()); + case IndexOrDocValuesQuery iodvq -> mightMatchNestedDocs(iodvq.getIndexQuery()); + case ApproximateScoreQuery asq -> mightMatchNestedDocs(asq.getOriginalQuery()); + case BooleanQuery bq -> { + boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); + if (hasRequiredClauses) { + yield bq.clauses().stream() + .filter(BooleanClause::isRequired) + .map(BooleanClause::query) + .allMatch(this::mightMatchNestedDocs); + } else { + yield bq.clauses().stream() + .filter(c -> c.occur() == Occur.SHOULD) + .map(BooleanClause::query) + .anyMatch(this::mightMatchNestedDocs); + } } - } else if (query instanceof OpenSearchToParentBlockJoinQuery) { - return ((OpenSearchToParentBlockJoinQuery) query).getPath() != null; - } else { - return true; - } + case OpenSearchToParentBlockJoinQuery ostpbjq -> ostpbjq.getPath() != null; + case null -> true; + default -> true; + }; } /** Returns true if a query on the given field might match nested documents. */ @@ -137,48 +122,33 @@ boolean mightMatchNestedDocs(String field) { /** Returns true if the given query might match parent documents or documents * that are nested under a different path. */ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) { - if (query instanceof ConstantScoreQuery) { - return mightMatchNonNestedDocs(((ConstantScoreQuery) query).getQuery(), nestedPath); - } else if (query instanceof BoostQuery) { - return mightMatchNonNestedDocs(((BoostQuery) query).getQuery(), nestedPath); - } else if (query instanceof MatchAllDocsQuery) { - return true; - } else if (query instanceof MatchNoDocsQuery) { - return false; - } else if (query instanceof TermQuery) { - return mightMatchNonNestedDocs(((TermQuery) query).getTerm().field(), nestedPath); - } else if (query instanceof TermInSetQuery) { - final TermInSetQuery termInSetQuery = (TermInSetQuery) query; - if (termInSetQuery.getTermsCount() > 0) { - return mightMatchNonNestedDocs(termInSetQuery.getField(), nestedPath); - } else { - return false; - } - } else if (query instanceof PointRangeQuery) { - return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath); - } else if (query instanceof IndexOrDocValuesQuery) { - return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath); - } else if (query instanceof ApproximateScoreQuery) { - return mightMatchNonNestedDocs(((ApproximateScoreQuery) query).getOriginalQuery(), nestedPath); - } else if (query instanceof BooleanQuery) { - final BooleanQuery bq = (BooleanQuery) query; - final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); - if (hasRequiredClauses) { - return bq.clauses() - .stream() - .filter(BooleanClause::isRequired) - .map(BooleanClause::query) - .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); - } else { - return bq.clauses() - .stream() - .filter(c -> c.occur() == Occur.SHOULD) - .map(BooleanClause::query) - .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); + return switch (query) { + case ConstantScoreQuery csq -> mightMatchNonNestedDocs(csq.getQuery(), nestedPath); + case BoostQuery bq -> mightMatchNonNestedDocs(bq.getQuery(), nestedPath); + case MatchAllDocsQuery ignored -> true; + case MatchNoDocsQuery ignored -> false; + case TermQuery tq -> mightMatchNonNestedDocs(tq.getTerm().field(), nestedPath); + case TermInSetQuery tisq -> tisq.getTermsCount() > 0 && mightMatchNonNestedDocs(tisq.getField(), nestedPath); + case PointRangeQuery prq -> mightMatchNonNestedDocs(prq.getField(), nestedPath); + case IndexOrDocValuesQuery iodvq -> mightMatchNonNestedDocs(iodvq.getIndexQuery(), nestedPath); + case ApproximateScoreQuery asq -> mightMatchNonNestedDocs(asq.getOriginalQuery(), nestedPath); + case BooleanQuery bq -> { + boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); + if (hasRequiredClauses) { + yield bq.clauses().stream() + .filter(BooleanClause::isRequired) + .map(BooleanClause::query) + .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); + } else { + yield bq.clauses().stream() + .filter(c -> c.occur() == Occur.SHOULD) + .map(BooleanClause::query) + .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); + } } - } else { - return true; - } + case null -> true; + default -> true; + }; } /** Returns true if a query on the given field might match parent documents From baab507130b8ae1b18438c15210d7e2638d1478d Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Fri, 11 Apr 2025 23:03:10 +0530 Subject: [PATCH 2/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../org/opensearch/index/search/NestedHelper.java | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/server/src/main/java/org/opensearch/index/search/NestedHelper.java b/server/src/main/java/org/opensearch/index/search/NestedHelper.java index 4c5f7e7589e14..04fa079c7f24f 100644 --- a/server/src/main/java/org/opensearch/index/search/NestedHelper.java +++ b/server/src/main/java/org/opensearch/index/search/NestedHelper.java @@ -79,12 +79,14 @@ public boolean mightMatchNestedDocs(Query query) { case BooleanQuery bq -> { boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); if (hasRequiredClauses) { - yield bq.clauses().stream() + yield bq.clauses() + .stream() .filter(BooleanClause::isRequired) .map(BooleanClause::query) .allMatch(this::mightMatchNestedDocs); } else { - yield bq.clauses().stream() + yield bq.clauses() + .stream() .filter(c -> c.occur() == Occur.SHOULD) .map(BooleanClause::query) .anyMatch(this::mightMatchNestedDocs); @@ -135,12 +137,14 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) { case BooleanQuery bq -> { boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); if (hasRequiredClauses) { - yield bq.clauses().stream() + yield bq.clauses() + .stream() .filter(BooleanClause::isRequired) .map(BooleanClause::query) .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); } else { - yield bq.clauses().stream() + yield bq.clauses() + .stream() .filter(c -> c.occur() == Occur.SHOULD) .map(BooleanClause::query) .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); From 5d26ea29982f14eee32736dffe45b041083648b4 Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Sat, 12 Apr 2025 16:24:19 +0530 Subject: [PATCH 3/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../java/org/opensearch/ExceptionsHelper.java | 23 ++++++++----------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java b/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java index 9692d20a050ff..9d7c1615c7ae9 100644 --- a/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java +++ b/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java @@ -93,20 +93,15 @@ public static OpenSearchException convertToOpenSearchException(Exception e) { } public static RestStatus status(Throwable t) { - if (t != null) { - if (t instanceof OpenSearchException) { - return ((OpenSearchException) t).status(); - } else if (t instanceof IllegalArgumentException) { - return RestStatus.BAD_REQUEST; - } else if (t instanceof JsonParseException) { - return RestStatus.BAD_REQUEST; - } else if (t instanceof OpenSearchRejectedExecutionException) { - return RestStatus.TOO_MANY_REQUESTS; - } else if (t instanceof NotXContentException) { - return RestStatus.BAD_REQUEST; - } - } - return RestStatus.INTERNAL_SERVER_ERROR; + return switch (t) { + case OpenSearchException ose -> ose.status(); + case IllegalArgumentException iae -> RestStatus.BAD_REQUEST; + case JsonParseException jpe -> RestStatus.BAD_REQUEST; + case OpenSearchRejectedExecutionException osre -> RestStatus.TOO_MANY_REQUESTS; + case NotXContentException nxce -> RestStatus.BAD_REQUEST; + case null -> RestStatus.INTERNAL_SERVER_ERROR; + default -> RestStatus.INTERNAL_SERVER_ERROR; + }; } public static String summaryMessage(Throwable t) { From 7e221cb2b91642df4f9c4a7aa614cfc26e3f4706 Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Sat, 12 Apr 2025 16:32:26 +0530 Subject: [PATCH 4/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../java/org/opensearch/ExceptionsHelper.java | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java b/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java index 9d7c1615c7ae9..c1bb9384090e8 100644 --- a/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java +++ b/libs/core/src/main/java/org/opensearch/ExceptionsHelper.java @@ -105,18 +105,14 @@ public static RestStatus status(Throwable t) { } public static String summaryMessage(Throwable t) { - if (t != null) { - if (t instanceof OpenSearchException) { - return getExceptionSimpleClassName(t) + "[" + t.getMessage() + "]"; - } else if (t instanceof IllegalArgumentException) { - return "Invalid argument"; - } else if (t instanceof JsonParseException) { - return "Failed to parse JSON"; - } else if (t instanceof OpenSearchRejectedExecutionException) { - return "Too many requests"; - } - } - return "Internal failure"; + return switch (t) { + case OpenSearchException ose -> getExceptionSimpleClassName(t) + "[" + t.getMessage() + "]"; + case IllegalArgumentException iae -> "Invalid argument"; + case JsonParseException jpe -> "Failed to parse JSON"; + case OpenSearchRejectedExecutionException osre -> "Too many requests"; + case null -> "Internal failure"; + default -> "Internal failure"; + }; } public static Throwable unwrapCause(Throwable t) { From 1b021b6622ac360984e3310fa58935eb878e89d5 Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Sat, 12 Apr 2025 18:31:46 +0530 Subject: [PATCH 5/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../common/logging/LoggerMessageFormat.java | 36 ++++++++----------- 1 file changed, 14 insertions(+), 22 deletions(-) diff --git a/libs/core/src/main/java/org/opensearch/core/common/logging/LoggerMessageFormat.java b/libs/core/src/main/java/org/opensearch/core/common/logging/LoggerMessageFormat.java index c7b9bee3cbf4d..edbf1f0f248a6 100644 --- a/libs/core/src/main/java/org/opensearch/core/common/logging/LoggerMessageFormat.java +++ b/libs/core/src/main/java/org/opensearch/core/common/logging/LoggerMessageFormat.java @@ -166,28 +166,20 @@ private static void deeplyAppendParameter(StringBuilder sbuf, Object o, Set booleanArrayAppend(sbuf, boolArr); + case byte[] byteArr -> byteArrayAppend(sbuf, byteArr); + case char[] charArr -> charArrayAppend(sbuf, charArr); + case short[] shortArr -> shortArrayAppend(sbuf, shortArr); + case int[] intArr -> intArrayAppend(sbuf, intArr); + case long[] longArr -> longArrayAppend(sbuf, longArr); + case float[] floatArr -> floatArrayAppend(sbuf, floatArr); + case double[] doubleArr -> doubleArrayAppend(sbuf, doubleArr); + default -> objectArrayAppend(sbuf, (Object[]) o, seen); } } From 5f4340f66aeb6c27d3fb8c25b3d3dea2b6fed36e Mon Sep 17 00:00:00 2001 From: Jay Sabva <202101224@daiict.ac.in> Date: Sat, 12 Apr 2025 18:47:10 +0530 Subject: [PATCH 6/6] ISSUE #17874 Make use of Java 17 pattern matching switch statements Signed-off-by: Jay Sabva <202101224@daiict.ac.in> --- .../core/xcontent/MapXContentParser.java | 23 ++++++++----------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/libs/core/src/main/java/org/opensearch/core/xcontent/MapXContentParser.java b/libs/core/src/main/java/org/opensearch/core/xcontent/MapXContentParser.java index 0a5cda324ddb7..ea958e49673c3 100644 --- a/libs/core/src/main/java/org/opensearch/core/xcontent/MapXContentParser.java +++ b/libs/core/src/main/java/org/opensearch/core/xcontent/MapXContentParser.java @@ -206,20 +206,15 @@ public Number numberValue() throws IOException { @Override public NumberType numberType() throws IOException { Number number = numberValue(); - if (number instanceof Integer) { - return NumberType.INT; - } else if (number instanceof BigInteger) { - return NumberType.BIG_INTEGER; - } else if (number instanceof Long) { - return NumberType.LONG; - } else if (number instanceof Float) { - return NumberType.FLOAT; - } else if (number instanceof Double) { - return NumberType.DOUBLE; - } else if (number instanceof BigDecimal) { - return NumberType.BIG_DECIMAL; - } - throw new IllegalStateException("No matching token for number_type [" + number.getClass() + "]"); + return switch (number) { + case Integer ignored -> NumberType.INT; + case BigInteger ignored -> NumberType.BIG_INTEGER; + case Long ignored -> NumberType.LONG; + case Float ignored -> NumberType.FLOAT; + case Double ignored -> NumberType.DOUBLE; + case BigDecimal ignored -> NumberType.BIG_DECIMAL; + default -> throw new IllegalStateException("No matching token for number_type [" + number.getClass() + "]"); + }; } @Override