wgtmac commented on code in PR #206:
URL: https://github.com/apache/iceberg-cpp/pull/206#discussion_r2338566036
##########
test/literal_test.cc:
##########
@@ -227,6 +290,120 @@ TEST(LiteralTest, StringComparison) {
EXPECT_EQ(string2 <=> string1, std::partial_ordering::greater);
}
+TEST(LiteralTest, StringCastToDate) {
+ // Test standard date format
+ auto literal1 = Literal::String("2023-05-15");
+ auto result1 = literal1.CastTo(iceberg::date());
+ ASSERT_THAT(result1, IsOk());
+ EXPECT_EQ(result1->type()->type_id(), TypeId::kDate);
+ EXPECT_EQ(result1->ToString(), "19492");
+
+ // Test epoch
+ auto literal_epoch = Literal::String("1970-01-01");
+ auto result_epoch = literal_epoch.CastTo(iceberg::date());
+ ASSERT_THAT(result_epoch, IsOk());
+ EXPECT_EQ(result_epoch->ToString(), "0");
+
+ // Test pre-epoch
+ auto literal_pre_epoch = Literal::String("1969-12-31");
+ auto result_pre_epoch = literal_pre_epoch.CastTo(iceberg::date());
+ ASSERT_THAT(result_pre_epoch, IsOk());
+ EXPECT_EQ(result_pre_epoch->ToString(), "-1");
+
+ // Invalid Formats
+ auto invalid1 = Literal::String("2023/05/15");
+ EXPECT_THAT(invalid1.CastTo(iceberg::date()),
IsError(ErrorKind::kNotSupported));
+
+ auto invalid2 = Literal::String("2023-05-15 extra");
+ EXPECT_THAT(invalid2.CastTo(iceberg::date()),
IsError(ErrorKind::kNotSupported));
+
+ auto invalid3 = Literal::String("2023-05");
+ EXPECT_THAT(invalid3.CastTo(iceberg::date()),
IsError(ErrorKind::kNotSupported));
+}
+
+TEST(LiteralTest, StringCastToTime) {
+ // Test without fractional part
+ auto literal1 = Literal::String("12:00:00");
+ auto result1 = literal1.CastTo(iceberg::time());
+ ASSERT_THAT(result1, IsOk());
+ EXPECT_EQ(result1->type()->type_id(), TypeId::kTime);
+ EXPECT_EQ(result1->ToString(), "43200000000"); // 12h in microseconds
+
+ // Test with full fractional part
+ auto literal2 = Literal::String("12:34:56.123456");
+ auto result2 = literal2.CastTo(iceberg::time());
+ ASSERT_THAT(result2, IsOk());
+ EXPECT_EQ(result2->ToString(), "45296123456");
+
+ // Test with fractional part that needs padding
+ auto literal3 = Literal::String("01:02:03.123");
+ auto result3 = literal3.CastTo(iceberg::time());
+ ASSERT_THAT(result3, IsOk());
+ EXPECT_EQ(result3->ToString(), "3723123000"); // .123 becomes .123000
+
+ // Test with fractional part that needs truncation
+ auto literal4 = Literal::String("23:59:59.987654321");
+ auto result4 = literal4.CastTo(iceberg::time());
+ ASSERT_THAT(result4, IsOk());
+ EXPECT_EQ(result4->ToString(), "86399987654");
+
+ // Invalid Formats
+ auto invalid1 = Literal::String("12-00-00");
+ EXPECT_THAT(invalid1.CastTo(iceberg::time()),
IsError(ErrorKind::kNotSupported));
+
+ auto invalid2 = Literal::String("12:00:00 extra");
+ EXPECT_THAT(invalid2.CastTo(iceberg::time()),
IsError(ErrorKind::kNotSupported));
+
+ auto invalid3 = Literal::String("25:00:00");
+ EXPECT_THAT(invalid3.CastTo(iceberg::time()),
IsError(ErrorKind::kNotSupported));
+}
+
+TEST(LiteralTest, StringCastToTimestamp) {
+ // Test without fractional part
+ auto literal1 = Literal::String("2023-05-15T12:00:00");
+ auto result1 = literal1.CastTo(iceberg::timestamp());
+ ASSERT_THAT(result1, IsOk());
+ EXPECT_EQ(result1->type()->type_id(), TypeId::kTimestamp);
+ EXPECT_EQ(result1->ToString(), "1684152000000000");
+
+ // Test with full fractional part
+ auto literal2 = Literal::String("2023-05-15T12:34:56.123456");
+ auto result2 = literal2.CastTo(iceberg::timestamp());
+ ASSERT_THAT(result2, IsOk());
+ EXPECT_EQ(result2->ToString(), "1684154096123456");
+
+ // Invalid Formats
+ auto invalid1 = Literal::String("2023-05-15 12:00:00");
Review Comment:
Why this is an invalid format?
##########
test/literal_test.cc:
##########
@@ -92,6 +92,12 @@ TEST(LiteralTest, IntCastTo) {
auto double_result = int_literal.CastTo(iceberg::float64());
ASSERT_THAT(double_result, IsOk());
EXPECT_EQ(double_result->type()->type_id(), TypeId::kDouble);
+
+ // Cast to Date
+ auto date_result = int_literal.CastTo(iceberg::date());
Review Comment:
These four lines are repeated for a lot of times. Can we add a function or
macro?
##########
test/literal_test.cc:
##########
@@ -254,6 +431,214 @@ TEST(LiteralTest, BinaryComparison) {
EXPECT_EQ(binary2 <=> binary1, std::partial_ordering::greater);
}
+// Fixed type tests
+TEST(LiteralTest, FixedBasics) {
+ std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0xFF};
+ auto fixed_literal = Literal::Fixed(data);
+ auto empty_fixed = Literal::Fixed({});
+
+ EXPECT_EQ(fixed_literal.type()->type_id(), TypeId::kFixed);
+ EXPECT_EQ(empty_fixed.type()->type_id(), TypeId::kFixed);
+
+ EXPECT_EQ(fixed_literal.ToString(), "X'010203FF'");
+ EXPECT_EQ(empty_fixed.ToString(), "X''");
+}
+
+TEST(LiteralTest, FixedComparison) {
+ std::vector<uint8_t> data1 = {0x01, 0x02};
+ std::vector<uint8_t> data2 = {0x01, 0x03};
+ std::vector<uint8_t> data3 = {0x01, 0x02};
+
+ auto fixed1 = Literal::Fixed(data1);
+ auto fixed2 = Literal::Fixed(data2);
+ auto fixed3 = Literal::Fixed(data3);
+
+ EXPECT_EQ(fixed1 <=> fixed3, std::partial_ordering::equivalent);
+ EXPECT_EQ(fixed1 <=> fixed2, std::partial_ordering::less);
+ EXPECT_EQ(fixed2 <=> fixed1, std::partial_ordering::greater);
+}
+
+// Date type tests
+TEST(LiteralTest, DateBasics) {
+ auto date_literal = Literal::Date(19489); // May 15, 2023
+ auto negative_date = Literal::Date(-1); // December 31, 1969
+
+ EXPECT_EQ(date_literal.type()->type_id(), TypeId::kDate);
+ EXPECT_EQ(negative_date.type()->type_id(), TypeId::kDate);
+
+ EXPECT_EQ(date_literal.ToString(), "19489");
Review Comment:
Shouldn't we print it as a human readable date time string? What does the
Java impl do?
##########
test/literal_test.cc:
##########
@@ -254,6 +431,214 @@ TEST(LiteralTest, BinaryComparison) {
EXPECT_EQ(binary2 <=> binary1, std::partial_ordering::greater);
}
+// Fixed type tests
+TEST(LiteralTest, FixedBasics) {
+ std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0xFF};
+ auto fixed_literal = Literal::Fixed(data);
+ auto empty_fixed = Literal::Fixed({});
+
+ EXPECT_EQ(fixed_literal.type()->type_id(), TypeId::kFixed);
+ EXPECT_EQ(empty_fixed.type()->type_id(), TypeId::kFixed);
+
+ EXPECT_EQ(fixed_literal.ToString(), "X'010203FF'");
+ EXPECT_EQ(empty_fixed.ToString(), "X''");
+}
+
+TEST(LiteralTest, FixedComparison) {
+ std::vector<uint8_t> data1 = {0x01, 0x02};
+ std::vector<uint8_t> data2 = {0x01, 0x03};
+ std::vector<uint8_t> data3 = {0x01, 0x02};
+
+ auto fixed1 = Literal::Fixed(data1);
+ auto fixed2 = Literal::Fixed(data2);
+ auto fixed3 = Literal::Fixed(data3);
+
+ EXPECT_EQ(fixed1 <=> fixed3, std::partial_ordering::equivalent);
+ EXPECT_EQ(fixed1 <=> fixed2, std::partial_ordering::less);
+ EXPECT_EQ(fixed2 <=> fixed1, std::partial_ordering::greater);
+}
+
+// Date type tests
+TEST(LiteralTest, DateBasics) {
+ auto date_literal = Literal::Date(19489); // May 15, 2023
+ auto negative_date = Literal::Date(-1); // December 31, 1969
+
+ EXPECT_EQ(date_literal.type()->type_id(), TypeId::kDate);
+ EXPECT_EQ(negative_date.type()->type_id(), TypeId::kDate);
+
+ EXPECT_EQ(date_literal.ToString(), "19489");
+ EXPECT_EQ(negative_date.ToString(), "-1");
+}
+
+TEST(LiteralTest, DateComparison) {
+ auto date1 = Literal::Date(100);
+ auto date2 = Literal::Date(200);
+ auto date3 = Literal::Date(100);
+
+ EXPECT_EQ(date1 <=> date3, std::partial_ordering::equivalent);
+ EXPECT_EQ(date1 <=> date2, std::partial_ordering::less);
+ EXPECT_EQ(date2 <=> date1, std::partial_ordering::greater);
+}
+
+// Time type tests
+TEST(LiteralTest, TimeBasics) {
+ auto time_literal = Literal::Time(43200000000LL); // 12:00:00 in
microseconds
+ auto midnight = Literal::Time(0LL);
+
+ EXPECT_EQ(time_literal.type()->type_id(), TypeId::kTime);
+ EXPECT_EQ(midnight.type()->type_id(), TypeId::kTime);
+
+ EXPECT_EQ(time_literal.ToString(), "43200000000");
+ EXPECT_EQ(midnight.ToString(), "0");
+}
+
+TEST(LiteralTest, TimeComparison) {
+ auto time1 = Literal::Time(43200000000LL); // 12:00:00
+ auto time2 = Literal::Time(86400000000LL); // 24:00:00 (invalid but for
testing)
+ auto time3 = Literal::Time(43200000000LL);
+
+ EXPECT_EQ(time1 <=> time3, std::partial_ordering::equivalent);
+ EXPECT_EQ(time1 <=> time2, std::partial_ordering::less);
+ EXPECT_EQ(time2 <=> time1, std::partial_ordering::greater);
+}
+
+// Timestamp type tests
+TEST(LiteralTest, TimestampBasics) {
+ auto timestamp_literal =
+ Literal::Timestamp(1684137600000000LL); // May 15, 2023 12:00:00 UTC
+ auto epoch = Literal::Timestamp(0LL);
+
+ EXPECT_EQ(timestamp_literal.type()->type_id(), TypeId::kTimestamp);
+ EXPECT_EQ(epoch.type()->type_id(), TypeId::kTimestamp);
+
+ EXPECT_EQ(timestamp_literal.ToString(), "1684137600000000");
+ EXPECT_EQ(epoch.ToString(), "0");
+}
+
+TEST(LiteralTest, TimestampComparison) {
+ auto timestamp1 = Literal::Timestamp(1000000LL);
+ auto timestamp2 = Literal::Timestamp(2000000LL);
+ auto timestamp3 = Literal::Timestamp(1000000LL);
+
+ EXPECT_EQ(timestamp1 <=> timestamp3, std::partial_ordering::equivalent);
+ EXPECT_EQ(timestamp1 <=> timestamp2, std::partial_ordering::less);
+ EXPECT_EQ(timestamp2 <=> timestamp1, std::partial_ordering::greater);
+}
+
+TEST(LiteralTest, TimestampCastTo) {
+ auto timestamp_literal =
+ Literal::Timestamp(1684137600000000LL); // May 15, 2023 12:00:00 UTC
+
+ // Cast to Date
+ auto date_result = timestamp_literal.CastTo(iceberg::date());
+ ASSERT_THAT(date_result, IsOk());
+ EXPECT_EQ(date_result->type()->type_id(), TypeId::kDate);
+
+ // Cast to TimestampTz
+ auto timestamptz_result = timestamp_literal.CastTo(iceberg::timestamp_tz());
+ ASSERT_THAT(timestamptz_result, IsOk());
+ EXPECT_EQ(timestamptz_result->type()->type_id(), TypeId::kTimestampTz);
+ EXPECT_EQ(timestamptz_result->ToString(), "1684137600000000");
+}
+
+// TimestampTz type tests
+TEST(LiteralTest, TimestampTzBasics) {
+ auto timestamptz_literal =
+ Literal::TimestampTz(1684137600000000LL); // May 15, 2023 12:00:00 UTC
+ auto epoch = Literal::TimestampTz(0LL);
+
+ EXPECT_EQ(timestamptz_literal.type()->type_id(), TypeId::kTimestampTz);
+ EXPECT_EQ(epoch.type()->type_id(), TypeId::kTimestampTz);
+
+ EXPECT_EQ(timestamptz_literal.ToString(), "1684137600000000");
+ EXPECT_EQ(epoch.ToString(), "0");
+}
+
+TEST(LiteralTest, TimestampTzComparison) {
+ auto timestamptz1 = Literal::TimestampTz(1000000LL);
+ auto timestamptz2 = Literal::TimestampTz(2000000LL);
+ auto timestamptz3 = Literal::TimestampTz(1000000LL);
+
+ EXPECT_EQ(timestamptz1 <=> timestamptz3, std::partial_ordering::equivalent);
+ EXPECT_EQ(timestamptz1 <=> timestamptz2, std::partial_ordering::less);
+ EXPECT_EQ(timestamptz2 <=> timestamptz1, std::partial_ordering::greater);
+}
+
+TEST(LiteralTest, TimestampTzCastTo) {
+ auto timestamptz_literal =
+ Literal::TimestampTz(1684137600000000LL); // May 15, 2023 12:00:00 UTC
+
+ // Cast to Date
+ auto date_result = timestamptz_literal.CastTo(iceberg::date());
+ ASSERT_THAT(date_result, IsOk());
+ EXPECT_EQ(date_result->type()->type_id(), TypeId::kDate);
+
+ // Cast to Timestamp
+ auto timestamp_result = timestamptz_literal.CastTo(iceberg::timestamp());
+ ASSERT_THAT(timestamp_result, IsOk());
+ EXPECT_EQ(timestamp_result->type()->type_id(), TypeId::kTimestamp);
+ EXPECT_EQ(timestamp_result->ToString(), "1684137600000000");
+}
+
+// Binary to Fixed casting tests
+TEST(LiteralTest, BinaryCastTo) {
+ std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
+ auto binary_literal = Literal::Binary(data4);
+
+ // Cast to Fixed with matching length
+ auto fixed_result = binary_literal.CastTo(iceberg::fixed(4));
+ ASSERT_THAT(fixed_result, IsOk());
+ EXPECT_EQ(fixed_result->type()->type_id(), TypeId::kFixed);
+
+ // Cast to Fixed with different length should fail
+ auto fixed_result_wrong_length = binary_literal.CastTo(iceberg::fixed(5));
+ EXPECT_THAT(fixed_result_wrong_length, IsError(ErrorKind::kNotSupported));
+}
+
+// Fixed to Binary and Fixed casting tests
+TEST(LiteralTest, FixedCastTo) {
+ std::vector<uint8_t> data4 = {0x01, 0x02, 0x03, 0x04};
+ auto fixed_literal = Literal::Fixed(data4);
+
+ // Cast to Binary
+ auto binary_result = fixed_literal.CastTo(iceberg::binary());
+ ASSERT_THAT(binary_result, IsOk());
+ EXPECT_EQ(binary_result->type()->type_id(), TypeId::kBinary);
+
+ // Cast to Fixed with same length (should return same literal)
+ auto same_fixed_result = fixed_literal.CastTo(iceberg::fixed(4));
+ ASSERT_THAT(same_fixed_result, IsOk());
+ EXPECT_EQ(same_fixed_result->type()->type_id(), TypeId::kFixed);
+
+ // Cast to Fixed with different length should fail
+ auto different_fixed_result = fixed_literal.CastTo(iceberg::fixed(5));
+ EXPECT_THAT(different_fixed_result, IsError(ErrorKind::kNotSupported));
+}
+
+// Microseconds to Days conversion tests
+TEST(LiteralTest, MicrosToDaysConversion) {
Review Comment:
Can we try to refactor these cases to use parameterized test pattern?
--
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: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
