sfc-gh-aixu commented on code in PR #13195:
URL: https://github.com/apache/iceberg/pull/13195#discussion_r2187649348
##########
core/src/test/java/org/apache/iceberg/expressions/TestInclusiveMetricsEvaluatorWithExtract.java:
##########
@@ -683,4 +787,783 @@ public void testIntegerNotIn() {
.as("Should read: id above upper bound (85 > 79, 86 > 79)")
.isTrue();
}
+
+ private static Stream<Arguments> timestampLtParameters() {
+ return Stream.of(
+ Arguments.of(
+ "$.event_timestamp_nano_long",
+ Types.TimestampNanoType.withZone().toString(),
+ L_TS_NANO_MIN_VALUE_MINUS_10,
+ TS_NANO_MIN_VALUE,
+ TS_NANO_MAX_VALUE,
+ "$.event_timestamp_nano_ts_type",
+ TS_COMMON_MIN_VALUE_MINUS_10.toString(),
+ TS_COMMON_MIN_VALUE.toString(),
+ TS_COMMON_MAX_VALUE.toString()),
+ Arguments.of(
+ "$.event_timestamp_long",
+ Types.TimestampType.withZone().toString(),
+ L_TS_MIN_VALUE_MINUS_10,
+ TS_MIN_VALUE,
+ TS_MAX_VALUE,
+ "$.event_timestamp_ts_type",
+ TS_COMMON_MIN_VALUE_MINUS_10.toString(),
+ TS_COMMON_MIN_VALUE.toString(),
+ TS_COMMON_MAX_VALUE.toString()),
+ Arguments.of(
+ "$.event_time_long",
+ Types.TimeType.get().toString(),
+ L_TIME_MIN_VALUE_MINUS_10,
+ TIME_MIN_VALUE,
+ TIME_MAX_VALUE,
+ "$.event_time_ts_type",
+ T_TIME_MIN_VALUE_MINUS_10,
+ T_TIME_MIN_VALUE,
+ T_TIME_MAX_VALUE));
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampLtParameters")
+ public void testTimestampLt(
+ String columnNameInLong,
+ String timestampType,
+ long minValueMinus10,
+ long minValue,
+ long maxValue,
+ String columnNameInTSType,
+ String minValueMinus10Str,
+ String minValueStr,
+ String maxValueStr) {
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract("variant", columnNameInLong, "long"),
+ minValueMinus10)))
+ .as("Should not read: timestamp range below lower bound (20 < 30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract("variant", columnNameInLong, "long"), minValue)))
+ .as("Should not read: timestamp range below lower bound (30 is not <
30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract("variant", columnNameInLong, "long"), maxValue)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should not read: timestamp range below lower bound (20 < 30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueStr)))
+ .as("Should not read: timestamp range below lower bound (30 is not <
30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should not read: timestamp range below lower bound (20 < 30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueStr)))
+ .as("Should not read: timestamp range below lower bound (30 is not <
30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampLtParameters")
+ public void testTimestampLtEq(
+ String columnNameInLong,
+ String timestampType,
+ long minValueMinus10,
+ long minValue,
+ long maxValue,
+ String columnNameInTSType,
+ String minValueMinus10Str,
+ String minValueStr,
+ String maxValueStr) {
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(extract("variant", columnNameInLong, "long"),
minValueMinus10)))
+ .as("Should not read: timestamp range below lower bound (20 > 30)")
+ .isFalse();
+ assertThat(shouldRead(lessThanOrEqual(extract("variant", columnNameInLong,
"long"), minValue)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(shouldRead(lessThanOrEqual(extract("variant", columnNameInLong,
"long"), maxValue)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(
+ extract("variant", columnNameInLong, timestampType),
minValueMinus10Str)))
+ .as("Should not read: timestamp range below lower bound (20 > 30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(extract("variant", columnNameInLong,
timestampType), minValueStr)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(extract("variant", columnNameInLong,
timestampType), maxValueStr)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(
+ extract("variant", columnNameInTSType, timestampType),
minValueMinus10Str)))
+ .as("Should not read: timestamp range below lower bound (20 > 30)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(
+ extract("variant", columnNameInTSType, timestampType),
minValueStr)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ lessThanOrEqual(
+ extract("variant", columnNameInTSType, timestampType),
maxValueStr)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ }
+
+ private static Stream<Arguments> timestampGtParameters() {
+ return Stream.of(
+ Arguments.of(
+ "$.event_timestamp_nano_long",
+ Types.TimestampNanoType.withZone().toString(),
+ L_TS_NANO_MAX_VALUE_PLUS_10,
+ TS_NANO_MAX_VALUE,
+ L_TS_NANO_MAX_VALUE_MINUS_10,
+ "$.event_timestamp_nano_ts_type",
+ TS_COMMON_MAX_VALUE_PLUS_10.toString(),
+ TS_COMMON_MAX_VALUE.toString(),
+ TS_COMMON_MAX_VALUE_MINUS_10.toString()),
+ Arguments.of(
+ "$.event_timestamp_long",
+ Types.TimestampType.withZone().toString(),
+ L_TS_MAX_VALUE_PLUS_10,
+ TS_MAX_VALUE,
+ L_TS_MAX_VALUE_MINUS_10,
+ "$.event_timestamp_ts_type",
+ TS_COMMON_MAX_VALUE_PLUS_10.toString(),
+ TS_COMMON_MAX_VALUE.toString(),
+ TS_COMMON_MAX_VALUE_MINUS_10.toString()),
+ Arguments.of(
+ "$.event_time_long",
+ Types.TimeType.get().toString(),
+ L_TIME_MAX_VALUE_PLUS_10,
+ TIME_MAX_VALUE,
+ L_TIME_MAX_VALUE_MINUS_10,
+ "$.event_time_ts_type",
+ T_TIME_MAX_VALUE_PLUS_10,
+ T_TIME_MAX_VALUE,
+ T_TIME_MAX_VALUE_MINUS_10));
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampGtParameters")
+ public void testTimestampGt(
+ String columnNameInLong,
+ String timestampType,
+ long maxValuePlus10,
+ long maxValue,
+ long maxValueMinus10,
+ String columnNameInTSType,
+ String maxValuePlus10Str,
+ String maxValueStr,
+ String maxValueMinus10Str) {
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract("variant", columnNameInLong, "long"),
+ maxValuePlus10)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract("variant", columnNameInLong, "long"), maxValue)))
+ .as("Should not read: range above upper bound (79 is not > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract("variant", columnNameInLong, "long"),
+ maxValueMinus10)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueStr)))
+ .as("Should not read: timestamp range above upper bound (79 is not >
79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueStr)))
+ .as("Should not read: timestamp range above upper bound (79 is not >
79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThan(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampGtParameters")
+ public void testTimestampGtEq(
+ String columnNameInLong,
+ String timestampType,
+ long maxValuePlus10,
+ long maxValue,
+ long maxValueMinus10,
+ String columnNameInTSType,
+ String maxValuePlus10Str,
+ String maxValueStr,
+ String maxValueMinus10Str) {
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract("variant", columnNameInLong, "long"),
+ maxValuePlus10)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract("variant", columnNameInLong, "long"), maxValue)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract("variant", columnNameInLong, "long"),
+ maxValueMinus10)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should not read: timestamp range above upper bound (89 > 79)")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: one possible timestamp")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ greaterThanOrEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ }
+
+ private static Stream<Arguments> timestampEqParameters() {
+ return Stream.of(
+ Arguments.of(
+ "$.event_timestamp_nano_long",
+ Types.TimestampNanoType.withZone().toString(),
+ L_TS_NANO_MIN_VALUE_MINUS_10,
+ TS_NANO_MIN_VALUE,
+ L_TS_NANO_MAX_VALUE_PLUS_10,
+ L_TS_NANO_MAX_VALUE_MINUS_10,
+ TS_NANO_MAX_VALUE,
+ "$.event_timestamp_nano_ts_type",
+ TS_COMMON_MIN_VALUE_MINUS_10.toString(),
+ TS_COMMON_MIN_VALUE.toString(),
+ TS_COMMON_MAX_VALUE_PLUS_10.toString(),
+ TS_COMMON_MAX_VALUE_MINUS_10.toString(),
+ TS_COMMON_MAX_VALUE.toString()),
+ Arguments.of(
+ "$.event_timestamp_long",
+ Types.TimestampType.withZone().toString(),
+ L_TS_MIN_VALUE_MINUS_10,
+ TS_MIN_VALUE,
+ L_TS_MAX_VALUE_PLUS_10,
+ L_TS_MAX_VALUE_MINUS_10,
+ TS_MAX_VALUE,
+ "$.event_timestamp_ts_type",
+ TS_COMMON_MIN_VALUE_MINUS_10.toString(),
+ TS_COMMON_MIN_VALUE.toString(),
+ TS_COMMON_MAX_VALUE_PLUS_10.toString(),
+ TS_COMMON_MAX_VALUE_MINUS_10.toString(),
+ TS_COMMON_MAX_VALUE.toString()),
+ Arguments.of(
+ "$.event_time_long",
+ Types.TimeType.get().toString(),
+ L_TIME_MIN_VALUE_MINUS_10,
+ TIME_MIN_VALUE,
+ L_TIME_MAX_VALUE_PLUS_10,
+ L_TIME_MAX_VALUE_MINUS_10,
+ TIME_MAX_VALUE,
+ "$.event_time_ts_type",
+ T_TIME_MIN_VALUE_MINUS_10,
+ T_TIME_MIN_VALUE,
+ T_TIME_MAX_VALUE_PLUS_10,
+ T_TIME_MAX_VALUE_MINUS_10,
+ T_TIME_MAX_VALUE));
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampEqParameters")
+ public void testTimestampEq(
+ String columnNameInLong,
+ String timestampType,
+ long minValueMinus10,
+ long minValue,
+ long maxValuePlus10,
+ long maxValueMinus10,
+ long maxValue,
+ String columnNameInTSType,
+ String minValueMinus10Str,
+ String minValueStr,
+ String maxValuePlus10Str,
+ String maxValueMinus10Str,
+ String maxValueStr
+ ) {
+ assertThat(
+ shouldRead(
+ equal(
+ extract("variant", columnNameInLong, "long"),
+ minValueMinus10)))
+ .as("Should not read: timestamp below lower bound")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract("variant", columnNameInLong, "long"), minValue)))
+ .as("Should read: timestamp equal to lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract("variant", columnNameInLong, "long"),
+ maxValuePlus10)))
+ .as("Should not read: timestamp above upper bound")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract("variant", columnNameInLong, "long"),
+ maxValueMinus10)))
+ .as("Should read: timestamp below lower and upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract("variant", columnNameInLong, "long"), maxValue)))
+ .as("Should read: timestamp equal to lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should not read: timestamp below lower bound")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueStr)))
+ .as("Should read: timestamp equal to lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should not read: timestamp above upper bound")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: timestamp between lower and upper bounds")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: timestamp equal to upper bound")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should not read: timestamp range above upper bound")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueStr)))
+ .as("Should read: timestamp equal to upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should read: many possible timestamps")
+ .isFalse();
+ assertThat(
+ shouldRead(
+ equal(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: many possible timestamps")
+ .isTrue();
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampEqParameters")
+ public void testTimestampNotEq(
+ String columnNameInLong,
+ String timestampType,
+ long minValueMinus10,
+ long minValue,
+ long maxValuePlus10,
+ long maxValueMinus10,
+ long maxValue,
+ String columnNameInTSType,
+ String minValueMinus10Str,
+ String minValueStr,
+ String maxValuePlus10Str,
+ String maxValueMinus10Str,
+ String maxValueStr
+ ) {
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract("variant", columnNameInLong, "long"),
+ minValueMinus10)))
+ .as("Should read: timestamp below lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract("variant", columnNameInLong, "long"), minValue)))
+ .as("Should read: timestamp equal to lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract("variant", columnNameInLong, "long"),
+ maxValuePlus10)))
+ .as("Should read: timestamp above upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract("variant", columnNameInLong, "long"),
+ maxValueMinus10)))
+ .as("Should read: timestamp between lower and upper bounds")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract("variant", columnNameInLong, "long"), maxValue)))
+ .as("Should read: timestamp equal to upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should read: timestamp below lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ minValueStr)))
+ .as("Should read: timestamp equal to lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should read: timestamp above upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: timestamp between lower and upper bounds")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInLong,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: timestamp equal to upper bound")
+ .isTrue();
+
+ // Timestamp as timestamp datatype
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueMinus10Str)))
+ .as("Should read: timestamp range below lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ minValueStr)))
+ .as("Should read: timestamp range below lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueMinus10Str)))
+ .as("Should read: timestamp range below lower bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValuePlus10Str)))
+ .as("Should read: timestamp equal to upper bound")
+ .isTrue();
+ assertThat(
+ shouldRead(
+ notEqual(
+ extract(
+ "variant",
+ columnNameInTSType,
+ timestampType),
+ maxValueStr)))
+ .as("Should read: timestamp between lower and upper bounds")
+ .isTrue();
+ }
+
+ @Test
+ public void testUUIDEq() {
Review Comment:
Do we need to have coverage for NotEq and others like out of the range
tests?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For additional commands, e-mail: issues-h...@iceberg.apache.org
