Skip to content

Commit e684be2

Browse files
zhjwpkuzhjwpku
authored
feat: add strict projection to transform (#387)
1 parent e1acefd commit e684be2

File tree

5 files changed

+1196
-389
lines changed

5 files changed

+1196
-389
lines changed

‎src/iceberg/test/predicate_test.cc‎

Lines changed: 43 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,6 @@
2626
#include "iceberg/schema.h"
2727
#include "iceberg/test/matchers.h"
2828
#include "iceberg/type.h"
29-
#include "iceberg/util/macros.h"
3029

3130
namespace iceberg {
3231

@@ -607,24 +606,24 @@ std::shared_ptr<BoundPredicate> AssertAndCastToBoundPredicate(
607606
} // namespace
608607

609608
TEST_F(PredicateTest, BoundUnaryPredicateTestIsNull) {
610-
ICEBERG_ASSIGN_OR_THROW(auto is_null_pred, Expressions::IsNull("name")->Bind(
611-
*schema_, /*case_sensitive=*/true));
609+
ICEBERG_UNWRAP_OR_FAIL(auto is_null_pred, Expressions::IsNull("name")->Bind(
610+
*schema_, /*case_sensitive=*/true));
612611
auto bound_pred = AssertAndCastToBoundPredicate(is_null_pred);
613612
EXPECT_THAT(bound_pred->Test(Literal::Null(string())), HasValue(testing::Eq(true)));
614613
EXPECT_THAT(bound_pred->Test(Literal::String("test")), HasValue(testing::Eq(false)));
615614
}
616615

617616
TEST_F(PredicateTest, BoundUnaryPredicateTestNotNull) {
618-
ICEBERG_ASSIGN_OR_THROW(auto not_null_pred, Expressions::NotNull("name")->Bind(
619-
*schema_, /*case_sensitive=*/true));
617+
ICEBERG_UNWRAP_OR_FAIL(auto not_null_pred, Expressions::NotNull("name")->Bind(
618+
*schema_, /*case_sensitive=*/true));
620619
auto bound_pred = AssertAndCastToBoundPredicate(not_null_pred);
621620
EXPECT_THAT(bound_pred->Test(Literal::String("test")), HasValue(testing::Eq(true)));
622621
EXPECT_THAT(bound_pred->Test(Literal::Null(string())), HasValue(testing::Eq(false)));
623622
}
624623

625624
TEST_F(PredicateTest, BoundUnaryPredicateTestIsNaN) {
626-
ICEBERG_ASSIGN_OR_THROW(auto is_nan_pred, Expressions::IsNaN("salary")->Bind(
627-
*schema_, /*case_sensitive=*/true));
625+
ICEBERG_UNWRAP_OR_FAIL(auto is_nan_pred, Expressions::IsNaN("salary")->Bind(
626+
*schema_, /*case_sensitive=*/true));
628627
auto bound_pred = AssertAndCastToBoundPredicate(is_nan_pred);
629628

630629
// Test with NaN values
@@ -643,8 +642,8 @@ TEST_F(PredicateTest, BoundUnaryPredicateTestIsNaN) {
643642
}
644643

645644
TEST_F(PredicateTest, BoundUnaryPredicateTestNotNaN) {
646-
ICEBERG_ASSIGN_OR_THROW(auto not_nan_pred, Expressions::NotNaN("salary")->Bind(
647-
*schema_, /*case_sensitive=*/true));
645+
ICEBERG_UNWRAP_OR_FAIL(auto not_nan_pred, Expressions::NotNaN("salary")->Bind(
646+
*schema_, /*case_sensitive=*/true));
648647
auto bound_pred = AssertAndCastToBoundPredicate(not_nan_pred);
649648

650649
// Test with regular values
@@ -661,34 +660,34 @@ TEST_F(PredicateTest, BoundUnaryPredicateTestNotNaN) {
661660

662661
TEST_F(PredicateTest, BoundLiteralPredicateTestComparison) {
663662
// Test less than
664-
ICEBERG_ASSIGN_OR_THROW(auto lt_pred, Expressions::LessThan("age", Literal::Int(30))
665-
->Bind(*schema_, /*case_sensitive=*/true));
663+
ICEBERG_UNWRAP_OR_FAIL(auto lt_pred, Expressions::LessThan("age", Literal::Int(30))
664+
->Bind(*schema_, /*case_sensitive=*/true));
666665
auto bound_lt = AssertAndCastToBoundPredicate(lt_pred);
667666
EXPECT_THAT(bound_lt->Test(Literal::Int(20)), HasValue(testing::Eq(true)));
668667
EXPECT_THAT(bound_lt->Test(Literal::Int(30)), HasValue(testing::Eq(false)));
669668
EXPECT_THAT(bound_lt->Test(Literal::Int(40)), HasValue(testing::Eq(false)));
670669

671670
// Test less than or equal
672-
ICEBERG_ASSIGN_OR_THROW(auto lte_pred,
673-
Expressions::LessThanOrEqual("age", Literal::Int(30))
674-
->Bind(*schema_, /*case_sensitive=*/true));
671+
ICEBERG_UNWRAP_OR_FAIL(auto lte_pred,
672+
Expressions::LessThanOrEqual("age", Literal::Int(30))
673+
->Bind(*schema_, /*case_sensitive=*/true));
675674
auto bound_lte = AssertAndCastToBoundPredicate(lte_pred);
676675
EXPECT_THAT(bound_lte->Test(Literal::Int(20)), HasValue(testing::Eq(true)));
677676
EXPECT_THAT(bound_lte->Test(Literal::Int(30)), HasValue(testing::Eq(true)));
678677
EXPECT_THAT(bound_lte->Test(Literal::Int(40)), HasValue(testing::Eq(false)));
679678

680679
// Test greater than
681-
ICEBERG_ASSIGN_OR_THROW(auto gt_pred, Expressions::GreaterThan("age", Literal::Int(30))
682-
->Bind(*schema_, /*case_sensitive=*/true));
680+
ICEBERG_UNWRAP_OR_FAIL(auto gt_pred, Expressions::GreaterThan("age", Literal::Int(30))
681+
->Bind(*schema_, /*case_sensitive=*/true));
683682
auto bound_gt = AssertAndCastToBoundPredicate(gt_pred);
684683
EXPECT_THAT(bound_gt->Test(Literal::Int(20)), HasValue(testing::Eq(false)));
685684
EXPECT_THAT(bound_gt->Test(Literal::Int(30)), HasValue(testing::Eq(false)));
686685
EXPECT_THAT(bound_gt->Test(Literal::Int(40)), HasValue(testing::Eq(true)));
687686

688687
// Test greater than or equal
689-
ICEBERG_ASSIGN_OR_THROW(auto gte_pred,
690-
Expressions::GreaterThanOrEqual("age", Literal::Int(30))
691-
->Bind(*schema_, /*case_sensitive=*/true));
688+
ICEBERG_UNWRAP_OR_FAIL(auto gte_pred,
689+
Expressions::GreaterThanOrEqual("age", Literal::Int(30))
690+
->Bind(*schema_, /*case_sensitive=*/true));
692691
auto bound_gte = AssertAndCastToBoundPredicate(gte_pred);
693692
EXPECT_THAT(bound_gte->Test(Literal::Int(20)), HasValue(testing::Eq(false)));
694693
EXPECT_THAT(bound_gte->Test(Literal::Int(30)), HasValue(testing::Eq(true)));
@@ -697,16 +696,16 @@ TEST_F(PredicateTest, BoundLiteralPredicateTestComparison) {
697696

698697
TEST_F(PredicateTest, BoundLiteralPredicateTestEquality) {
699698
// Test equal
700-
ICEBERG_ASSIGN_OR_THROW(auto eq_pred, Expressions::Equal("age", Literal::Int(25))
701-
->Bind(*schema_, /*case_sensitive=*/true));
699+
ICEBERG_UNWRAP_OR_FAIL(auto eq_pred, Expressions::Equal("age", Literal::Int(25))
700+
->Bind(*schema_, /*case_sensitive=*/true));
702701
auto bound_eq = AssertAndCastToBoundPredicate(eq_pred);
703702
EXPECT_THAT(bound_eq->Test(Literal::Int(25)), HasValue(testing::Eq(true)));
704703
EXPECT_THAT(bound_eq->Test(Literal::Int(26)), HasValue(testing::Eq(false)));
705704
EXPECT_THAT(bound_eq->Test(Literal::Int(24)), HasValue(testing::Eq(false)));
706705

707706
// Test not equal
708-
ICEBERG_ASSIGN_OR_THROW(auto neq_pred, Expressions::NotEqual("age", Literal::Int(25))
709-
->Bind(*schema_, /*case_sensitive=*/true));
707+
ICEBERG_UNWRAP_OR_FAIL(auto neq_pred, Expressions::NotEqual("age", Literal::Int(25))
708+
->Bind(*schema_, /*case_sensitive=*/true));
710709
auto bound_neq = AssertAndCastToBoundPredicate(neq_pred);
711710
EXPECT_THAT(bound_neq->Test(Literal::Int(25)), HasValue(testing::Eq(false)));
712711
EXPECT_THAT(bound_neq->Test(Literal::Int(26)), HasValue(testing::Eq(true)));
@@ -715,35 +714,35 @@ TEST_F(PredicateTest, BoundLiteralPredicateTestEquality) {
715714

716715
TEST_F(PredicateTest, BoundLiteralPredicateTestWithDifferentTypes) {
717716
// Test with double
718-
ICEBERG_ASSIGN_OR_THROW(auto gt_pred,
719-
Expressions::GreaterThan("salary", Literal::Double(50000.0))
720-
->Bind(*schema_, /*case_sensitive=*/true));
717+
ICEBERG_UNWRAP_OR_FAIL(auto gt_pred,
718+
Expressions::GreaterThan("salary", Literal::Double(50000.0))
719+
->Bind(*schema_, /*case_sensitive=*/true));
721720
auto bound_double = AssertAndCastToBoundPredicate(gt_pred);
722721
EXPECT_THAT(bound_double->Test(Literal::Double(60000.0)), HasValue(testing::Eq(true)));
723722
EXPECT_THAT(bound_double->Test(Literal::Double(40000.0)), HasValue(testing::Eq(false)));
724723
EXPECT_THAT(bound_double->Test(Literal::Double(50000.0)), HasValue(testing::Eq(false)));
725724

726725
// Test with string
727-
ICEBERG_ASSIGN_OR_THROW(auto str_eq_pred,
728-
Expressions::Equal("name", Literal::String("Alice"))
729-
->Bind(*schema_, /*case_sensitive=*/true));
726+
ICEBERG_UNWRAP_OR_FAIL(auto str_eq_pred,
727+
Expressions::Equal("name", Literal::String("Alice"))
728+
->Bind(*schema_, /*case_sensitive=*/true));
730729
auto bound_string = AssertAndCastToBoundPredicate(str_eq_pred);
731730
EXPECT_THAT(bound_string->Test(Literal::String("Alice")), HasValue(testing::Eq(true)));
732731
EXPECT_THAT(bound_string->Test(Literal::String("Bob")), HasValue(testing::Eq(false)));
733732
EXPECT_THAT(bound_string->Test(Literal::String("alice")),
734733
HasValue(testing::Eq(false))); // Case sensitive
735734

736735
// Test with boolean
737-
ICEBERG_ASSIGN_OR_THROW(auto bool_eq_pred,
738-
Expressions::Equal("active", Literal::Boolean(true))
739-
->Bind(*schema_, /*case_sensitive=*/true));
736+
ICEBERG_UNWRAP_OR_FAIL(auto bool_eq_pred,
737+
Expressions::Equal("active", Literal::Boolean(true))
738+
->Bind(*schema_, /*case_sensitive=*/true));
740739
auto bound_bool = AssertAndCastToBoundPredicate(bool_eq_pred);
741740
EXPECT_THAT(bound_bool->Test(Literal::Boolean(true)), HasValue(testing::Eq(true)));
742741
EXPECT_THAT(bound_bool->Test(Literal::Boolean(false)), HasValue(testing::Eq(false)));
743742
}
744743

745744
TEST_F(PredicateTest, BoundLiteralPredicateTestStartsWith) {
746-
ICEBERG_ASSIGN_OR_THROW(
745+
ICEBERG_UNWRAP_OR_FAIL(
747746
auto starts_with_pred,
748747
Expressions::StartsWith("name", "Jo")->Bind(*schema_, /*case_sensitive=*/true));
749748
auto bound_pred = AssertAndCastToBoundPredicate(starts_with_pred);
@@ -759,7 +758,7 @@ TEST_F(PredicateTest, BoundLiteralPredicateTestStartsWith) {
759758
EXPECT_THAT(bound_pred->Test(Literal::String("")), HasValue(testing::Eq(false)));
760759

761760
// Test empty prefix
762-
ICEBERG_ASSIGN_OR_THROW(
761+
ICEBERG_UNWRAP_OR_FAIL(
763762
auto empty_prefix_pred,
764763
Expressions::StartsWith("name", "")->Bind(*schema_, /*case_sensitive=*/true));
765764
auto bound_empty = AssertAndCastToBoundPredicate(empty_prefix_pred);
@@ -770,7 +769,7 @@ TEST_F(PredicateTest, BoundLiteralPredicateTestStartsWith) {
770769
}
771770

772771
TEST_F(PredicateTest, BoundLiteralPredicateTestNotStartsWith) {
773-
ICEBERG_ASSIGN_OR_THROW(
772+
ICEBERG_UNWRAP_OR_FAIL(
774773
auto not_starts_with_pred,
775774
Expressions::NotStartsWith("name", "Jo")->Bind(*schema_, /*case_sensitive=*/true));
776775
auto bound_pred = AssertAndCastToBoundPredicate(not_starts_with_pred);
@@ -787,7 +786,7 @@ TEST_F(PredicateTest, BoundLiteralPredicateTestNotStartsWith) {
787786
}
788787

789788
TEST_F(PredicateTest, BoundSetPredicateTestIn) {
790-
ICEBERG_ASSIGN_OR_THROW(
789+
ICEBERG_UNWRAP_OR_FAIL(
791790
auto in_pred,
792791
Expressions::In("age", {Literal::Int(10), Literal::Int(20), Literal::Int(30)})
793792
->Bind(*schema_, /*case_sensitive=*/true));
@@ -805,7 +804,7 @@ TEST_F(PredicateTest, BoundSetPredicateTestIn) {
805804
}
806805

807806
TEST_F(PredicateTest, BoundSetPredicateTestNotIn) {
808-
ICEBERG_ASSIGN_OR_THROW(
807+
ICEBERG_UNWRAP_OR_FAIL(
809808
auto not_in_pred,
810809
Expressions::NotIn("age", {Literal::Int(10), Literal::Int(20), Literal::Int(30)})
811810
->Bind(*schema_, /*case_sensitive=*/true));
@@ -823,7 +822,7 @@ TEST_F(PredicateTest, BoundSetPredicateTestNotIn) {
823822
}
824823

825824
TEST_F(PredicateTest, BoundSetPredicateTestWithStrings) {
826-
ICEBERG_ASSIGN_OR_THROW(
825+
ICEBERG_UNWRAP_OR_FAIL(
827826
auto in_pred,
828827
Expressions::In("name", {Literal::String("Alice"), Literal::String("Bob"),
829828
Literal::String("Charlie")})
@@ -843,10 +842,10 @@ TEST_F(PredicateTest, BoundSetPredicateTestWithStrings) {
843842
}
844843

845844
TEST_F(PredicateTest, BoundSetPredicateTestWithLongs) {
846-
ICEBERG_ASSIGN_OR_THROW(auto in_pred,
847-
Expressions::In("id", {Literal::Long(100L), Literal::Long(200L),
848-
Literal::Long(300L)})
849-
->Bind(*schema_, /*case_sensitive=*/true));
845+
ICEBERG_UNWRAP_OR_FAIL(auto in_pred,
846+
Expressions::In("id", {Literal::Long(100L), Literal::Long(200L),
847+
Literal::Long(300L)})
848+
->Bind(*schema_, /*case_sensitive=*/true));
850849
auto bound_pred = AssertAndCastToBoundPredicate(in_pred);
851850

852851
// Test longs in the set
@@ -860,8 +859,8 @@ TEST_F(PredicateTest, BoundSetPredicateTestWithLongs) {
860859
}
861860

862861
TEST_F(PredicateTest, BoundSetPredicateTestSingleLiteral) {
863-
ICEBERG_ASSIGN_OR_THROW(auto in_pred, Expressions::In("age", {Literal::Int(42)})
864-
->Bind(*schema_, /*case_sensitive=*/true));
862+
ICEBERG_UNWRAP_OR_FAIL(auto in_pred, Expressions::In("age", {Literal::Int(42)})
863+
->Bind(*schema_, /*case_sensitive=*/true));
865864

866865
// Single element IN becomes Equal
867866
EXPECT_EQ(in_pred->op(), Expression::Operation::kEq);

0 commit comments

Comments
 (0)