feat: Implement Type Casting and toString for Literals #206

HeartLinked · 2025-09-03T09:10:46Z

Implements the complete type casting logic for iceberg::Literal in the LiteralCaster class to align with the Java reference implementation. This is critical for expression evaluation and predicate pushdown.
Add basic implementation for fixed type.
Updated ToString() to match Java's output format for better consistency (e.g., X'...' for binary).
Added comprehensive unit tests to validate all new casting logic and ToString() formatting.

src/iceberg/expression/literal.cc

src/iceberg/expression/literal.h

src/iceberg/expression/literal.cc

test/literal_test.cc

src/iceberg/expression/literal.cc

test/literal_test.cc

src/iceberg/expression/literal.cc

src/iceberg/expression/literal.h

test/literal_test.cc

wgtmac · 2025-09-12T03:51:58Z

src/iceberg/expression/literal.cc

+      result.reserve(2 + binary_data.size() * 2 +
+                     1);  // 2 chars per byte and 2 + 1 for prefix and suffix


Suggested change

result.reserve(2 + binary_data.size() * 2 +

1); // 2 chars per byte and 2 + 1 for prefix and suffix

result.reserve(/*prefix*/2 + binary_data.size() * 2 + /*suffix*/1);

wgtmac · 2025-09-22T08:53:53Z

src/iceberg/expression/literal.h

+
+  /// \brief Factory methods for decimal type
+  static Literal Decimal(const Decimal& value, int32_t precision, int32_t scale);
+  static Literal Decimal(int128_t value, int32_t precision, int32_t scale);


Suggested change

/// \brief Factory methods for decimal type

static Literal Decimal(const Decimal& value, int32_t precision, int32_t scale);

static Literal Decimal(int128_t value, int32_t precision, int32_t scale);

static Literal Decimal(int128_t value, int32_t precision, int32_t scale);

Decimal type is also a primitive type so let's put them together without blank line.

I think int128_t is enough and it duplicates with Decimal

wgtmac · 2025-09-22T08:55:32Z

src/iceberg/expression/literal.cc

+    case TypeId::kDate:
+      return Literal::Date(int_val);
+    case TypeId::kDecimal: {
+      auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);


Suggested change

auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);

auto decimal_type = internal::checked_pointer_cast<DecimalType>(target_type);

wgtmac · 2025-09-22T08:58:31Z

src/iceberg/expression/literal.cc

    case TypeId::kDouble:
      return Literal::Double(static_cast<double>(float_val));
+    case TypeId::kDecimal: {
+      auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);


wgtmac · 2025-09-22T08:59:36Z

src/iceberg/expression/literal.cc

+    case TypeId::kTimestampTz:
+      return Literal::TimestampTz(long_val);
+    case TypeId::kDecimal: {
+      auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);


Suggested change

auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);

auto decimal_type = internal::checked_pointer_cast<DecimalType>(target_type);

wgtmac · 2025-09-22T09:33:00Z

src/iceberg/expression/literal.cc

+      iceberg::Decimal parsed_val;
+      int32_t parsed_scale = 0;
+      ICEBERG_ASSIGN_OR_RAISE(
+          parsed_val, iceberg::Decimal::FromString(double_str, nullptr, &parsed_scale));
+      iceberg::Decimal rescaled_val;
+      ICEBERG_ASSIGN_OR_RAISE(rescaled_val,
+                              parsed_val.Rescale(parsed_scale, decimal_type->scale()));


Suggested change

iceberg::Decimal parsed_val;

int32_t parsed_scale = 0;

ICEBERG_ASSIGN_OR_RAISE(

parsed_val, iceberg::Decimal::FromString(double_str, nullptr, &parsed_scale));

iceberg::Decimal rescaled_val;

ICEBERG_ASSIGN_OR_RAISE(rescaled_val,

parsed_val.Rescale(parsed_scale, decimal_type->scale()));

int32_t parsed_scale = 0;

ICEBERG_ASSIGN_OR_RAISE(

auto parsed_val, iceberg::Decimal::FromString(double_str, /*precision=*/nullptr, &parsed_scale));

iceberg::Decimal rescaled_val;

ICEBERG_ASSIGN_OR_RAISE(rescaled_val,

parsed_val.Rescale(parsed_scale, decimal_type->scale()));

wgtmac · 2025-09-22T09:33:16Z

src/iceberg/expression/literal.cc

+      iceberg::Decimal dec_val;
+      ICEBERG_ASSIGN_OR_RAISE(dec_val, iceberg::Decimal::FromString(str_val));


Suggested change

iceberg::Decimal dec_val;

ICEBERG_ASSIGN_OR_RAISE(dec_val, iceberg::Decimal::FromString(str_val));

ICEBERG_ASSIGN_OR_RAISE(auto dec_val, iceberg::Decimal::FromString(str_val));

wgtmac · 2025-09-22T09:34:17Z

src/iceberg/expression/literal.cc

