From 7a120db6f88d1c4cd028979472d864bb9dcc52ad Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Mon, 30 Jun 2025 17:58:56 +0800 Subject: [PATCH 1/7] Support following datetime casts in v2: date str -> timestamp timestamp str -> date timestamp str -> time Signed-off-by: Yuanchun Shen --- .../java/org/opensearch/sql/data/model/ExprDateValue.java | 8 +++----- .../java/org/opensearch/sql/data/model/ExprTimeValue.java | 7 +++---- .../org/opensearch/sql/data/model/ExprTimestampValue.java | 8 +++----- 3 files changed, 9 insertions(+), 14 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java index c36cd3ea6d0..1e698918f3e 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java @@ -5,8 +5,6 @@ package org.opensearch.sql.data.model; -import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_VARIABLE_NANOS_OPTIONAL; - import com.google.common.base.Objects; import java.time.Instant; import java.time.LocalDate; @@ -14,8 +12,8 @@ import java.time.ZoneOffset; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; -import java.time.format.DateTimeParseException; import lombok.RequiredArgsConstructor; +import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; @@ -29,8 +27,8 @@ public class ExprDateValue extends AbstractExprValue { /** Constructor of ExprDateValue. */ public ExprDateValue(String date) { try { - this.date = LocalDate.parse(date, DATE_TIME_FORMATTER_VARIABLE_NANOS_OPTIONAL); - } catch (DateTimeParseException e) { + this.date = DateTimeParser.parseDateOrTimestamp(date).toLocalDate(); + } catch (SemanticCheckException e) { throw new SemanticCheckException( String.format("date:%s in unsupported format, please use 'yyyy-MM-dd'", date)); } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java index 6b5a4a7c481..07a3aabdbdd 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java @@ -6,16 +6,15 @@ package org.opensearch.sql.data.model; import static java.time.format.DateTimeFormatter.ISO_LOCAL_TIME; -import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_VARIABLE_NANOS_OPTIONAL; import java.time.Instant; import java.time.LocalDate; import java.time.LocalTime; import java.time.ZoneOffset; import java.time.ZonedDateTime; -import java.time.format.DateTimeParseException; import java.util.Objects; import lombok.RequiredArgsConstructor; +import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; @@ -30,8 +29,8 @@ public class ExprTimeValue extends AbstractExprValue { /** Constructor of ExprTimeValue. */ public ExprTimeValue(String time) { try { - this.time = LocalTime.parse(time, DATE_TIME_FORMATTER_VARIABLE_NANOS_OPTIONAL); - } catch (DateTimeParseException e) { + this.time = DateTimeParser.parseTimeOrTimestamp(time).toLocalTime(); + } catch (SemanticCheckException e) { throw new SemanticCheckException( String.format("time:%s in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", time)); } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java index e103dc72539..455723f6891 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java @@ -13,10 +13,10 @@ import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneOffset; -import java.time.format.DateTimeParseException; import java.time.temporal.ChronoUnit; import java.util.Objects; import lombok.RequiredArgsConstructor; +import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; @@ -31,10 +31,8 @@ public class ExprTimestampValue extends AbstractExprValue { public ExprTimestampValue(String timestamp) { try { this.timestamp = - LocalDateTime.parse(timestamp, DATE_TIME_FORMATTER_VARIABLE_NANOS) - .atZone(ZoneOffset.UTC) - .toInstant(); - } catch (DateTimeParseException e) { + DateTimeParser.parseDateOrTimestamp(timestamp).atZone(ZoneOffset.UTC).toInstant(); + } catch (SemanticCheckException e) { throw new SemanticCheckException( String.format( "timestamp:%s in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", From 0e9865085bc64be56796daca9c039922d880c90e Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Mon, 30 Jun 2025 17:59:41 +0800 Subject: [PATCH 2/7] Invoke datetime UDF to cast date/time/timestamp with Calcite Signed-off-by: Yuanchun Shen --- .../sql/calcite/ExtendedRexBuilder.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java b/core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java index 9ac9b0704c5..c7303d9adea 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java +++ b/core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java @@ -5,9 +5,14 @@ package org.opensearch.sql.calcite; +import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.ExprUDT.EXPR_DATE; +import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.ExprUDT.EXPR_TIME; +import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP; + import com.google.common.collect.ImmutableList; import java.util.Arrays; import java.util.List; +import java.util.Set; import org.apache.calcite.avatica.util.TimeUnit; import org.apache.calcite.rel.type.RelDataType; import org.apache.calcite.rex.RexBuilder; @@ -19,6 +24,8 @@ import org.apache.calcite.sql.type.SqlTypeName; import org.apache.calcite.sql.type.SqlTypeUtil; import org.opensearch.sql.ast.expression.SpanUnit; +import org.opensearch.sql.calcite.type.ExprSqlType; +import org.opensearch.sql.expression.function.PPLBuiltinOperators; public class ExtendedRexBuilder extends RexBuilder { @@ -117,6 +124,16 @@ public RexNode makeCast( // SqlStdOperatorTable.NOT_EQUALS, // ImmutableList.of(exp, makeZeroLiteral(exp.getType()))); } + } else if (type instanceof ExprSqlType exprSqlType + && Set.of(EXPR_DATE, EXPR_TIME, EXPR_TIMESTAMP).contains(exprSqlType.getUdt())) { + switch (exprSqlType.getUdt()) { + case EXPR_DATE: + return makeCall(type, PPLBuiltinOperators.DATE, List.of(exp)); + case EXPR_TIME: + return makeCall(type, PPLBuiltinOperators.TIME, List.of(exp)); + case EXPR_TIMESTAMP: + return makeCall(type, PPLBuiltinOperators.TIMESTAMP, List.of(exp)); + } } return super.makeCast(pos, type, exp, matchNullability, safe, format); } From bc2c9e2f2357ec874fc0fadfed911cf28bcbeca2 Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Mon, 30 Jun 2025 18:00:11 +0800 Subject: [PATCH 3/7] Test cast to date/time/timestamp Signed-off-by: Yuanchun Shen --- .../remote/CalcitePPLCastFunctionIT.java | 225 ++++++++++-------- 1 file changed, 130 insertions(+), 95 deletions(-) diff --git a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java index 209199747b0..4385548c719 100644 --- a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java @@ -7,18 +7,20 @@ import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_DATATYPE_NONNUMERIC; import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_DATATYPE_NUMERIC; +import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_DATE_FORMATS; import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_STATE_COUNTRY; import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_STATE_COUNTRY_WITH_NULL; -import static org.opensearch.sql.util.MatcherUtils.assertJsonEquals; import static org.opensearch.sql.util.MatcherUtils.rows; import static org.opensearch.sql.util.MatcherUtils.schema; import static org.opensearch.sql.util.MatcherUtils.verifyDataRows; +import static org.opensearch.sql.util.MatcherUtils.verifyErrorMessageContains; import static org.opensearch.sql.util.MatcherUtils.verifySchema; import java.io.IOException; import org.json.JSONObject; import org.junit.Test; import org.opensearch.sql.common.antlr.SyntaxCheckException; +import org.opensearch.sql.exception.SemanticCheckException; import org.opensearch.sql.ppl.PPLIntegTestCase; public class CalcitePPLCastFunctionIT extends PPLIntegTestCase { @@ -32,6 +34,7 @@ public void init() throws Exception { loadIndex(Index.STATE_COUNTRY_WITH_NULL); loadIndex(Index.DATA_TYPE_NUMERIC); loadIndex(Index.DATA_TYPE_NONNUMERIC); + loadIndex(Index.DATE_FORMATS); } @Test @@ -92,38 +95,15 @@ public void testCastNullValues() throws IOException { "source=%s | eval a = cast(state as string) | fields a", TEST_INDEX_STATE_COUNTRY_WITH_NULL)); - assertJsonEquals( - "{\n" - + " \"schema\": [\n" - + " {\n" - + " \"name\": \"a\",\n" - + " \"type\": \"string\"\n" - + " }\n" - + " ],\n" - + " \"datarows\": [\n" - + " [\n" - + " \"California\"\n" - + " ],\n" - + " [\n" - + " \"New York\"\n" - + " ],\n" - + " [\n" - + " \"Ontario\"\n" - + " ],\n" - + " [\n" - + " \"Quebec\"\n" - + " ],\n" - + " [\n" - + " null\n" - + " ],\n" - + " [\n" - + " null\n" - + " ]\n" - + " ],\n" - + " \"total\": 6,\n" - + " \"size\": 6\n" - + "}", - actual.toString()); + verifySchema(actual, schema("a", "string")); + verifyDataRows( + actual, + rows("California"), + rows("New York"), + rows("Ontario"), + rows("Quebec"), + rows((Object) null), + rows((Object) null)); } @Test @@ -133,32 +113,9 @@ public void testCastToUnsupportedType() throws IOException { String.format( "source=%s | eval a = cast(name as boolean) | fields a", TEST_INDEX_STATE_COUNTRY)); - assertJsonEquals( - "{\n" - + " \"schema\": [\n" - + " {\n" - + " \"name\": \"a\",\n" - + " \"type\": \"boolean\"\n" - + " }\n" - + " ],\n" - + " \"datarows\": [\n" - + " [\n" - + " null\n" - + " ],\n" - + " [\n" - + " null\n" - + " ],\n" - + " [\n" - + " null\n" - + " ],\n" - + " [\n" - + " null\n" - + " ]\n" - + " ],\n" - + " \"total\": 4,\n" - + " \"size\": 4\n" - + "}", - actual.toString()); + verifySchema(actual, schema("a", "boolean")); + verifyDataRows( + actual, rows((Object) null), rows((Object) null), rows((Object) null), rows((Object) null)); } @Test @@ -220,24 +177,8 @@ public void testCastLiteralToBoolean() throws IOException { String.format( "source=%s | eval a = cast('2' as boolean) | fields a | head 1", TEST_INDEX_DATATYPE_NUMERIC)); - assertJsonEquals( - "" - + "{\n" - + " \"schema\": [\n" - + " {\n" - + " \"name\": \"a\",\n" - + " \"type\": \"boolean\"\n" - + " }\n" - + " ],\n" - + " \"datarows\": [\n" - + " [\n" - + " null\n" - + " ]\n" - + " ],\n" - + " \"total\": 1,\n" - + " \"size\": 1\n" - + "}", - actual.toString()); + verifySchema(actual, schema("a", "boolean")); + verifyDataRows(actual, rows((Object) null)); actual = executeQuery( @@ -251,24 +192,8 @@ public void testCastLiteralToBoolean() throws IOException { String.format( "source=%s | eval a = cast('aa' as boolean) | fields a | head 1", TEST_INDEX_DATATYPE_NUMERIC)); - assertJsonEquals( - "" - + "{\n" - + " \"schema\": [\n" - + " {\n" - + " \"name\": \"a\",\n" - + " \"type\": \"boolean\"\n" - + " }\n" - + " ],\n" - + " \"datarows\": [\n" - + " [\n" - + " null\n" - + " ]\n" - + " ],\n" - + " \"total\": 1,\n" - + " \"size\": 1\n" - + "}", - actual.toString()); + verifySchema(actual, schema("a", "boolean")); + verifyDataRows(actual, rows((Object) null)); } @Test @@ -485,4 +410,114 @@ public void testCastNumericSTRING() throws IOException { TEST_INDEX_DATATYPE_NONNUMERIC)); verifyDataRows(actual, rows(true)); } + + @Test + public void testCastDate() throws IOException { + JSONObject actual = + executeQuery( + String.format( + "source=%s | eval a = cast('1984-04-12' as DATE) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "date")); + verifyDataRows(actual, rows("1984-04-12"), rows("1984-04-12")); + + actual = + executeQuery( + String.format( + "source=%s | head 1 | eval a = cast('2023-10-01 12:00:00' as date) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "date")); + verifyDataRows(actual, rows("2023-10-01")); + + Throwable t = + assertThrowsWithReplace( + SemanticCheckException.class, + () -> + executeQuery( + String.format( + "source=%s | eval a = cast('09:07:42' as DATE) | fields a", + TEST_INDEX_DATE_FORMATS))); + + verifyErrorMessageContains(t, "date:09:07:42 in unsupported format, please use 'yyyy-MM-dd'"); + } + + @Test + public void testCastTime() throws IOException { + JSONObject actual = + executeQuery( + String.format( + "source=%s | eval a = cast('09:07:42' as TIME) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "time")); + verifyDataRows(actual, rows("09:07:42"), rows("09:07:42")); + + actual = + executeQuery( + String.format( + "source=%s | head 1 | eval a = cast('09:07:42.12345' as TIME) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "time")); + verifyDataRows(actual, rows("09:07:42.12345")); + + actual = + executeQuery( + String.format( + "source=%s | head 1 | eval a = cast('1985-10-09 12:00:00' as time) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "time")); + verifyDataRows(actual, rows("12:00:00")); + + Throwable t = + assertThrowsWithReplace( + SemanticCheckException.class, + () -> + executeQuery( + String.format( + "source=%s | eval a = cast('1984-04-12' as TIME) | fields a", + TEST_INDEX_DATE_FORMATS))); + + verifyErrorMessageContains( + t, "time:1984-04-12 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'"); + } + + @Test + public void testCastTimestamp() throws IOException { + JSONObject actual = + executeQuery( + String.format( + "source=%s | eval a = cast('1984-04-12 09:07:42' as TIMESTAMP) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "timestamp")); + verifyDataRows(actual, rows("1984-04-12 09:07:42"), rows("1984-04-12 09:07:42")); + + actual = + executeQuery( + String.format( + "source=%s | head 1 | eval a = cast('2023-10-01 12:00:00.123456' as timestamp) |" + + " fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "timestamp")); + verifyDataRows(actual, rows("2023-10-01 12:00:00.123456")); + + actual = + executeQuery( + String.format( + "source=%s | eval a = cast('1984-04-12' as TIMESTAMP) | fields a", + TEST_INDEX_DATE_FORMATS)); + verifySchema(actual, schema("a", "timestamp")); + verifyDataRows(actual, rows("1984-04-12 00:00:00"), rows("1984-04-12 00:00:00")); + + Throwable t = + assertThrowsWithReplace( + SemanticCheckException.class, + () -> + executeQuery( + String.format( + "source=%s | eval a = cast('09:07:42' as TIMESTAMP) | fields a", + TEST_INDEX_DATE_FORMATS))); + + verifyErrorMessageContains( + t, + "timestamp:09:07:42 in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'"); + } } From 3c42fe1aac55c2571ea8e9406581cf46c8475f7e Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Tue, 1 Jul 2025 10:40:02 +0800 Subject: [PATCH 4/7] Use stricter date and time formatters Signed-off-by: Yuanchun Shen --- .../sql/calcite/utils/datetime/DateTimeParser.java | 11 +++++++---- .../opensearch/sql/utils/DateTimeFormatters.java | 14 ++++++++++++++ .../org/opensearch/sql/sql/DateTimeFunctionIT.java | 5 +++-- 3 files changed, 24 insertions(+), 6 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java index 08f93f83a08..3ea4dd14bd2 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java +++ b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java @@ -5,6 +5,10 @@ package org.opensearch.sql.calcite.utils.datetime; +import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_VARIABLE_NANOS; +import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_DATE_FORMATTER; +import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_TIME_FORMATTER; + import com.google.common.collect.ImmutableList; import java.time.LocalDate; import java.time.LocalDateTime; @@ -13,7 +17,6 @@ import java.time.format.DateTimeFormatter; import java.util.List; import org.opensearch.sql.exception.SemanticCheckException; -import org.opensearch.sql.utils.DateTimeFormatters; public interface DateTimeParser { /** @@ -91,7 +94,7 @@ static LocalDateTime parseDateOrTimestamp(String input) { static LocalDateTime parseTimestamp(String input) { List dateTimeFormatters = - ImmutableList.of(DateTimeFormatters.DATE_TIME_FORMATTER_VARIABLE_NANOS_OPTIONAL); + ImmutableList.of(DATE_TIME_FORMATTER_VARIABLE_NANOS); for (DateTimeFormatter fmt : dateTimeFormatters) { try { @@ -106,7 +109,7 @@ static LocalDateTime parseTimestamp(String input) { } static LocalTime parseTime(String input) { - List timeFormatters = ImmutableList.of(DateTimeFormatter.ISO_TIME); + List timeFormatters = ImmutableList.of(STRICT_TIME_FORMATTER); for (DateTimeFormatter fmt : timeFormatters) { try { return LocalTime.parse(input, fmt); @@ -118,7 +121,7 @@ static LocalTime parseTime(String input) { } static LocalDate parseDate(String input) { - List dateFormatters = ImmutableList.of(DateTimeFormatter.ISO_DATE); + List dateFormatters = ImmutableList.of(STRICT_DATE_FORMATTER); for (DateTimeFormatter fmt : dateFormatters) { try { return LocalDate.parse(input, fmt); diff --git a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java index a5702b4f77a..bbb9558ed72 100644 --- a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java +++ b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java @@ -129,6 +129,20 @@ public class DateTimeFormatters { .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); + public static final DateTimeFormatter STRICT_DATE_FORMATTER = + new DateTimeFormatterBuilder() + .appendPattern("[uuuu-MM-dd]") + .toFormatter(Locale.ROOT) + .withResolverStyle(ResolverStyle.STRICT); + + public static final DateTimeFormatter STRICT_TIME_FORMATTER = + new DateTimeFormatterBuilder() + .appendPattern("[HH:mm:ss][HH:mm]") + .appendFraction( + ChronoField.NANO_OF_SECOND, MIN_FRACTION_SECONDS, MAX_FRACTION_SECONDS, true) + .toFormatter(Locale.ROOT) + .withResolverStyle(ResolverStyle.STRICT); + // MDD public static final DateTimeFormatter DATE_FORMATTER_SINGLE_DIGIT_MONTH = new DateTimeFormatterBuilder() diff --git a/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java b/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java index 56ff2fafc13..376dc5a8762 100644 --- a/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java @@ -1471,8 +1471,9 @@ public void testBracketFails() { assertThrows(ResponseException.class, () -> executeQuery("select {t '2020-09-16'}")); assertThrows(ResponseException.class, () -> executeQuery("select {date '17:30:00'}")); assertThrows(ResponseException.class, () -> executeQuery("select {d '17:30:00'}")); - assertThrows(ResponseException.class, () -> executeQuery("select {timestamp '2020-09-16'}")); - assertThrows(ResponseException.class, () -> executeQuery("select {ts '2020-09-16'}")); + // The following test case is removed because they will be parsed to proper timestamps + // assertThrows(ResponseException.class, () -> executeQuery("select {timestamp '2020-09-16'}")); + // assertThrows(ResponseException.class, () -> executeQuery("select {ts '2020-09-16'}")); assertThrows(ResponseException.class, () -> executeQuery("select {timestamp '17:30:00'}")); assertThrows(ResponseException.class, () -> executeQuery("select {ts '17:30:00'}")); } From 8d1d53090746011d2509984fdb274396220e126e Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Tue, 1 Jul 2025 16:18:46 +0800 Subject: [PATCH 5/7] Add a timestamp formatter for instantiating ExprTimestampValue Signed-off-by: Yuanchun Shen --- .../sql/calcite/utils/datetime/DateTimeParser.java | 5 ++--- .../java/org/opensearch/sql/utils/DateTimeFormatters.java | 8 ++++++++ 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java index 3ea4dd14bd2..1bdfe729451 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java +++ b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java @@ -5,8 +5,8 @@ package org.opensearch.sql.calcite.utils.datetime; -import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_VARIABLE_NANOS; import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_DATE_FORMATTER; +import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_TIMESTAMP_FORMATTER; import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_TIME_FORMATTER; import com.google.common.collect.ImmutableList; @@ -93,8 +93,7 @@ static LocalDateTime parseDateOrTimestamp(String input) { } static LocalDateTime parseTimestamp(String input) { - List dateTimeFormatters = - ImmutableList.of(DATE_TIME_FORMATTER_VARIABLE_NANOS); + List dateTimeFormatters = ImmutableList.of(STRICT_TIMESTAMP_FORMATTER); for (DateTimeFormatter fmt : dateTimeFormatters) { try { diff --git a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java index bbb9558ed72..cbc715ef461 100644 --- a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java +++ b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java @@ -129,6 +129,14 @@ public class DateTimeFormatters { .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); + public static final DateTimeFormatter STRICT_TIMESTAMP_FORMATTER = + new DateTimeFormatterBuilder() + .appendPattern("[uuuu-MM-dd HH:mm:ss][uuuu-MM-dd HH:mm]") + .appendFraction( + ChronoField.NANO_OF_SECOND, MIN_FRACTION_SECONDS, MAX_FRACTION_SECONDS, true) + .toFormatter(Locale.ROOT) + .withResolverStyle(ResolverStyle.STRICT); + public static final DateTimeFormatter STRICT_DATE_FORMATTER = new DateTimeFormatterBuilder() .appendPattern("[uuuu-MM-dd]") From f8f01f41738405f366a9e1fdd79e9740905d2b9d Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Thu, 10 Jul 2025 11:24:34 +0800 Subject: [PATCH 6/7] Simplify date/time expr constructors & parsers Signed-off-by: Yuanchun Shen --- .../utils/datetime/DateTimeParser.java | 119 +++--------------- .../sql/data/model/ExprDateValue.java | 13 +- .../sql/data/model/ExprTimeValue.java | 13 +- .../sql/data/model/ExprTimestampValue.java | 14 ++- .../sql/utils/DateTimeFormatters.java | 18 ++- .../sql/sql/DateTimeFunctionIT.java | 10 +- 6 files changed, 57 insertions(+), 130 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java index 1bdfe729451..fdb221b81af 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java +++ b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeParser.java @@ -5,129 +5,38 @@ package org.opensearch.sql.calcite.utils.datetime; -import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_DATE_FORMATTER; -import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_TIMESTAMP_FORMATTER; -import static org.opensearch.sql.utils.DateTimeFormatters.STRICT_TIME_FORMATTER; - -import com.google.common.collect.ImmutableList; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneId; -import java.time.format.DateTimeFormatter; -import java.util.List; -import org.opensearch.sql.exception.SemanticCheckException; +import java.time.format.DateTimeParseException; +import java.util.Locale; +import org.opensearch.sql.utils.DateTimeFormatters; public interface DateTimeParser { /** - * Parse a string into a LocalDateTime If only date is found, time is set to 00:00:00. If only - * time is found, date is set to today. + * Parse a string into a LocalDateTime. If only date is found, time is set to 00:00:00. If only + * time is found, date is set to today at UTC. * * @param input A date/time/timestamp string * @return A LocalDateTime * @throws IllegalArgumentException if parsing fails */ static LocalDateTime parse(String input) { - - if (input == null || input.trim().isEmpty()) { - throw new SemanticCheckException("Cannot parse a null/empty date-time string."); - } - - if (input.contains(":")) { - try { - return parseTimestamp(input); - } catch (Exception ignored) { - } - - try { - LocalTime t = parseTime(input); - return LocalDateTime.of(LocalDate.now(ZoneId.of("UTC")), t); - } catch (Exception ignored) { - } - } else { - try { - LocalDate d = parseDate(input); - return d.atStartOfDay(); - } catch (Exception ignored) { - } - } - throw new SemanticCheckException(String.format("Unable to parse %s as datetime", input)); - } - - static LocalDateTime parseTimeOrTimestamp(String input) { - if (input == null || input.trim().isEmpty()) { - throw new SemanticCheckException("Cannot parse a null/empty date-time string."); - } - - try { - return parseTime(input).atDate(LocalDate.now(ZoneId.of("UTC"))); - } catch (Exception ignored) { - } - - try { - return parseTimestamp(input); - } catch (Exception ignored) { - } - - throw new SemanticCheckException( - String.format("time:%s in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", input)); - } - - static LocalDateTime parseDateOrTimestamp(String input) { - if (input == null || input.trim().isEmpty()) { - throw new SemanticCheckException("Cannot parse a null/empty date-time string."); - } - try { - return parseDate(input).atStartOfDay(); - } catch (Exception ignored) { + return LocalDateTime.parse(input, DateTimeFormatters.DATE_TIMESTAMP_FORMATTER); + } catch (DateTimeParseException ignored) { } try { - return parseTimestamp(input); + LocalTime t = LocalTime.parse(input, DateTimeFormatters.TIME_TIMESTAMP_FORMATTER); + return LocalDateTime.of(LocalDate.now(ZoneId.of("UTC")), t); } catch (Exception ignored) { + throw new IllegalArgumentException( + String.format( + Locale.ROOT, + "timestamp:%s in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", + input)); } - - throw new SemanticCheckException( - String.format("date:%s in unsupported format, please use 'yyyy-MM-dd'", input)); - } - - static LocalDateTime parseTimestamp(String input) { - List dateTimeFormatters = ImmutableList.of(STRICT_TIMESTAMP_FORMATTER); - - for (DateTimeFormatter fmt : dateTimeFormatters) { - try { - return LocalDateTime.parse(input, fmt); - } catch (Exception ignored) { - } - } - throw new SemanticCheckException( - String.format( - "timestamp:%s in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", - input)); - } - - static LocalTime parseTime(String input) { - List timeFormatters = ImmutableList.of(STRICT_TIME_FORMATTER); - for (DateTimeFormatter fmt : timeFormatters) { - try { - return LocalTime.parse(input, fmt); - } catch (Exception ignored) { - } - } - throw new SemanticCheckException( - String.format("time:%s in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", input)); - } - - static LocalDate parseDate(String input) { - List dateFormatters = ImmutableList.of(STRICT_DATE_FORMATTER); - for (DateTimeFormatter fmt : dateFormatters) { - try { - return LocalDate.parse(input, fmt); - } catch (Exception ignored) { - } - } - throw new SemanticCheckException( - String.format("date:%s in unsupported format, please use 'yyyy-MM-dd'", input)); } } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java index 1e698918f3e..430a3423623 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java @@ -12,11 +12,12 @@ import java.time.ZoneOffset; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeParseException; import lombok.RequiredArgsConstructor; -import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.utils.DateTimeFormatters; /** Expression Date Value. */ @RequiredArgsConstructor @@ -24,11 +25,15 @@ public class ExprDateValue extends AbstractExprValue { private final LocalDate date; - /** Constructor of ExprDateValue. */ + /** + * Constructor with date string. + * + * @param date a date or timestamp string (does not accept time string) + */ public ExprDateValue(String date) { try { - this.date = DateTimeParser.parseDateOrTimestamp(date).toLocalDate(); - } catch (SemanticCheckException e) { + this.date = LocalDate.parse(date, DateTimeFormatters.DATE_TIMESTAMP_FORMATTER); + } catch (DateTimeParseException e) { throw new SemanticCheckException( String.format("date:%s in unsupported format, please use 'yyyy-MM-dd'", date)); } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java index 07a3aabdbdd..0129c90e6f4 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java @@ -12,13 +12,14 @@ import java.time.LocalTime; import java.time.ZoneOffset; import java.time.ZonedDateTime; +import java.time.format.DateTimeParseException; import java.util.Objects; import lombok.RequiredArgsConstructor; -import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; import org.opensearch.sql.expression.function.FunctionProperties; +import org.opensearch.sql.utils.DateTimeFormatters; /** Expression Time Value. */ @RequiredArgsConstructor @@ -26,11 +27,15 @@ public class ExprTimeValue extends AbstractExprValue { private final LocalTime time; - /** Constructor of ExprTimeValue. */ + /** + * Constructor with time string. + * + * @param time a time or timestamp string (does not accept date string) + */ public ExprTimeValue(String time) { try { - this.time = DateTimeParser.parseTimeOrTimestamp(time).toLocalTime(); - } catch (SemanticCheckException e) { + this.time = LocalTime.parse(time, DateTimeFormatters.TIME_TIMESTAMP_FORMATTER); + } catch (DateTimeParseException e) { throw new SemanticCheckException( String.format("time:%s in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", time)); } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java index 455723f6891..e6e55c7b824 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java @@ -13,13 +13,14 @@ import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneOffset; +import java.time.format.DateTimeParseException; import java.time.temporal.ChronoUnit; import java.util.Objects; import lombok.RequiredArgsConstructor; -import org.opensearch.sql.calcite.utils.datetime.DateTimeParser; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.utils.DateTimeFormatters; /** Expression Timestamp Value. */ @RequiredArgsConstructor @@ -27,12 +28,17 @@ public class ExprTimestampValue extends AbstractExprValue { private final Instant timestamp; - /** Constructor. */ + /** + * Constructor with timestamp string. + * + * @param timestamp a date or timestamp string (does not accept time string) + */ public ExprTimestampValue(String timestamp) { try { this.timestamp = - DateTimeParser.parseDateOrTimestamp(timestamp).atZone(ZoneOffset.UTC).toInstant(); - } catch (SemanticCheckException e) { + LocalDateTime.parse(timestamp, DateTimeFormatters.DATE_TIMESTAMP_FORMATTER) + .toInstant(ZoneOffset.UTC); + } catch (DateTimeParseException e) { throw new SemanticCheckException( String.format( "timestamp:%s in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", diff --git a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java index cbc715ef461..b35fd0946c7 100644 --- a/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java +++ b/core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java @@ -129,25 +129,23 @@ public class DateTimeFormatters { .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); - public static final DateTimeFormatter STRICT_TIMESTAMP_FORMATTER = + public static final DateTimeFormatter DATE_TIMESTAMP_FORMATTER = new DateTimeFormatterBuilder() - .appendPattern("[uuuu-MM-dd HH:mm:ss][uuuu-MM-dd HH:mm]") + .appendPattern("[uuuu-MM-dd HH:mm:ss][uuuu-MM-dd HH:mm][uuuu-MM-dd]") .appendFraction( ChronoField.NANO_OF_SECOND, MIN_FRACTION_SECONDS, MAX_FRACTION_SECONDS, true) + .parseDefaulting(HOUR_OF_DAY, 0) + .parseDefaulting(MINUTE_OF_HOUR, 0) + .parseDefaulting(SECOND_OF_MINUTE, 0) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); - public static final DateTimeFormatter STRICT_DATE_FORMATTER = + public static final DateTimeFormatter TIME_TIMESTAMP_FORMATTER = new DateTimeFormatterBuilder() - .appendPattern("[uuuu-MM-dd]") - .toFormatter(Locale.ROOT) - .withResolverStyle(ResolverStyle.STRICT); - - public static final DateTimeFormatter STRICT_TIME_FORMATTER = - new DateTimeFormatterBuilder() - .appendPattern("[HH:mm:ss][HH:mm]") + .appendPattern("[uuuu-MM-dd HH:mm:ss][uuuu-MM-dd HH:mm][HH:mm:ss][HH:mm]") .appendFraction( ChronoField.NANO_OF_SECOND, MIN_FRACTION_SECONDS, MAX_FRACTION_SECONDS, true) + .parseDefaulting(SECOND_OF_MINUTE, 0) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); diff --git a/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java b/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java index 376dc5a8762..e5132eb02f1 100644 --- a/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/sql/DateTimeFunctionIT.java @@ -1396,6 +1396,13 @@ protected JSONObject executeQuery(String query) throws IOException { return new JSONObject(getResponseBody(response)); } + @Test + public void testDateStringAsTimestamp() throws IOException { + JSONObject result = executeQuery("select {timestamp '2025-07-10'} as t"); + verifySchema(result, schema("{timestamp '2025-07-10'}", "t", "timestamp")); + verifyDataRows(result, rows("2025-07-10 00:00:00")); + } + @Test public void testTimestampBracket() throws IOException { JSONObject result = executeQuery("select {timestamp '2020-09-16 17:30:00'}"); @@ -1471,9 +1478,6 @@ public void testBracketFails() { assertThrows(ResponseException.class, () -> executeQuery("select {t '2020-09-16'}")); assertThrows(ResponseException.class, () -> executeQuery("select {date '17:30:00'}")); assertThrows(ResponseException.class, () -> executeQuery("select {d '17:30:00'}")); - // The following test case is removed because they will be parsed to proper timestamps - // assertThrows(ResponseException.class, () -> executeQuery("select {timestamp '2020-09-16'}")); - // assertThrows(ResponseException.class, () -> executeQuery("select {ts '2020-09-16'}")); assertThrows(ResponseException.class, () -> executeQuery("select {timestamp '17:30:00'}")); assertThrows(ResponseException.class, () -> executeQuery("select {ts '17:30:00'}")); } From bd9cea2ea33e557b1b50ffab74fbf4513cf449cb Mon Sep 17 00:00:00 2001 From: Yuanchun Shen Date: Thu, 10 Jul 2025 15:10:40 +0800 Subject: [PATCH 7/7] Change to ExpressionEvaluationException when fail parsing malformat date/time strings Signed-off-by: Yuanchun Shen --- .../datetime/DateTimeConversionUtils.java | 10 +- .../sql/data/model/ExprDateValue.java | 4 +- .../sql/data/model/ExprStringValue.java | 8 +- .../sql/data/model/ExprTimeValue.java | 4 +- .../sql/data/model/ExprTimestampValue.java | 4 +- .../sql/data/model/DateTimeValueTest.java | 38 +-- .../expression/datetime/ConvertTZTest.java | 10 +- .../datetime/DateTimeFunctionTest.java | 136 +++++--- .../expression/datetime/TimeStampAddTest.java | 4 +- .../datetime/TimeStampDiffTest.java | 3 +- .../expression/datetime/TimestampTest.java | 4 +- .../expression/datetime/ToSecondsTest.java | 4 +- .../sql/expression/datetime/WeekdayTest.java | 18 +- .../sql/expression/datetime/YearweekTest.java | 10 +- ...tePPLBuiltinDatetimeFunctionInvalidIT.java | 294 +++++++++--------- .../CalcitePPLBuiltinFunctionsNullIT.java | 26 +- .../remote/CalcitePPLCastFunctionIT.java | 8 +- .../script/filter/lucene/LuceneQueryTest.java | 4 +- 18 files changed, 320 insertions(+), 269 deletions(-) diff --git a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeConversionUtils.java b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeConversionUtils.java index 20edee22bff..ebc4f56c748 100644 --- a/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeConversionUtils.java +++ b/core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeConversionUtils.java @@ -11,7 +11,7 @@ import org.apache.calcite.avatica.util.TimeUnit; import org.opensearch.sql.data.model.*; import org.opensearch.sql.data.type.ExprCoreType; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.function.FunctionProperties; public final class DateTimeConversionUtils { @@ -36,7 +36,7 @@ public static ExprTimestampValue forceConvertToTimestampValue( ExprValueUtils.timestampValue(timeValue.timestampValue(properties)); case ExprStringValue stringValue -> new ExprTimestampValue( DateTimeParser.parse(stringValue.stringValue())); - default -> throw new SemanticCheckException( + default -> throw new ExpressionEvaluationException( String.format( "Cannot convert %s to timestamp, only STRING, DATE, TIME and TIMESTAMP are supported", value.type())); @@ -63,8 +63,8 @@ public static ExprTimestampValue convertToTimestampValue( } else { try { return new ExprTimestampValue(value.timestampValue()); - } catch (SemanticCheckException e) { - throw new SemanticCheckException( + } catch (ExpressionEvaluationException e) { + throw new ExpressionEvaluationException( String.format( "Cannot convert %s to timestamp, only STRING, DATE, TIME and TIMESTAMP are" + " supported", @@ -98,7 +98,7 @@ public static ExprDateValue convertToDateValue(ExprValue value, FunctionProperti return new ExprDateValue(value.stringValue()); } default -> { - throw new SemanticCheckException( + throw new ExpressionEvaluationException( String.format( "Cannot convert %s to date, only STRING, DATE, TIME and TIMESTAMP are supported", value.type())); diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java index 430a3423623..5285a0c02a3 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprDateValue.java @@ -16,7 +16,7 @@ import lombok.RequiredArgsConstructor; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.utils.DateTimeFormatters; /** Expression Date Value. */ @@ -34,7 +34,7 @@ public ExprDateValue(String date) { try { this.date = LocalDate.parse(date, DateTimeFormatters.DATE_TIMESTAMP_FORMATTER); } catch (DateTimeParseException e) { - throw new SemanticCheckException( + throw new ExpressionEvaluationException( String.format("date:%s in unsupported format, please use 'yyyy-MM-dd'", date)); } } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprStringValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprStringValue.java index f2e63e986de..c72075869da 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprStringValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprStringValue.java @@ -13,7 +13,7 @@ import lombok.RequiredArgsConstructor; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; /** Expression String Value. */ @RequiredArgsConstructor @@ -39,7 +39,7 @@ public String stringValue() { public Instant timestampValue() { try { return new ExprTimestampValue(value).timestampValue(); - } catch (SemanticCheckException e) { + } catch (ExpressionEvaluationException e) { return new ExprTimestampValue( LocalDateTime.of(new ExprDateValue(value).dateValue(), LocalTime.of(0, 0, 0))) .timestampValue(); @@ -50,7 +50,7 @@ public Instant timestampValue() { public LocalDate dateValue() { try { return new ExprTimestampValue(value).dateValue(); - } catch (SemanticCheckException e) { + } catch (ExpressionEvaluationException e) { return new ExprDateValue(value).dateValue(); } } @@ -59,7 +59,7 @@ public LocalDate dateValue() { public LocalTime timeValue() { try { return new ExprTimestampValue(value).timeValue(); - } catch (SemanticCheckException e) { + } catch (ExpressionEvaluationException e) { return new ExprTimeValue(value).timeValue(); } } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java index 0129c90e6f4..6e441ba88d6 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimeValue.java @@ -17,7 +17,7 @@ import lombok.RequiredArgsConstructor; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.function.FunctionProperties; import org.opensearch.sql.utils.DateTimeFormatters; @@ -36,7 +36,7 @@ public ExprTimeValue(String time) { try { this.time = LocalTime.parse(time, DateTimeFormatters.TIME_TIMESTAMP_FORMATTER); } catch (DateTimeParseException e) { - throw new SemanticCheckException( + throw new ExpressionEvaluationException( String.format("time:%s in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", time)); } } diff --git a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java index e6e55c7b824..194a2c2420e 100644 --- a/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java +++ b/core/src/main/java/org/opensearch/sql/data/model/ExprTimestampValue.java @@ -19,7 +19,7 @@ import lombok.RequiredArgsConstructor; import org.opensearch.sql.data.type.ExprCoreType; import org.opensearch.sql.data.type.ExprType; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.utils.DateTimeFormatters; /** Expression Timestamp Value. */ @@ -39,7 +39,7 @@ public ExprTimestampValue(String timestamp) { LocalDateTime.parse(timestamp, DateTimeFormatters.DATE_TIMESTAMP_FORMATTER) .toInstant(ZoneOffset.UTC); } catch (DateTimeParseException e) { - throw new SemanticCheckException( + throw new ExpressionEvaluationException( String.format( "timestamp:%s in unsupported format, please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", timestamp)); diff --git a/core/src/test/java/org/opensearch/sql/data/model/DateTimeValueTest.java b/core/src/test/java/org/opensearch/sql/data/model/DateTimeValueTest.java index b5a3d61211f..31a38983347 100644 --- a/core/src/test/java/org/opensearch/sql/data/model/DateTimeValueTest.java +++ b/core/src/test/java/org/opensearch/sql/data/model/DateTimeValueTest.java @@ -18,7 +18,6 @@ import java.time.ZonedDateTime; import org.junit.jupiter.api.Test; import org.opensearch.sql.exception.ExpressionEvaluationException; -import org.opensearch.sql.exception.SemanticCheckException; import org.opensearch.sql.expression.function.FunctionProperties; public class DateTimeValueTest { @@ -90,23 +89,23 @@ public void dateValueInterfaceTest() { assertEquals( ZonedDateTime.of(LocalDateTime.parse("2012-07-07T00:00:00"), ZoneOffset.UTC).toInstant(), dateValue.timestampValue()); - ExpressionEvaluationException exception = + Throwable exception = assertThrows(ExpressionEvaluationException.class, () -> integerValue(1).dateValue()); assertEquals("invalid to get dateValue from value of type INTEGER", exception.getMessage()); } @Test public void dateInUnsupportedFormat() { - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> new ExprDateValue("2020-07-07Z")); + Throwable exception = + assertThrows(ExpressionEvaluationException.class, () -> new ExprDateValue("2020-07-07Z")); assertEquals( "date:2020-07-07Z in unsupported format, please use 'yyyy-MM-dd'", exception.getMessage()); } @Test public void timeInUnsupportedFormat() { - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> new ExprTimeValue("01:01:0")); + Throwable exception = + assertThrows(ExpressionEvaluationException.class, () -> new ExprTimeValue("01:01:0")); assertEquals( "time:01:01:0 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", exception.getMessage()); @@ -114,9 +113,10 @@ public void timeInUnsupportedFormat() { @Test public void timestampInUnsupportedFormat() { - SemanticCheckException exception = + Throwable exception = assertThrows( - SemanticCheckException.class, () -> new ExprTimestampValue("2020-07-07T01:01:01Z")); + ExpressionEvaluationException.class, + () -> new ExprTimestampValue("2020-07-07T01:01:01Z")); assertEquals( "timestamp:2020-07-07T01:01:01Z in unsupported format, " + "please use 'yyyy-MM-dd HH:mm:ss[.SSSSSSSSS]'", @@ -134,9 +134,9 @@ public void stringTimestampValue() { assertEquals(LocalTime.parse("19:44:00"), stringValue.timeValue()); assertEquals("\"2020-08-17 19:44:00\"", stringValue.toString()); - SemanticCheckException exception = + Throwable exception = assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> new ExprStringValue("2020-07-07T01:01:01Z").timestampValue()); assertEquals( "date:2020-07-07T01:01:01Z in unsupported format, " + "please use 'yyyy-MM-dd'", @@ -152,9 +152,10 @@ public void stringDateValue() { assertEquals(LocalDate.parse("2020-08-17"), stringValue.dateValue()); assertEquals("\"2020-08-17\"", stringValue.toString()); - SemanticCheckException exception = + Throwable exception = assertThrows( - SemanticCheckException.class, () -> new ExprStringValue("2020-07-07Z").dateValue()); + ExpressionEvaluationException.class, + () -> new ExprStringValue("2020-07-07Z").dateValue()); assertEquals( "date:2020-07-07Z in unsupported format, please use 'yyyy-MM-dd'", exception.getMessage()); } @@ -166,9 +167,9 @@ public void stringTimeValue() { assertEquals(LocalTime.parse("19:44:00"), stringValue.timeValue()); assertEquals("\"19:44:00\"", stringValue.toString()); - SemanticCheckException exception = + Throwable exception = assertThrows( - SemanticCheckException.class, () -> new ExprStringValue("01:01:0").timeValue()); + ExpressionEvaluationException.class, () -> new ExprStringValue("01:01:0").timeValue()); assertEquals( "time:01:01:0 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", exception.getMessage()); @@ -214,9 +215,9 @@ public void timestampWithVariableNanoPrecision() { @Test public void timestampOverMaxNanoPrecision() { - SemanticCheckException exception = + Throwable exception = assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> new ExprTimestampValue("2020-07-07 01:01:01.1234567890")); assertEquals( "timestamp:2020-07-07 01:01:01.1234567890 in unsupported format, please use " @@ -226,8 +227,9 @@ public void timestampOverMaxNanoPrecision() { @Test public void timeOverMaxNanoPrecision() { - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> new ExprTimeValue("01:01:01.1234567890")); + Throwable exception = + assertThrows( + ExpressionEvaluationException.class, () -> new ExprTimeValue("01:01:01.1234567890")); assertEquals( "time:01:01:01.1234567890 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'", exception.getMessage()); diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/ConvertTZTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/ConvertTZTest.java index 707f995138e..9602c434535 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/ConvertTZTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/ConvertTZTest.java @@ -12,7 +12,7 @@ import org.junit.jupiter.api.Test; import org.opensearch.sql.data.model.ExprTimestampValue; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.ExpressionTestBase; import org.opensearch.sql.expression.FunctionExpression; @@ -27,7 +27,7 @@ public void invalidDate() { DSL.literal("+00:00"), DSL.literal("+00:00")); assertEquals(TIMESTAMP, expr.type()); - assertThrows(SemanticCheckException.class, expr::valueOf); + assertThrows(ExpressionEvaluationException.class, expr::valueOf); } @Test @@ -156,7 +156,7 @@ public void invalidDateFeb30() { DSL.literal("+00:00"), DSL.literal("+00:00")); assertEquals(TIMESTAMP, expr.type()); - assertThrows(SemanticCheckException.class, expr::valueOf); + assertThrows(ExpressionEvaluationException.class, expr::valueOf); } @Test @@ -167,7 +167,7 @@ public void invalidDateApril31() { DSL.literal("+00:00"), DSL.literal("+00:00")); assertEquals(TIMESTAMP, expr.type()); - assertThrows(SemanticCheckException.class, expr::valueOf); + assertThrows(ExpressionEvaluationException.class, expr::valueOf); } @Test @@ -178,6 +178,6 @@ public void invalidMonth13() { DSL.literal("+00:00"), DSL.literal("+00:00")); assertEquals(TIMESTAMP, expr.type()); - assertThrows(SemanticCheckException.class, expr::valueOf); + assertThrows(ExpressionEvaluationException.class, expr::valueOf); } } diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/DateTimeFunctionTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/DateTimeFunctionTest.java index ad15dadfb73..11b367fd7b1 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/DateTimeFunctionTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/DateTimeFunctionTest.java @@ -42,6 +42,7 @@ import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprTimestampValue; 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.Expression; @@ -253,20 +254,24 @@ public void dayOfMonthWithUnderscoresLeapYear() { DSL.day_of_month(functionProperties, DSL.literal("2020-02-29")), 29); // Feb. 29 of a non-leap year - assertThrows(SemanticCheckException.class, () -> testInvalidDayOfMonth("2021-02-29")); + assertThrows(ExpressionEvaluationException.class, () -> testInvalidDayOfMonth("2021-02-29")); } @Test public void dayOfMonthWithUnderscoresInvalidArguments() { assertAll( // 40th day of the month - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfMonth("2021-02-40")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfMonth("2021-02-40")), // 13th month of the year - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfMonth("2021-13-40")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfMonth("2021-13-40")), // incorrect format () -> assertThrows( - SemanticCheckException.class, () -> testInvalidDayOfMonth("asdfasdfasdf"))); + ExpressionEvaluationException.class, () -> testInvalidDayOfMonth("asdfasdfasdf"))); } private void dayOfWeekQuery(FunctionExpression dateExpression, int dayOfWeek, String testExpr) { @@ -361,20 +366,28 @@ public void dayOfWeekWithUnderscoresLeapYear() { 1, "day_of_week(\"2021-02-28\")"), // Feb. 29 of a non-leap year - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfWeek("2021-02-29"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfWeek("2021-02-29"))); } @Test public void dayOfWeekWithUnderscoresInvalidArgument() { assertAll( // 40th day of the month - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfWeek("2021-02-40")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfWeek("2021-02-40")), // 13th month of the year - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfWeek("2021-13-29")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfWeek("2021-13-29")), // incorrect format - () -> assertThrows(SemanticCheckException.class, () -> testInvalidDayOfWeek("asdfasdf"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidDayOfWeek("asdfasdf"))); } @Test @@ -490,15 +503,19 @@ private void invalidDayOfYearQuery(String date) { public void invalidDayOfYearArgument() { assertAll( // 29th of Feb non-leapyear - () -> assertThrows(SemanticCheckException.class, () -> invalidDayOfYearQuery("2019-02-29")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDayOfYearQuery("2019-02-29")), // 13th month - () -> assertThrows(SemanticCheckException.class, () -> invalidDayOfYearQuery("2019-13-15")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDayOfYearQuery("2019-13-15")), // incorrect format for type () -> assertThrows( - SemanticCheckException.class, () -> invalidDayOfYearQuery("asdfasdfasdf"))); + ExpressionEvaluationException.class, () -> invalidDayOfYearQuery("asdfasdfasdf"))); } @Test @@ -578,19 +595,19 @@ private void testInvalidMinuteOfDay(String date) { @Test public void invalidMinuteOfDay() { assertThrows( - SemanticCheckException.class, () -> testInvalidMinuteOfDay("2022-12-14 12:23:3400")); + ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("2022-12-14 12:23:3400")); assertThrows( - SemanticCheckException.class, () -> testInvalidMinuteOfDay("2022-12-14 12:2300:34")); + ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("2022-12-14 12:2300:34")); assertThrows( - SemanticCheckException.class, () -> testInvalidMinuteOfDay("2022-12-14 1200:23:34")); + ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("2022-12-14 1200:23:34")); assertThrows( - SemanticCheckException.class, () -> testInvalidMinuteOfDay("2022-12-1400 12:23:34")); + ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("2022-12-1400 12:23:34")); assertThrows( - SemanticCheckException.class, () -> testInvalidMinuteOfDay("2022-1200-14 12:23:34")); - assertThrows(SemanticCheckException.class, () -> testInvalidMinuteOfDay("12:23:3400")); - assertThrows(SemanticCheckException.class, () -> testInvalidMinuteOfDay("12:2300:34")); - assertThrows(SemanticCheckException.class, () -> testInvalidMinuteOfDay("1200:23:34")); - assertThrows(SemanticCheckException.class, () -> testInvalidMinuteOfDay("asdfasdfasdf")); + ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("2022-1200-14 12:23:34")); + assertThrows(ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("12:23:3400")); + assertThrows(ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("12:2300:34")); + assertThrows(ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("1200:23:34")); + assertThrows(ExpressionEvaluationException.class, () -> testInvalidMinuteOfDay("asdfasdfasdf")); } private void hourOfDayQuery(FunctionExpression dateExpression, int hour) { @@ -626,15 +643,23 @@ private void invalidHourOfDayQuery(String time) { public void hourOfDayInvalidArguments() { assertAll( // Invalid Seconds - () -> assertThrows(SemanticCheckException.class, () -> invalidHourOfDayQuery("12:23:61")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidHourOfDayQuery("12:23:61")), // Invalid Minutes - () -> assertThrows(SemanticCheckException.class, () -> invalidHourOfDayQuery("12:61:34")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidHourOfDayQuery("12:61:34")), // Invalid Hours - () -> assertThrows(SemanticCheckException.class, () -> invalidHourOfDayQuery("25:23:34")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidHourOfDayQuery("25:23:34")), // incorrect format - () -> assertThrows(SemanticCheckException.class, () -> invalidHourOfDayQuery("asdfasdf"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidHourOfDayQuery("asdfasdf"))); } private void checkForExpectedDay( @@ -693,7 +718,7 @@ private void lastDay(String date) { @Test public void testLastDayInvalidArgument() { - assertThrows(SemanticCheckException.class, () -> lastDay("asdfasdf")); + assertThrows(ExpressionEvaluationException.class, () -> lastDay("asdfasdf")); } @Test @@ -821,19 +846,23 @@ public void minuteOfHourInvalidArguments() { assertAll( // Invalid Seconds () -> - assertThrows(SemanticCheckException.class, () -> invalidMinuteOfHourQuery("12:23:61")), + assertThrows( + ExpressionEvaluationException.class, () -> invalidMinuteOfHourQuery("12:23:61")), // Invalid Minutes () -> - assertThrows(SemanticCheckException.class, () -> invalidMinuteOfHourQuery("12:61:34")), + assertThrows( + ExpressionEvaluationException.class, () -> invalidMinuteOfHourQuery("12:61:34")), // Invalid Hours () -> - assertThrows(SemanticCheckException.class, () -> invalidMinuteOfHourQuery("25:23:34")), + assertThrows( + ExpressionEvaluationException.class, () -> invalidMinuteOfHourQuery("25:23:34")), // incorrect format () -> - assertThrows(SemanticCheckException.class, () -> invalidMinuteOfHourQuery("asdfasdf"))); + assertThrows( + ExpressionEvaluationException.class, () -> invalidMinuteOfHourQuery("asdfasdf"))); } @Test @@ -882,7 +911,7 @@ public void testMonthOfYearWithTimeType() { LocalDate.now(functionProperties.getQueryStartClock()).getMonthValue()); } - private void invalidDatesQuery(String date) throws SemanticCheckException { + private void invalidDatesQuery(String date) throws ExpressionEvaluationException { FunctionExpression expression = DSL.month_of_year(functionProperties, DSL.literal(new ExprDateValue(date))); eval(expression); @@ -891,10 +920,18 @@ private void invalidDatesQuery(String date) throws SemanticCheckException { @Test public void monthOfYearInvalidDates() { assertAll( - () -> assertThrows(SemanticCheckException.class, () -> invalidDatesQuery("2019-01-50")), - () -> assertThrows(SemanticCheckException.class, () -> invalidDatesQuery("2019-02-29")), - () -> assertThrows(SemanticCheckException.class, () -> invalidDatesQuery("2019-02-31")), - () -> assertThrows(SemanticCheckException.class, () -> invalidDatesQuery("2019-13-05"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDatesQuery("2019-01-50")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDatesQuery("2019-02-29")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDatesQuery("2019-02-31")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> invalidDatesQuery("2019-13-05"))); } @Test @@ -1050,19 +1087,19 @@ public void secondOfMinuteInvalidArguments() { // Invalid Seconds () -> assertThrows( - SemanticCheckException.class, () -> invalidSecondOfMinuteQuery("12:23:61")), + ExpressionEvaluationException.class, () -> invalidSecondOfMinuteQuery("12:23:61")), // Invalid Minutes () -> assertThrows( - SemanticCheckException.class, () -> invalidSecondOfMinuteQuery("12:61:34")), + ExpressionEvaluationException.class, () -> invalidSecondOfMinuteQuery("12:61:34")), // Invalid Hours () -> assertThrows( - SemanticCheckException.class, () -> invalidSecondOfMinuteQuery("25:23:34")), + ExpressionEvaluationException.class, () -> invalidSecondOfMinuteQuery("25:23:34")), // incorrect format () -> assertThrows( - SemanticCheckException.class, () -> invalidSecondOfMinuteQuery("asdfasdf"))); + ExpressionEvaluationException.class, () -> invalidSecondOfMinuteQuery("asdfasdf"))); } @Test @@ -1264,8 +1301,7 @@ public void testWeekOfYearWithTimeType() { public void modeInUnsupportedFormat() { FunctionExpression expression1 = DSL.week(functionProperties, DSL.literal(new ExprDateValue("2019-01-05")), DSL.literal(8)); - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> eval(expression1)); + Throwable exception = assertThrows(SemanticCheckException.class, () -> eval(expression1)); assertEquals("mode:8 is invalid, please use mode value between 0-7", exception.getMessage()); FunctionExpression expression2 = @@ -1281,31 +1317,34 @@ public void testInvalidWeekOfYear() { // test invalid month () -> assertThrows( - SemanticCheckException.class, () -> weekOfYearQuery("2019-13-05 01:02:03", 0, 0)), + ExpressionEvaluationException.class, + () -> weekOfYearQuery("2019-13-05 01:02:03", 0, 0)), // test invalid day () -> assertThrows( - SemanticCheckException.class, () -> weekOfYearQuery("2019-01-50 01:02:03", 0, 0)), + ExpressionEvaluationException.class, + () -> weekOfYearQuery("2019-01-50 01:02:03", 0, 0)), // test invalid leap year () -> assertThrows( - SemanticCheckException.class, () -> weekOfYearQuery("2019-02-29 01:02:03", 0, 0)), + ExpressionEvaluationException.class, + () -> weekOfYearQuery("2019-02-29 01:02:03", 0, 0)), // Test for Week_Of_Year // test invalid month () -> assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> weekOfYearUnderscoresQuery("2019-13-05 01:02:03", 0, 0)), // test invalid day () -> assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> weekOfYearUnderscoresQuery("2019-01-50 01:02:03", 0, 0)), // test invalid leap year () -> assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> weekOfYearUnderscoresQuery("2019-02-29 01:02:03", 0, 0))); } @@ -1314,8 +1353,7 @@ public void weekOfYearModeInUnsupportedFormat() { FunctionExpression expression1 = DSL.week_of_year( functionProperties, DSL.literal(new ExprDateValue("2019-01-05")), DSL.literal(8)); - SemanticCheckException exception = - assertThrows(SemanticCheckException.class, () -> eval(expression1)); + Throwable exception = assertThrows(SemanticCheckException.class, () -> eval(expression1)); assertEquals("mode:8 is invalid, please use mode value between 0-7", exception.getMessage()); FunctionExpression expression2 = @@ -1459,7 +1497,7 @@ private static Stream getInvalidTestDataForTimeFormat() { @MethodSource("getInvalidTestDataForTimeFormat") public void testInvalidTimeFormat(LiteralExpression arg, LiteralExpression format) { FunctionExpression expr = DSL.time_format(functionProperties, arg, format); - assertThrows(SemanticCheckException.class, () -> eval(expr)); + assertThrows(ExpressionEvaluationException.class, () -> eval(expr)); } private static Stream getInvalidTimeFormatHandlers() { diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampAddTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampAddTest.java index 13f4f207040..b60b9b8812c 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampAddTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampAddTest.java @@ -24,7 +24,7 @@ import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprTimestampValue; import org.opensearch.sql.data.model.ExprValue; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.Expression; import org.opensearch.sql.expression.ExpressionTestBase; @@ -207,7 +207,7 @@ private static Stream getInvalidTestDataForTimestampAdd() { @MethodSource("getInvalidTestDataForTimestampAdd") public void testInvalidArguments(String interval, int amount, ExprValue datetimeExpr) { FunctionExpression expr = timestampaddQuery(interval, amount, datetimeExpr); - assertThrows(SemanticCheckException.class, () -> eval(expr)); + assertThrows(ExpressionEvaluationException.class, () -> eval(expr)); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampDiffTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampDiffTest.java index b5ac3b078f0..6feead30d79 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampDiffTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/TimeStampDiffTest.java @@ -26,6 +26,7 @@ import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprTimestampValue; 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.Expression; @@ -260,7 +261,7 @@ public void testTimestampDiffWithInvalidTimeArgs(String unit, String arg1, Strin FunctionExpression expr = timestampdiffQuery( functionProperties, unit, new ExprStringValue(arg1), new ExprStringValue(arg2)); - assertThrows(SemanticCheckException.class, () -> eval(expr)); + assertThrows(ExpressionEvaluationException.class, () -> eval(expr)); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/TimestampTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/TimestampTest.java index 5aebec9e782..92058f9bae1 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/TimestampTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/TimestampTest.java @@ -24,7 +24,7 @@ import org.junit.jupiter.params.provider.MethodSource; import org.opensearch.sql.data.model.ExprTimestampValue; import org.opensearch.sql.data.model.ExprValueUtils; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.ExpressionTestBase; @@ -60,7 +60,7 @@ public void timestamp_one_arg_string_invalid_format(String value, String testNam // exception thrown from ExprTimestampValue(String) CTOR var exception = assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> DSL.timestamp(functionProperties, DSL.literal(value)).valueOf()); assertEquals( String.format( diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/ToSecondsTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/ToSecondsTest.java index e983eb28f67..0cfca70258b 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/ToSecondsTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/ToSecondsTest.java @@ -27,7 +27,7 @@ import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprTimestampValue; import org.opensearch.sql.data.model.ExprValue; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.Expression; import org.opensearch.sql.expression.ExpressionTestBase; @@ -90,7 +90,7 @@ private static Stream getInvalidTestDataForToSeconds() { @MethodSource("getInvalidTestDataForToSeconds") public void testToSecondsInvalidArg(ExprValue arg) { FunctionExpression expr = DSL.to_seconds(DSL.literal(arg)); - assertThrows(SemanticCheckException.class, () -> eval(expr)); + assertThrows(ExpressionEvaluationException.class, () -> eval(expr)); } @Test diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/WeekdayTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/WeekdayTest.java index d2a63945034..e7b292970a5 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/WeekdayTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/WeekdayTest.java @@ -20,7 +20,7 @@ import org.opensearch.sql.data.model.ExprDateValue; import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprValue; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.expression.Expression; import org.opensearch.sql.expression.ExpressionTestBase; @@ -96,20 +96,28 @@ public void weekdayLeapYear() { 6, "weekday(\"2021-02-28\")"), // Feb. 29 of a non-leap year - () -> assertThrows(SemanticCheckException.class, () -> testInvalidWeekday("2021-02-29"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidWeekday("2021-02-29"))); } @Test public void weekdayInvalidArgument() { assertAll( // 40th day of the month - () -> assertThrows(SemanticCheckException.class, () -> testInvalidWeekday("2021-02-40")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidWeekday("2021-02-40")), // 13th month of the year - () -> assertThrows(SemanticCheckException.class, () -> testInvalidWeekday("2021-13-29")), + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidWeekday("2021-13-29")), // incorrect format - () -> assertThrows(SemanticCheckException.class, () -> testInvalidWeekday("asdfasdf"))); + () -> + assertThrows( + ExpressionEvaluationException.class, () -> testInvalidWeekday("asdfasdf"))); } private ExprValue eval(Expression expression) { diff --git a/core/src/test/java/org/opensearch/sql/expression/datetime/YearweekTest.java b/core/src/test/java/org/opensearch/sql/expression/datetime/YearweekTest.java index d944f7c85c3..fbfb2996e28 100644 --- a/core/src/test/java/org/opensearch/sql/expression/datetime/YearweekTest.java +++ b/core/src/test/java/org/opensearch/sql/expression/datetime/YearweekTest.java @@ -24,6 +24,7 @@ import org.opensearch.sql.data.model.ExprTimeValue; import org.opensearch.sql.data.model.ExprTimestampValue; 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.Expression; @@ -139,15 +140,18 @@ public void testInvalidYearWeek() { // test invalid month () -> assertThrows( - SemanticCheckException.class, () -> yearweekQuery("2019-13-05 01:02:03", 0, 0)), + ExpressionEvaluationException.class, + () -> yearweekQuery("2019-13-05 01:02:03", 0, 0)), // test invalid day () -> assertThrows( - SemanticCheckException.class, () -> yearweekQuery("2019-01-50 01:02:03", 0, 0)), + ExpressionEvaluationException.class, + () -> yearweekQuery("2019-01-50 01:02:03", 0, 0)), // test invalid leap year () -> assertThrows( - SemanticCheckException.class, () -> yearweekQuery("2019-02-29 01:02:03", 0, 0))); + ExpressionEvaluationException.class, + () -> yearweekQuery("2019-02-29 01:02:03", 0, 0))); } @Test diff --git a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinDatetimeFunctionInvalidIT.java b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinDatetimeFunctionInvalidIT.java index e0fb5b7ee6b..d1327986821 100644 --- a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinDatetimeFunctionInvalidIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinDatetimeFunctionInvalidIT.java @@ -9,7 +9,7 @@ import static org.opensearch.sql.util.MatcherUtils.verifyErrorMessageContains; import org.junit.jupiter.api.Test; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.legacy.SQLIntegTestCase; import org.opensearch.sql.ppl.PPLIntegTestCase; @@ -30,7 +30,7 @@ public void init() throws Exception { public void testYearWeekInvalid() { Throwable e = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -43,7 +43,7 @@ public void testYearWeekInvalid() { public void testYearInvalid() { Throwable e = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -52,7 +52,7 @@ public void testYearInvalid() { verifyErrorMessageContains(e, "unsupported format"); Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -65,7 +65,7 @@ public void testYearInvalid() { public void testWeekInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -75,7 +75,7 @@ public void testWeekInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -88,7 +88,7 @@ public void testWeekInvalid() { public void testTO_SECONDSInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -98,7 +98,7 @@ public void testTO_SECONDSInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -107,7 +107,7 @@ public void testTO_SECONDSInvalid() { verifyErrorMessageContains(e2, "unsupported format"); Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -121,7 +121,7 @@ public void testDATEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -130,7 +130,7 @@ public void testDATEInvalid() { verifyErrorMessageContains(e1, "unsupported format"); Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -139,7 +139,7 @@ public void testDATEInvalid() { verifyErrorMessageContains(e2, "unsupported format"); Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -153,7 +153,7 @@ public void testTIMEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -163,7 +163,7 @@ public void testTIMEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -173,7 +173,7 @@ public void testTIMEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -187,7 +187,7 @@ public void testDAYInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -197,7 +197,7 @@ public void testDAYInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -207,7 +207,7 @@ public void testDAYInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -221,7 +221,7 @@ public void testDAYNAMEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -232,7 +232,7 @@ public void testDAYNAMEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -242,7 +242,7 @@ public void testDAYNAMEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -257,7 +257,7 @@ public void testDAYOFMONTHInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -267,7 +267,7 @@ public void testDAYOFMONTHInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -277,7 +277,7 @@ public void testDAYOFMONTHInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -292,7 +292,7 @@ public void testDAY_OF_MONTHInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -303,7 +303,7 @@ public void testDAY_OF_MONTHInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -313,7 +313,7 @@ public void testDAY_OF_MONTHInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -327,7 +327,7 @@ public void testDAYOFWEEKInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -337,7 +337,7 @@ public void testDAYOFWEEKInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -347,7 +347,7 @@ public void testDAYOFWEEKInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -357,7 +357,7 @@ public void testDAYOFWEEKInvalid() { Throwable e4 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -367,7 +367,7 @@ public void testDAYOFWEEKInvalid() { Throwable e5 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -377,7 +377,7 @@ public void testDAYOFWEEKInvalid() { Throwable e6 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -391,7 +391,7 @@ public void testDAY_OF_WEEKInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -401,7 +401,7 @@ public void testDAY_OF_WEEKInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -411,7 +411,7 @@ public void testDAY_OF_WEEKInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -425,7 +425,7 @@ public void testDAYOFYEARInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -435,7 +435,7 @@ public void testDAYOFYEARInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -445,7 +445,7 @@ public void testDAYOFYEARInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -459,7 +459,7 @@ public void testDAY_OF_YEARInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -469,7 +469,7 @@ public void testDAY_OF_YEARInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -479,7 +479,7 @@ public void testDAY_OF_YEARInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -493,7 +493,7 @@ public void testHOURInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -503,7 +503,7 @@ public void testHOURInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -513,7 +513,7 @@ public void testHOURInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -527,7 +527,7 @@ public void testHOUR_OF_DAYInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -537,7 +537,7 @@ public void testHOUR_OF_DAYInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -547,7 +547,7 @@ public void testHOUR_OF_DAYInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -561,7 +561,7 @@ public void testLAST_DAYInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -571,7 +571,7 @@ public void testLAST_DAYInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -581,7 +581,7 @@ public void testLAST_DAYInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -595,7 +595,7 @@ public void testMINUTEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -605,7 +605,7 @@ public void testMINUTEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -615,7 +615,7 @@ public void testMINUTEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -629,7 +629,7 @@ public void testMINUTE_OF_DAYInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -639,7 +639,7 @@ public void testMINUTE_OF_DAYInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -649,7 +649,7 @@ public void testMINUTE_OF_DAYInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -663,7 +663,7 @@ public void testMINUTE_OF_HOURInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -673,7 +673,7 @@ public void testMINUTE_OF_HOURInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -683,7 +683,7 @@ public void testMINUTE_OF_HOURInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -697,7 +697,7 @@ public void testMONTHInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -707,7 +707,7 @@ public void testMONTHInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -717,7 +717,7 @@ public void testMONTHInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -731,7 +731,7 @@ public void testMONTH_OF_YEARInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -741,7 +741,7 @@ public void testMONTH_OF_YEARInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -751,7 +751,7 @@ public void testMONTH_OF_YEARInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -765,7 +765,7 @@ public void testMONTHNAMEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -776,7 +776,7 @@ public void testMONTHNAMEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -786,7 +786,7 @@ public void testMONTHNAMEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -801,7 +801,7 @@ public void testQUARTERInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -811,7 +811,7 @@ public void testQUARTERInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -821,7 +821,7 @@ public void testQUARTERInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -835,7 +835,7 @@ public void testSECONDInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -845,7 +845,7 @@ public void testSECONDInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -855,7 +855,7 @@ public void testSECONDInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -869,7 +869,7 @@ public void testSECOND_OF_MINUTEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -879,7 +879,7 @@ public void testSECOND_OF_MINUTEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -889,7 +889,7 @@ public void testSECOND_OF_MINUTEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -903,7 +903,7 @@ public void testTIME_TO_SECInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -913,7 +913,7 @@ public void testTIME_TO_SECInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -923,7 +923,7 @@ public void testTIME_TO_SECInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -937,7 +937,7 @@ public void testTIMESTAMPInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -947,7 +947,7 @@ public void testTIMESTAMPInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -957,7 +957,7 @@ public void testTIMESTAMPInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -967,7 +967,7 @@ public void testTIMESTAMPInvalid() { Throwable e4 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -977,7 +977,7 @@ public void testTIMESTAMPInvalid() { Throwable e5 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -987,7 +987,7 @@ public void testTIMESTAMPInvalid() { Throwable e6 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -997,7 +997,7 @@ public void testTIMESTAMPInvalid() { Throwable e7 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1007,7 +1007,7 @@ public void testTIMESTAMPInvalid() { Throwable e8 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1017,7 +1017,7 @@ public void testTIMESTAMPInvalid() { Throwable e9 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1032,7 +1032,7 @@ public void testTO_DAYSInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1042,7 +1042,7 @@ public void testTO_DAYSInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1052,7 +1052,7 @@ public void testTO_DAYSInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1066,7 +1066,7 @@ public void testYEARInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1076,7 +1076,7 @@ public void testYEARInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1086,7 +1086,7 @@ public void testYEARInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1100,7 +1100,7 @@ public void testWEEKInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1110,7 +1110,7 @@ public void testWEEKInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1120,7 +1120,7 @@ public void testWEEKInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1134,7 +1134,7 @@ public void testWEEK_OF_YEARInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1144,7 +1144,7 @@ public void testWEEK_OF_YEARInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1154,7 +1154,7 @@ public void testWEEK_OF_YEARInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1168,7 +1168,7 @@ public void testWEEKDAYInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1178,7 +1178,7 @@ public void testWEEKDAYInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1188,7 +1188,7 @@ public void testWEEKDAYInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1202,7 +1202,7 @@ public void testYEARWEEKInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1212,7 +1212,7 @@ public void testYEARWEEKInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1222,7 +1222,7 @@ public void testYEARWEEKInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1236,7 +1236,7 @@ public void testADDDATEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1246,7 +1246,7 @@ public void testADDDATEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1256,7 +1256,7 @@ public void testADDDATEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1267,7 +1267,7 @@ public void testADDDATEInvalid() { Throwable e4 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1277,7 +1277,7 @@ public void testADDDATEInvalid() { Throwable e5 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1287,7 +1287,7 @@ public void testADDDATEInvalid() { Throwable e6 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1301,7 +1301,7 @@ public void testADDTIMEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1311,7 +1311,7 @@ public void testADDTIMEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1321,7 +1321,7 @@ public void testADDTIMEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1336,7 +1336,7 @@ public void testDATE_ADDInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1346,7 +1346,7 @@ public void testDATE_ADDInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1356,7 +1356,7 @@ public void testDATE_ADDInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1371,7 +1371,7 @@ public void testDATE_SUBInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1381,7 +1381,7 @@ public void testDATE_SUBInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1391,7 +1391,7 @@ public void testDATE_SUBInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1406,7 +1406,7 @@ public void testDATEDIFFInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1416,7 +1416,7 @@ public void testDATEDIFFInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1426,7 +1426,7 @@ public void testDATEDIFFInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1441,7 +1441,7 @@ public void testSUBDATEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1451,7 +1451,7 @@ public void testSUBDATEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1461,7 +1461,7 @@ public void testSUBDATEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1472,7 +1472,7 @@ public void testSUBDATEInvalid() { Throwable e4 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1482,7 +1482,7 @@ public void testSUBDATEInvalid() { Throwable e5 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1492,7 +1492,7 @@ public void testSUBDATEInvalid() { Throwable e6 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1505,7 +1505,7 @@ public void testSUBDATEInvalid() { public void testSUBTIMEInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1515,7 +1515,7 @@ public void testSUBTIMEInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1525,7 +1525,7 @@ public void testSUBTIMEInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1540,7 +1540,7 @@ public void testTIMESTAMPADDInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1550,7 +1550,7 @@ public void testTIMESTAMPADDInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1560,7 +1560,7 @@ public void testTIMESTAMPADDInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1575,7 +1575,7 @@ public void testTIMESTAMPDIFFInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1586,7 +1586,7 @@ public void testTIMESTAMPDIFFInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1597,7 +1597,7 @@ public void testTIMESTAMPDIFFInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1612,7 +1612,7 @@ public void testDATE_FORMATInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1622,7 +1622,7 @@ public void testDATE_FORMATInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1632,7 +1632,7 @@ public void testDATE_FORMATInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1647,7 +1647,7 @@ public void testTIME_FORMATInvalid() { Throwable e1 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1657,7 +1657,7 @@ public void testTIME_FORMATInvalid() { Throwable e2 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -1667,7 +1667,7 @@ public void testTIME_FORMATInvalid() { Throwable e3 = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( diff --git a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinFunctionsNullIT.java b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinFunctionsNullIT.java index 30892e70e05..db15b3f7113 100644 --- a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinFunctionsNullIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLBuiltinFunctionsNullIT.java @@ -15,7 +15,7 @@ import org.json.JSONArray; import org.json.JSONObject; import org.junit.jupiter.api.Test; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.ppl.PPLIntegTestCase; public class CalcitePPLBuiltinFunctionsNullIT extends PPLIntegTestCase { @@ -353,17 +353,16 @@ public void testDateNull() throws IOException { @Test public void testDateInvalid() { - Throwable semanticException = + Throwable t = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( "source=%s | eval d1 = DATE('2020-08-26'), d2 = DATE('2020-15-26') |" + " fields d1, d2", TEST_INDEX_DATE_FORMATS_WITH_NULL))); - verifyErrorMessageContains( - semanticException, "date:2020-15-26 in unsupported format, please use 'yyyy-MM-dd'"); + verifyErrorMessageContains(t, "date:2020-15-26 in unsupported format, please use 'yyyy-MM-dd'"); } /** STRING/TIME/TIMESTAMP -> INTEGER */ @@ -380,24 +379,23 @@ public void testHourNull() throws IOException { @Test public void testHourInvalid() { - Throwable semanticException = + Throwable t = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( "source=%s | eval h1 = HOUR('2020-08-26') | fields h1", TEST_INDEX_DATE_FORMATS_WITH_NULL))); verifyErrorMessageContains( - semanticException, - "time:2020-08-26 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'"); + t, "time:2020-08-26 in unsupported format, please use 'HH:mm:ss[.SSSSSSSSS]'"); } @Test public void testDayInvalid() { Throwable malformMonthException = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -406,22 +404,22 @@ public void testDayInvalid() { verifyErrorMessageContains( malformMonthException, "date:2020-13-26 in unsupported format, please use 'yyyy-MM-dd'"); - Throwable dateAsTimeException = + Throwable timeAsDateException = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( "source=%s | eval d2 = DAY('12:00:00') | fields d2", TEST_INDEX_DATE_FORMATS_WITH_NULL))); verifyErrorMessageContains( - dateAsTimeException, "date:12:00:00 in unsupported format, please use 'yyyy-MM-dd'"); + timeAsDateException, "date:12:00:00 in unsupported format, please use 'yyyy-MM-dd'"); } @Test public void testTimeInvalid() { assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( diff --git a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java index 4385548c719..7c21932d819 100644 --- a/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java +++ b/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLCastFunctionIT.java @@ -20,7 +20,7 @@ import org.json.JSONObject; import org.junit.Test; import org.opensearch.sql.common.antlr.SyntaxCheckException; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.ppl.PPLIntegTestCase; public class CalcitePPLCastFunctionIT extends PPLIntegTestCase { @@ -431,7 +431,7 @@ public void testCastDate() throws IOException { Throwable t = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -469,7 +469,7 @@ public void testCastTime() throws IOException { Throwable t = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( @@ -509,7 +509,7 @@ public void testCastTimestamp() throws IOException { Throwable t = assertThrowsWithReplace( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> executeQuery( String.format( diff --git a/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/LuceneQueryTest.java b/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/LuceneQueryTest.java index 1713d1dd1b4..b5bbb180cff 100644 --- a/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/LuceneQueryTest.java +++ b/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/LuceneQueryTest.java @@ -14,7 +14,7 @@ import org.junit.jupiter.api.DisplayNameGeneration; import org.junit.jupiter.api.DisplayNameGenerator; import org.junit.jupiter.api.Test; -import org.opensearch.sql.exception.SemanticCheckException; +import org.opensearch.sql.exception.ExpressionEvaluationException; import org.opensearch.sql.expression.DSL; import org.opensearch.sql.opensearch.data.type.OpenSearchDateType; @@ -94,7 +94,7 @@ void should_cast_to_timestamp_with_no_format() { String format = "2021/11/08T17:00:00Z"; OpenSearchDateType dateType = OpenSearchDateType.of(format); assertThrows( - SemanticCheckException.class, + ExpressionEvaluationException.class, () -> new LuceneQuery() {}.build( DSL.equal(