Skip to content

feat: add inclusive metrics evaluator #357

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
wgtmac merged 15 commits into from
Dec 2, 2025
Merged

feat: add inclusive metrics evaluator #357

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
e60b30d
feat: add inclusive metrics evaluator
Nov 26, 2025
84970bb
fix cpplint
Nov 27, 2025
77a4463
add case
Nov 28, 2025
e40c09b
fix cpplint
Nov 28, 2025
af85e08
revert new error code
Nov 28, 2025
931cb85
modify meson build files
Dec 1, 2025
6f7c2ad
resolve conflict
Dec 1, 2025
7d40792
fix comments && rebase main
Dec 1, 2025
28d9397
refactor kind check
Dec 1, 2025
5ec5315
migrate all java case
Dec 1, 2025
c20b738
debug startsWith case in windows
Dec 2, 2025
0ce9818
fix cast
Dec 2, 2025
786b5f4
add transform case
Dec 2, 2025
89ad9e9
fix literal comparable
Dec 2, 2025
bf9822f
polish
wgtmac Dec 2, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions src/iceberg/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ set(ICEBERG_SOURCES
expression/evaluator.cc
expression/expression.cc
expression/expressions.cc
expression/inclusive_metrics_evaluator.cc
expression/literal.cc
expression/predicate.cc
expression/rewrite_not.cc
Expand Down
162 changes: 0 additions & 162 deletions src/iceberg/expression/expressions.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -156,226 +156,87 @@ std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::IsNull(
return IsNull<BoundReference>(Ref(std::move(name)));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::IsNull(
std::shared_ptr<UnboundTerm<B>> expr) {
ICEBERG_ASSIGN_OR_THROW(
auto pred,
UnboundPredicateImpl<B>::Make(Expression::Operation::kIsNull, std::move(expr)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotNull(
std::string name) {
return NotNull<BoundReference>(Ref(std::move(name)));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotNull(
std::shared_ptr<UnboundTerm<B>> expr) {
ICEBERG_ASSIGN_OR_THROW(
auto pred,
UnboundPredicateImpl<B>::Make(Expression::Operation::kNotNull, std::move(expr)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::IsNaN(
std::string name) {
return IsNaN<BoundReference>(Ref(std::move(name)));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::IsNaN(
std::shared_ptr<UnboundTerm<B>> expr) {
ICEBERG_ASSIGN_OR_THROW(auto pred, UnboundPredicateImpl<B>::Make(
Expression::Operation::kIsNan, std::move(expr)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotNaN(
std::string name) {
return NotNaN<BoundReference>(Ref(std::move(name)));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotNaN(
std::shared_ptr<UnboundTerm<B>> expr) {
ICEBERG_ASSIGN_OR_THROW(
auto pred,
UnboundPredicateImpl<B>::Make(Expression::Operation::kNotNan, std::move(expr)));
return pred;
}

// Template implementations for comparison predicates

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::LessThan(
std::string name, Literal value) {
return LessThan<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::LessThan(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kLt,
std::move(expr), std::move(value)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::LessThanOrEqual(
std::string name, Literal value) {
return LessThanOrEqual<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::LessThanOrEqual(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kLtEq,
std::move(expr), std::move(value)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::GreaterThan(
std::string name, Literal value) {
return GreaterThan<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::GreaterThan(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kGt,
std::move(expr), std::move(value)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::GreaterThanOrEqual(
std::string name, Literal value) {
return GreaterThanOrEqual<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::GreaterThanOrEqual(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kGtEq,
std::move(expr), std::move(value)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Equal(std::string name,
Literal value) {
return Equal<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Equal(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kEq,
std::move(expr), std::move(value)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotEqual(
std::string name, Literal value) {
return NotEqual<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotEqual(
std::shared_ptr<UnboundTerm<B>> expr, Literal value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kNotEq,
std::move(expr), std::move(value)));
return pred;
}

// String predicates

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::StartsWith(
std::string name, std::string value) {
return StartsWith<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::StartsWith(
std::shared_ptr<UnboundTerm<B>> expr, std::string value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred,
UnboundPredicateImpl<B>::Make(Expression::Operation::kStartsWith, std::move(expr),
Literal::String(std::move(value))));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotStartsWith(
std::string name, std::string value) {
return NotStartsWith<BoundReference>(Ref(std::move(name)), std::move(value));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotStartsWith(
std::shared_ptr<UnboundTerm<B>> expr, std::string value) {
ICEBERG_ASSIGN_OR_THROW(
auto pred,
UnboundPredicateImpl<B>::Make(Expression::Operation::kNotStartsWith,
std::move(expr), Literal::String(std::move(value))));
return pred;
}

// Template implementations for set predicates

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::In(
std::string name, std::vector<Literal> values) {
return In<BoundReference>(Ref(std::move(name)), std::move(values));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::In(
std::shared_ptr<UnboundTerm<B>> expr, std::vector<Literal> values) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kIn,
std::move(expr), std::move(values)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::In(
std::string name, std::initializer_list<Literal> values) {
return In<BoundReference>(Ref(std::move(name)), std::vector<Literal>(values));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::In(
std::shared_ptr<UnboundTerm<B>> expr, std::initializer_list<Literal> values) {
return In<B>(std::move(expr), std::vector<Literal>(values));
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotIn(
std::string name, std::vector<Literal> values) {
return NotIn<BoundReference>(Ref(std::move(name)), std::move(values));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotIn(
std::shared_ptr<UnboundTerm<B>> expr, std::vector<Literal> values) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(Expression::Operation::kNotIn,
std::move(expr), std::move(values)));
return pred;
}

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::NotIn(
std::string name, std::initializer_list<Literal> values) {
return NotIn<BoundReference>(Ref(std::move(name)), std::vector<Literal>(values));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::NotIn(
std::shared_ptr<UnboundTerm<B>> expr, std::initializer_list<Literal> values) {
return NotIn<B>(expr, std::vector<Literal>(values));
}

// Template implementations for generic predicate factory

std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Predicate(
Expand Down Expand Up @@ -404,29 +265,6 @@ std::shared_ptr<UnboundPredicateImpl<BoundReference>> Expressions::Predicate(
return pred;
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Predicate(
Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
std::vector<Literal> values) {
ICEBERG_ASSIGN_OR_THROW(
auto pred, UnboundPredicateImpl<B>::Make(op, std::move(expr), std::move(values)));
return pred;
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Predicate(
Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr,
std::initializer_list<Literal> values) {
return Predicate<B>(op, std::move(expr), std::vector<Literal>(values));
}

template <typename B>
std::shared_ptr<UnboundPredicateImpl<B>> Expressions::Predicate(
Expression::Operation op, std::shared_ptr<UnboundTerm<B>> expr) {
ICEBERG_ASSIGN_OR_THROW(auto pred, UnboundPredicateImpl<B>::Make(op, std::move(expr)));
return pred;
}

// Constants

std::shared_ptr<True> Expressions::AlwaysTrue() { return True::Instance(); }
Expand Down
Loading
Loading