From 614029b77ebc876fdb03d2219c5d5b61dcbb8afd Mon Sep 17 00:00:00 2001 From: Ritvi Bhatt Date: Fri, 8 May 2026 09:39:36 -0700 Subject: [PATCH] update type mismatch errors Signed-off-by: Ritvi Bhatt --- .../sql/analysis/ExpressionAnalyzer.java | 25 ++++++++--- .../opensearch/sql/calcite/SchemaUnifier.java | 17 ++++++-- .../expression/aggregation/SumAggregator.java | 14 ++++++- .../function/DefaultFunctionResolver.java | 33 ++++++++++----- .../opensearch/sql/analysis/AnalyzerTest.java | 10 +++-- .../sql/analysis/ExpressionAnalyzerTest.java | 6 ++- .../PercentileApproxAggregatorTest.java | 4 +- .../aggregation/SumAggregatorTest.java | 12 ++++-- .../datetime/DateAddAndAddDateTest.java | 7 ++-- .../datetime/DateSubAndSubDateTest.java | 7 ++-- .../function/DefaultFunctionResolverTest.java | 21 +++++----- .../arthmetic/ArithmeticFunctionTest.java | 41 ++++++------------- .../convert/TypeCastOperatorTest.java | 4 +- .../sql/ppl/calcite/CalcitePPLAppendTest.java | 4 +- 14 files changed, 123 insertions(+), 82 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/analysis/ExpressionAnalyzer.java b/core/src/main/java/org/opensearch/sql/analysis/ExpressionAnalyzer.java index 54300540766..e134254ad90 100644 --- a/core/src/main/java/org/opensearch/sql/analysis/ExpressionAnalyzer.java +++ b/core/src/main/java/org/opensearch/sql/analysis/ExpressionAnalyzer.java @@ -56,6 +56,8 @@ import org.opensearch.sql.ast.expression.subquery.InSubquery; import org.opensearch.sql.ast.expression.subquery.ScalarSubquery; import org.opensearch.sql.calcite.utils.CalciteUtils; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprValueUtils; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; @@ -269,10 +271,16 @@ public Expression visitHighlightFunction(HighlightFunction node, AnalysisContext public Expression visitScoreFunction(ScoreFunction node, AnalysisContext context) { Literal boostArg = node.getRelevanceFieldWeight(); if (!boostArg.getType().equals(DataType.DOUBLE)) { - throw new SemanticCheckException( - String.format( - "Expected boost type '%s' but got '%s'", - DataType.DOUBLE.name(), boostArg.getType().name())); + throw ErrorReport.wrap( + new SemanticCheckException( + String.format( + "Expected boost type '%s' but got '%s'", + DataType.DOUBLE.name(), boostArg.getType().name()))) + .code(ErrorCode.TYPE_ERROR) + .context("parameter", "boost") + .context("expected_type", DataType.DOUBLE.name()) + .context("actual_type", boostArg.getType().name()) + .build(); } Double thisBoostValue = ((Double) boostArg.getValue()); @@ -402,8 +410,13 @@ public Expression visitCase(Case node, AnalysisContext context) { // Make CaseClause return list so it can be used in error message in determined order List resultTypes = caseClause.allResultTypes(); if (ImmutableSet.copyOf(resultTypes).size() > 1) { - throw new SemanticCheckException( - "All result types of CASE clause must be the same, but found " + resultTypes); + throw ErrorReport.wrap( + new SemanticCheckException( + "All result types of CASE clause must be the same, but found " + resultTypes)) + .code(ErrorCode.TYPE_ERROR) + .context("construct", "CASE") + .context("result_types", resultTypes.stream().map(Object::toString).toList()) + .build(); } return caseClause; } diff --git a/core/src/main/java/org/opensearch/sql/calcite/SchemaUnifier.java b/core/src/main/java/org/opensearch/sql/calcite/SchemaUnifier.java index e01cbe3992d..3b63dbdda54 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/SchemaUnifier.java +++ b/core/src/main/java/org/opensearch/sql/calcite/SchemaUnifier.java @@ -15,6 +15,8 @@ import org.apache.calcite.rel.type.RelDataTypeField; import org.apache.calcite.rex.RexNode; import org.apache.calcite.sql.type.SqlTypeName; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; /** * Utility class for unifying schemas across multiple RelNodes. Supports two strategies: @@ -86,10 +88,17 @@ private static List buildUnifiedSchema(List nodes) { seenFields.put(fieldName, fieldType); } else if (!areTypesCompatible(existingType, fieldType)) { // Same field name but different type - throw exception - throw new IllegalArgumentException( - String.format( - "Unable to process column '%s' due to incompatible types: '%s' and '%s'", - fieldName, existingType.getSqlTypeName(), fieldType.getSqlTypeName())); + String existingTypeName = String.valueOf(existingType.getSqlTypeName()); + String newTypeName = String.valueOf(fieldType.getSqlTypeName()); + throw ErrorReport.wrap( + new IllegalArgumentException( + String.format( + "Unable to process column '%s' due to incompatible types: '%s' and '%s'", + fieldName, existingTypeName, newTypeName))) + .code(ErrorCode.TYPE_ERROR) + .context("column", fieldName) + .context("types", List.of(existingTypeName, newTypeName)) + .build(); } // If we've seen this exact (name, type) combination, skip it } diff --git a/core/src/main/java/org/opensearch/sql/expression/aggregation/SumAggregator.java b/core/src/main/java/org/opensearch/sql/expression/aggregation/SumAggregator.java index d6377219808..6e1cd5ac218 100644 --- a/core/src/main/java/org/opensearch/sql/expression/aggregation/SumAggregator.java +++ b/core/src/main/java/org/opensearch/sql/expression/aggregation/SumAggregator.java @@ -17,6 +17,8 @@ import java.util.List; import java.util.Locale; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprNullValue; import org.opensearch.sql.data.model.ExprValue; import org.opensearch.sql.data.model.ExprValueUtils; @@ -82,8 +84,16 @@ public void add(ExprValue value) { sumResult = doubleValue(getDoubleValue(sumResult) + getDoubleValue(value)); break; default: - throw new ExpressionEvaluationException( - String.format("unexpected type [%s] in sum aggregation", type)); + throw ErrorReport.wrap( + new ExpressionEvaluationException( + String.format( + "sum aggregation does not support type %s; expected a numeric type" + + " (INTEGER, LONG, FLOAT, or DOUBLE)", + type))) + .code(ErrorCode.TYPE_ERROR) + .context("aggregation", "sum") + .context("actual_type", type.toString()) + .build(); } } diff --git a/core/src/main/java/org/opensearch/sql/expression/function/DefaultFunctionResolver.java b/core/src/main/java/org/opensearch/sql/expression/function/DefaultFunctionResolver.java index e1d00527231..a3f2fe403ed 100644 --- a/core/src/main/java/org/opensearch/sql/expression/function/DefaultFunctionResolver.java +++ b/core/src/main/java/org/opensearch/sql/expression/function/DefaultFunctionResolver.java @@ -15,6 +15,8 @@ import lombok.RequiredArgsConstructor; import lombok.Singular; import org.apache.commons.lang3.tuple.Pair; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.exception.ExpressionEvaluationException; /** @@ -52,19 +54,30 @@ public Pair resolve(FunctionSignature unreso if (FunctionSignature.isVarArgFunction(bestMatchEntry.getValue().getParamTypeList()) && (unresolvedSignature.getParamTypeList().isEmpty() || unresolvedSignature.getParamTypeList().size() > 9)) { - throw new ExpressionEvaluationException( - String.format( - "%s function expected 1-9 arguments, but got %d", - functionName, unresolvedSignature.getParamTypeList().size())); + throw ErrorReport.wrap( + new ExpressionEvaluationException( + String.format( + "%s function expected 1-9 arguments, but got %d", + functionName, unresolvedSignature.getParamTypeList().size()))) + .code(ErrorCode.TYPE_ERROR) + .context("function", functionName.toString()) + .context("actual_arg_count", unresolvedSignature.getParamTypeList().size()) + .build(); } if (FunctionSignature.NOT_MATCH.equals(bestMatchEntry.getKey()) && !FunctionSignature.isVarArgFunction(bestMatchEntry.getValue().getParamTypeList())) { - throw new ExpressionEvaluationException( - String.format( - "%s function expected %s, but got %s", - functionName, - formatFunctions(functionBundle.keySet()), - unresolvedSignature.formatTypes())); + throw ErrorReport.wrap( + new ExpressionEvaluationException( + String.format( + "%s function expected %s, but got %s", + functionName, + formatFunctions(functionBundle.keySet()), + unresolvedSignature.formatTypes()))) + .code(ErrorCode.TYPE_ERROR) + .context("function", functionName.toString()) + .context("expected_signatures", formatFunctions(functionBundle.keySet())) + .context("actual_types", unresolvedSignature.formatTypes()) + .build(); } else { FunctionSignature resolvedSignature = bestMatchEntry.getValue(); return Pair.of(resolvedSignature, functionBundle.get(resolvedSignature)); diff --git a/core/src/test/java/org/opensearch/sql/analysis/AnalyzerTest.java b/core/src/test/java/org/opensearch/sql/analysis/AnalyzerTest.java index 6324e7ee5bd..9be017515bc 100644 --- a/core/src/test/java/org/opensearch/sql/analysis/AnalyzerTest.java +++ b/core/src/test/java/org/opensearch/sql/analysis/AnalyzerTest.java @@ -93,6 +93,8 @@ import org.opensearch.sql.ast.tree.RareTopN.CommandType; import org.opensearch.sql.ast.tree.UnresolvedPlan; import org.opensearch.sql.common.antlr.SyntaxCheckException; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.exception.SemanticCheckException; @@ -159,9 +161,9 @@ public void filter_relation_with_invalid_qualifiedName_ExpressionEvaluationExcep AstDSL.relation("schema"), AstDSL.equalTo(AstDSL.qualifiedName("_test"), AstDSL.intLiteral(1))); - ExpressionEvaluationException exception = - assertThrows(ExpressionEvaluationException.class, () -> analyze(typeMismatchPlan)); + ErrorReport exception = assertThrows(ErrorReport.class, () -> analyze(typeMismatchPlan)); assertEquals(getIncompatibleTypeErrMsg(STRING, INTEGER), exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test @@ -369,9 +371,9 @@ public void analyze_filter_visit_score_function_with_unsupported_boost_SemanticC AstDSL.unresolvedArg("query", stringLiteral("search query")), AstDSL.unresolvedArg("boost", stringLiteral("3"))), AstDSL.stringLiteral("3.0"))); - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> analyze(unresolvedPlan)); + ErrorReport exception = assertThrows(ErrorReport.class, () -> analyze(unresolvedPlan)); assertEquals("Expected boost type 'DOUBLE' but got 'STRING'", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test diff --git a/core/src/test/java/org/opensearch/sql/analysis/ExpressionAnalyzerTest.java b/core/src/test/java/org/opensearch/sql/analysis/ExpressionAnalyzerTest.java index 4b096a6ed9a..9292d871345 100644 --- a/core/src/test/java/org/opensearch/sql/analysis/ExpressionAnalyzerTest.java +++ b/core/src/test/java/org/opensearch/sql/analysis/ExpressionAnalyzerTest.java @@ -43,6 +43,8 @@ import org.opensearch.sql.ast.expression.UnresolvedExpression; import org.opensearch.sql.ast.tree.UnresolvedPlan; import org.opensearch.sql.common.antlr.SyntaxCheckException; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprTupleValue; import org.opensearch.sql.data.model.ExprValueUtils; import org.opensearch.sql.exception.SemanticCheckException; @@ -165,11 +167,11 @@ public void case_with_default_result_type_different() { AstDSL.when(AstDSL.intLiteral(30), AstDSL.stringLiteral("Thirty")), AstDSL.when(AstDSL.intLiteral(50), AstDSL.stringLiteral("Fifty"))); - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> analyze(caseWhen)); + ErrorReport exception = assertThrows(ErrorReport.class, () -> analyze(caseWhen)); assertEquals( "All result types of CASE clause must be the same, but found [STRING, STRING, INTEGER]", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/aggregation/PercentileApproxAggregatorTest.java b/core/src/test/java/org/opensearch/sql/expression/aggregation/PercentileApproxAggregatorTest.java index 2e204b9420d..7157d1131d1 100644 --- a/core/src/test/java/org/opensearch/sql/expression/aggregation/PercentileApproxAggregatorTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/aggregation/PercentileApproxAggregatorTest.java @@ -24,9 +24,9 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprValue; import org.opensearch.sql.data.model.ExprValueUtils; -import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.Expression; import org.opensearch.sql.expression.LiteralExpression; @@ -185,7 +185,7 @@ public void test_percentile_with_invalid_size() { assertEquals("out of bounds percent value, must be in [0, 100]", exception.getMessage()); var exception2 = assertThrows( - ExpressionEvaluationException.class, + ErrorReport.class, () -> aggregation( DSL.percentile(DSL.ref("double_value", DOUBLE), DSL.literal("string")), diff --git a/core/src/test/java/org/opensearch/sql/expression/aggregation/SumAggregatorTest.java b/core/src/test/java/org/opensearch/sql/expression/aggregation/SumAggregatorTest.java index eb5a18f248d..9242580b0a3 100644 --- a/core/src/test/java/org/opensearch/sql/expression/aggregation/SumAggregatorTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/aggregation/SumAggregatorTest.java @@ -17,6 +17,8 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import org.junit.jupiter.api.Test; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprValue; import org.opensearch.sql.data.model.ExprValueUtils; import org.opensearch.sql.data.type.ExprCoreType; @@ -67,14 +69,18 @@ public void sum_string_field_expression() { SumAggregator sumAggregator = new SumAggregator(ImmutableList.of(DSL.ref("string_value", STRING)), ExprCoreType.STRING); SumState sumState = sumAggregator.create(); - ExpressionEvaluationException exception = + ErrorReport exception = assertThrows( - ExpressionEvaluationException.class, + ErrorReport.class, () -> sumAggregator.iterate( ExprValueUtils.tupleValue(ImmutableMap.of("string_value", "m")).bindingTuples(), sumState)); - assertEquals("unexpected type [STRING] in sum aggregation", exception.getMessage()); + assertEquals( + "sum aggregation does not support type STRING; expected a numeric type (INTEGER, LONG," + + " FLOAT, or DOUBLE)", + exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/DateAddAndAddDateTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/DateAddAndAddDateTest.java index b4ab3a85672..4605c1ee513 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/DateAddAndAddDateTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/DateAddAndAddDateTest.java @@ -18,7 +18,8 @@ import java.time.Period; import java.time.ZoneOffset; import org.junit.jupiter.api.Test; -import org.opensearch.sql.exception.ExpressionEvaluationException; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; public class DateAddAndAddDateTest extends DateTimeTestBase { @@ -152,12 +153,12 @@ public void adddate_has_second_signature_but_not_date_add() { var exception = assertThrows( - ExpressionEvaluationException.class, - () -> date_add(LocalDateTime.of(1961, 4, 12, 9, 7), 100500)); + ErrorReport.class, () -> date_add(LocalDateTime.of(1961, 4, 12, 9, 7), 100500)); assertEquals( "date_add function expected {[DATE,INTERVAL],[TIMESTAMP,INTERVAL]," + "[TIME,INTERVAL]}, but got [TIMESTAMP,INTEGER]", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/DateSubAndSubDateTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/DateSubAndSubDateTest.java index 897f49cfee0..cc487e6979e 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/DateSubAndSubDateTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/DateSubAndSubDateTest.java @@ -18,8 +18,9 @@ import java.time.Period; import java.time.ZoneOffset; import org.junit.jupiter.api.Test; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprValue; -import org.opensearch.sql.exception.ExpressionEvaluationException; public class DateSubAndSubDateTest extends DateTimeTestBase { @@ -136,12 +137,12 @@ public void subdate_has_second_signature_but_not_date_sub() { var exception = assertThrows( - ExpressionEvaluationException.class, - () -> date_sub(LocalDateTime.of(1961, 4, 12, 9, 7), 100500)); + ErrorReport.class, () -> date_sub(LocalDateTime.of(1961, 4, 12, 9, 7), 100500)); assertEquals( "date_sub function expected {[DATE,INTERVAL],[TIMESTAMP,INTERVAL],[TIME,INTERVAL]}, but got" + " [TIMESTAMP,INTEGER]", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/function/DefaultFunctionResolverTest.java b/core/src/test/java/org/opensearch/sql/expression/function/DefaultFunctionResolverTest.java index 0c0439a7645..757a73d9035 100644 --- a/core/src/test/java/org/opensearch/sql/expression/function/DefaultFunctionResolverTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/function/DefaultFunctionResolverTest.java @@ -20,8 +20,9 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; +import org.opensearch.sql.common.error.ErrorCode; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.type.WideningTypeRule; -import org.opensearch.sql.exception.ExpressionEvaluationException; @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class) @ExtendWith(MockitoExtension.class) @@ -68,12 +69,12 @@ void resolve_function_not_match() { DefaultFunctionResolver resolver = new DefaultFunctionResolver(functionName, ImmutableMap.of(notMatchFS, notMatchBuilder)); - ExpressionEvaluationException exception = - assertThrows( - ExpressionEvaluationException.class, () -> resolver.resolve(functionSignature)); + ErrorReport exception = + assertThrows(ErrorReport.class, () -> resolver.resolve(functionSignature)); assertEquals( "add function expected {[INTEGER,INTEGER]}, but got [BOOLEAN,BOOLEAN]", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test @@ -100,10 +101,10 @@ void resolve_varargs_no_args_function_signature_not_match() { DefaultFunctionResolver resolver = new DefaultFunctionResolver(functionName, ImmutableMap.of(bestMatchFS, bestMatchBuilder)); - ExpressionEvaluationException exception = - assertThrows( - ExpressionEvaluationException.class, () -> resolver.resolve(functionSignature)); + ErrorReport exception = + assertThrows(ErrorReport.class, () -> resolver.resolve(functionSignature)); assertEquals("concat function expected 1-9 arguments, but got 0", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } @Test @@ -120,9 +121,9 @@ void resolve_varargs_too_many_args_function_signature_not_match() { DefaultFunctionResolver resolver = new DefaultFunctionResolver(functionName, ImmutableMap.of(bestMatchFS, bestMatchBuilder)); - ExpressionEvaluationException exception = - assertThrows( - ExpressionEvaluationException.class, () -> resolver.resolve(functionSignature)); + ErrorReport exception = + assertThrows(ErrorReport.class, () -> resolver.resolve(functionSignature)); assertEquals("concat function expected 1-9 arguments, but got 10", exception.getMessage()); + assertEquals(ErrorCode.TYPE_ERROR, exception.getCode()); } } diff --git a/core/src/test/java/org/opensearch/sql/expression/operator/arthmetic/ArithmeticFunctionTest.java b/core/src/test/java/org/opensearch/sql/expression/operator/arthmetic/ArithmeticFunctionTest.java index 24c0d0decfe..6a4bf13df1d 100644 --- a/core/src/test/java/org/opensearch/sql/expression/operator/arthmetic/ArithmeticFunctionTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/operator/arthmetic/ArithmeticFunctionTest.java @@ -19,6 +19,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprByteValue; import org.opensearch.sql.data.model.ExprDoubleValue; import org.opensearch.sql.data.model.ExprFloatValue; @@ -30,7 +31,6 @@ import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.data.type.WideningTypeRule; -import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.ExpressionTestBase; import org.opensearch.sql.expression.FunctionExpression; @@ -213,43 +213,26 @@ public void divideFunction(ExprValue op1, ExprValue op2) { @ParameterizedTest(name = "multipleParameters({1},{2})") @MethodSource("arithmeticFunctionArguments") public void multipleParameters(ExprValue op1) { + assertThrows(ErrorReport.class, () -> DSL.add(literal(op1), literal(op1), literal(op1))); assertThrows( - ExpressionEvaluationException.class, - () -> DSL.add(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.addFunction(literal(op1), literal(op1), literal(op1))); + ErrorReport.class, () -> DSL.addFunction(literal(op1), literal(op1), literal(op1))); + assertThrows(ErrorReport.class, () -> DSL.subtract(literal(op1), literal(op1), literal(op1))); assertThrows( - ExpressionEvaluationException.class, - () -> DSL.subtract(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.subtractFunction(literal(op1), literal(op1), literal(op1))); + ErrorReport.class, () -> DSL.subtractFunction(literal(op1), literal(op1), literal(op1))); + assertThrows(ErrorReport.class, () -> DSL.multiply(literal(op1), literal(op1), literal(op1))); assertThrows( - ExpressionEvaluationException.class, - () -> DSL.multiply(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.multiplyFunction(literal(op1), literal(op1), literal(op1))); + ErrorReport.class, () -> DSL.multiplyFunction(literal(op1), literal(op1), literal(op1))); + assertThrows(ErrorReport.class, () -> DSL.divide(literal(op1), literal(op1), literal(op1))); assertThrows( - ExpressionEvaluationException.class, - () -> DSL.divide(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.divideFunction(literal(op1), literal(op1), literal(op1))); + ErrorReport.class, () -> DSL.divideFunction(literal(op1), literal(op1), literal(op1))); + assertThrows(ErrorReport.class, () -> DSL.mod(literal(op1), literal(op1), literal(op1))); + assertThrows(ErrorReport.class, () -> DSL.modulus(literal(op1), literal(op1), literal(op1))); assertThrows( - ExpressionEvaluationException.class, - () -> DSL.mod(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.modulus(literal(op1), literal(op1), literal(op1))); - assertThrows( - ExpressionEvaluationException.class, - () -> DSL.modulusFunction(literal(op1), literal(op1), literal(op1))); + ErrorReport.class, () -> DSL.modulusFunction(literal(op1), literal(op1), literal(op1))); } protected void assertValueEqual( diff --git a/core/src/test/java/org/opensearch/sql/expression/operator/convert/TypeCastOperatorTest.java b/core/src/test/java/org/opensearch/sql/expression/operator/convert/TypeCastOperatorTest.java index ff0c8bcc019..c09d4fb9da2 100644 --- a/core/src/test/java/org/opensearch/sql/expression/operator/convert/TypeCastOperatorTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/operator/convert/TypeCastOperatorTest.java @@ -30,6 +30,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.opensearch.sql.common.error.ErrorReport; import org.opensearch.sql.data.model.ExprBooleanValue; import org.opensearch.sql.data.model.ExprByteValue; import org.opensearch.sql.data.model.ExprCollectionValue; @@ -47,7 +48,6 @@ import org.opensearch.sql.data.model.ExprTimestampValue; import org.opensearch.sql.data.model.ExprTupleValue; import org.opensearch.sql.data.model.ExprValue; -import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.exception.SemanticCheckException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.FunctionExpression; @@ -436,7 +436,7 @@ void castToIp() { // From invalid type assertThrows( - ExpressionEvaluationException.class, + ErrorReport.class, () -> DSL.castIp(DSL.literal(0)), "cast_to_ip function expected {[IP],[STRING]}, but got [INTEGER]"); diff --git a/ppl/src/test/java/org/opensearch/sql/ppl/calcite/CalcitePPLAppendTest.java b/ppl/src/test/java/org/opensearch/sql/ppl/calcite/CalcitePPLAppendTest.java index a163af186d5..d3a673dafba 100644 --- a/ppl/src/test/java/org/opensearch/sql/ppl/calcite/CalcitePPLAppendTest.java +++ b/ppl/src/test/java/org/opensearch/sql/ppl/calcite/CalcitePPLAppendTest.java @@ -11,6 +11,7 @@ import org.apache.calcite.test.CalciteAssert; import org.junit.Assert; import org.junit.Test; +import org.opensearch.sql.common.error.ErrorReport; public class CalcitePPLAppendTest extends CalcitePPLAbstractTest { @@ -231,8 +232,7 @@ public void testAppendWithMergedColumns() { public void testAppendWithConflictTypeColumn() { String ppl = "source=EMP | fields DEPTNO | append [ source=EMP | fields DEPTNO | eval DEPTNO = 20 ]"; - Exception exception = - Assert.assertThrows(IllegalArgumentException.class, () -> getRelNode(ppl)); + Exception exception = Assert.assertThrows(ErrorReport.class, () -> getRelNode(ppl)); verifyErrorMessageContains( exception, "Unable to process column 'DEPTNO' due to incompatible types:"); }