+  auto binary_val = std::get<std::vector<uint8_t>>(literal.value_);
+  switch (target_type->type_id()) {
+    case TypeId::kFixed: {
+      auto target_fixed_type = std::static_pointer_cast<FixedType>(target_type);


Suggested change

auto target_fixed_type = std::static_pointer_cast<FixedType>(target_type);

auto target_fixed_type = internal::checked_pointer_cast<FixedType>(target_type);

wgtmac · 2025-09-22T09:39:53Z

src/iceberg/expression/literal.cc

+  auto unsupported_error = [this]() {
+    return std::format("ToString not supported for type: {}", type_->ToString());
+  };
+  auto invalid_argument = [this]() {
+    return std::format("Invalid argument for type: {}", type_->ToString());
+  };


Suggested change

auto unsupported_error = [this]() {

return std::format("ToString not supported for type: {}", type_->ToString());

};

auto invalid_argument = [this]() {

return std::format("Invalid argument for type: {}", type_->ToString());

};

auto invalid_literal = [this]() {

return std::format("Invalid literal of type: {}", type_->ToString());

};

This function will be called in printing an expression so it is better to print a consistent short message.

wgtmac · 2025-09-22T09:48:17Z

src/iceberg/expression/literal.cc

+      if (str_res.has_value()) {
+        return str_res.value();
+      }
+      return invalid_argument();


We can use std::expected.value_or to simplify this.

wgtmac · 2025-09-24T08:57:51Z

test/literal_test.cc

-// Special value tests
-TEST(LiteralTest, SpecialValues) {
+// Same type cast tests
+TEST(LiteralTest, SameTypeCast) {


As discussed offline, please refactor this file to use parameterized test to use common code for testing different data types.

wgtmac · 2025-09-29T03:46:27Z

src/iceberg/expression/literal.cc

    case TypeId::kTimestamp:
    case TypeId::kTimestampTz: {
-      throw IcebergError("Not implemented: ToString for " + type_->ToString());
+      return std::to_string(std::get<int64_t>(value_));


I think these switch cases can be easily rewritten by return std::to_string(std::get<typename LiteralTraits<type_id>::ValueType>(value_)); once #185 is merged.

wgtmac · 2025-09-29T03:46:43Z

src/iceberg/expression/literal.cc

+  auto unsupported_error = [this]() {
+    return std::format("ToString not supported for type: {}", type_->ToString());
+  };
+


Suggested change

auto unsupported_error = [this]() {

return std::format("ToString not supported for type: {}", type_->ToString());

};

wgtmac · 2025-09-29T03:48:18Z

src/iceberg/expression/literal.cc

    }
    default: {
-      throw IcebergError("Unknown type: " + type_->ToString());
+      return unsupported_error();


Suggested change

return unsupported_error();

return std::format("invalid literal of type {}", type_->ToString());

wgtmac · 2025-09-29T03:50:41Z

src/iceberg/expression/literal.h

+#include "iceberg/util/decimal.h"
+#include "iceberg/util/int128.h"


Revert these related lines?

wgtmac · 2025-09-29T03:50:46Z

src/iceberg/expression/literal.h

                             std::string,     // for string
                             std::vector<uint8_t>,     // for binary, fixed
-                             std::array<uint8_t, 16>,  // for uuid and decimal
+                             std::array<uint8_t, 16>,  // for uuid


wgtmac · 2025-09-29T03:56:58Z

test/literal_test.cc

  ASSERT_THAT(min_result, IsOk());
  EXPECT_TRUE(min_result->IsBelowMin());
+
+  max_result = max_long.CastTo(iceberg::date());


Suggested change

max_result = max_long.CastTo(iceberg::date());

max_result = max_long.CastTo(date());

wgtmac · 2025-09-29T03:57:23Z

test/literal_test.cc

-  ASSERT_THAT(double_result, IsOk());
-  EXPECT_EQ(double_result->type()->type_id(), TypeId::kDouble);
+  AssertCastSucceeds(float_literal.CastTo(iceberg::float64()), TypeId::kDouble,
+                     static_cast<double>(2.0f));


Suggested change

static_cast<double>(2.0f));

2.0);

wgtmac · 2025-09-29T03:58:02Z

test/literal_test.cc

+  auto min_double =
+      Literal::Double(-static_cast<double>(std::numeric_limits<float>::max()) * 2);
+
+  auto max_result = max_double.CastTo(iceberg::float32());


Suggested change

auto max_result = max_double.CastTo(iceberg::float32());

auto max_result = max_double.CastTo(float32());

wgtmac · 2025-09-29T03:58:16Z

test/literal_test.cc

+  auto binary_literal = Literal::Binary(data4);
+
+  // Cast to Fixed with matching length
+  AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);


Suggested change

AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);

AssertCastSucceeds(binary_literal.CastTo(fixed(4)), TypeId::kFixed, data4);

wgtmac · 2025-09-29T03:58:30Z

test/literal_test.cc

+  AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
+
+  // Cast to Fixed with different length should fail
+  EXPECT_THAT(binary_literal.CastTo(iceberg::fixed(5)),


Suggested change

EXPECT_THAT(binary_literal.CastTo(iceberg::fixed(5)),

EXPECT_THAT(binary_literal.CastTo(fixed(5)),

HeartLinked force-pushed the feat/literal2 branch from b599a7a to 9dfc38a Compare September 3, 2025 09:36

nullccxsy reviewed Sep 4, 2025

View reviewed changes

src/iceberg/expression/literal.cc Outdated Show resolved Hide resolved

src/iceberg/expression/literal.cc Outdated Show resolved Hide resolved

src/iceberg/expression/literal.cc Outdated Show resolved Hide resolved

HeartLinked force-pushed the feat/literal2 branch from 3f912eb to 59e57fc Compare September 4, 2025 07:27

wgtmac suggested changes Sep 9, 2025

View reviewed changes

HeartLinked force-pushed the feat/literal2 branch 2 times, most recently from cf43748 to 406a3f2 Compare September 10, 2025 06:26

wgtmac suggested changes Sep 11, 2025

View reviewed changes

wgtmac reviewed Sep 11, 2025

View reviewed changes

test/literal_test.cc Outdated Show resolved Hide resolved

test/literal_test.cc Outdated Show resolved Hide resolved

test/literal_test.cc Show resolved Hide resolved

test/literal_test.cc Outdated Show resolved Hide resolved

nullccxsy reviewed Sep 12, 2025

View reviewed changes

HeartLinked force-pushed the feat/literal2 branch from 406a3f2 to 9525400 Compare September 12, 2025 06:45

HeartLinked added 2 commits September 19, 2025 13:18

feat: Implement Type Casting and toString for Literals

5f6ed19

remove string cast to time types

6ddba62

HeartLinked force-pushed the feat/literal2 branch from a62ac22 to 1e106ed Compare September 19, 2025 10:40

HuaHuaY reviewed Sep 23, 2025

View reviewed changes

src/iceberg/expression/literal.h Outdated Show resolved Hide resolved

HuaHuaY reviewed Sep 23, 2025

View reviewed changes

test/literal_test.cc Outdated Show resolved Hide resolved

HuaHuaY reviewed Sep 23, 2025

View reviewed changes

test/literal_test.cc Outdated Show resolved Hide resolved

feat: Implement Type Casting and toString for Literals

632ec79

HeartLinked force-pushed the feat/literal2 branch from 2beaf96 to 632ec79 Compare September 23, 2025 07:41

HuaHuaY mentioned this pull request Sep 23, 2025

feat: Literal support decimal & Literal serde #238

Open

1

d454afa

wgtmac reviewed Sep 23, 2025

View reviewed changes

wgtmac reviewed Sep 24, 2025

View reviewed changes

wgtmac suggested changes Sep 29, 2025

View reviewed changes

		result.reserve(2 + binary_data.size() * 2 +
		1); // 2 chars per byte and 2 + 1 for prefix and suffix

	result.reserve(2 + binary_data.size() * 2 +
	1); // 2 chars per byte and 2 + 1 for prefix and suffix
	result.reserve(/prefix/2 + binary_data.size() * 2 + /suffix/1);

	auto decimal_type = std::static_pointer_cast<DecimalType>(target_type);
	auto decimal_type = internal::checked_pointer_cast<DecimalType>(target_type);

		iceberg::Decimal dec_val;
		ICEBERG_ASSIGN_OR_RAISE(dec_val, iceberg::Decimal::FromString(str_val));

	iceberg::Decimal dec_val;
	ICEBERG_ASSIGN_OR_RAISE(dec_val, iceberg::Decimal::FromString(str_val));
	ICEBERG_ASSIGN_OR_RAISE(auto dec_val, iceberg::Decimal::FromString(str_val));

	auto target_fixed_type = std::static_pointer_cast<FixedType>(target_type);
	auto target_fixed_type = internal::checked_pointer_cast<FixedType>(target_type);

	auto unsupported_error = [this]() {
	return std::format("ToString not supported for type: {}", type_->ToString());
	};

	return unsupported_error();
	return std::format("invalid literal of type {}", type_->ToString());

		#include "iceberg/util/decimal.h"
		#include "iceberg/util/int128.h"

	max_result = max_long.CastTo(iceberg::date());
	max_result = max_long.CastTo(date());

	auto max_result = max_double.CastTo(iceberg::float32());
	auto max_result = max_double.CastTo(float32());

	AssertCastSucceeds(binary_literal.CastTo(iceberg::fixed(4)), TypeId::kFixed, data4);
	AssertCastSucceeds(binary_literal.CastTo(fixed(4)), TypeId::kFixed, data4);

	EXPECT_THAT(binary_literal.CastTo(iceberg::fixed(5)),
	EXPECT_THAT(binary_literal.CastTo(fixed(5)),

feat: Implement Type Casting and toString for Literals #206

Are you sure you want to change the base?

feat: Implement Type Casting and toString for Literals #206

Uh oh!

Conversation

HeartLinked commented Sep 3, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!