|
| 1 | +/* |
| 2 | + * Licensed to the Apache Software Foundation (ASF) under one |
| 3 | + * or more contributor license agreements. See the NOTICE file |
| 4 | + * distributed with this work for additional information |
| 5 | + * regarding copyright ownership. The ASF licenses this file |
| 6 | + * to you under the Apache License, Version 2.0 (the |
| 7 | + * "License"); you may not use this file except in compliance |
| 8 | + * with the License. You may obtain a copy of the License at |
| 9 | + * |
| 10 | + * http://www.apache.org/licenses/LICENSE-2.0 |
| 11 | + * |
| 12 | + * Unless required by applicable law or agreed to in writing, |
| 13 | + * software distributed under the License is distributed on an |
| 14 | + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| 15 | + * KIND, either express or implied. See the License for the |
| 16 | + * specific language governing permissions and limitations |
| 17 | + * under the License. |
| 18 | + */ |
| 19 | + |
| 20 | +#include <arrow/c/bridge.h> |
| 21 | +#include <arrow/json/from_string.h> |
| 22 | +#include <avro/Compiler.hh> |
| 23 | +#include <avro/Generic.hh> |
| 24 | +#include <avro/Node.hh> |
| 25 | +#include <avro/Types.hh> |
| 26 | +#include <gmock/gmock.h> |
| 27 | +#include <gtest/gtest.h> |
| 28 | +#include <iceberg/arrow/arrow_error_transform_internal.h> |
| 29 | +#include <iceberg/avro/avro_data_util_internal.h> |
| 30 | +#include <iceberg/avro/avro_schema_util_internal.h> |
| 31 | +#include <iceberg/schema.h> |
| 32 | +#include <iceberg/schema_internal.h> |
| 33 | +#include <iceberg/schema_util.h> |
| 34 | +#include <iceberg/type.h> |
| 35 | +#include <iceberg/util/macros.h> |
| 36 | + |
| 37 | +#include "matchers.h" |
| 38 | + |
| 39 | +namespace iceberg::avro { |
| 40 | + |
| 41 | +/// \brief Test case structure for parameterized primitive type tests |
| 42 | +struct AppendDatumParam { |
| 43 | + std::string name; |
| 44 | + std::shared_ptr<Type> projected_type; |
| 45 | + std::shared_ptr<Type> source_type; |
| 46 | + std::function<void(::avro::GenericDatum&, int)> value_setter; |
| 47 | + std::string expected_json; |
| 48 | +}; |
| 49 | + |
| 50 | +/// \brief Helper function to create test data for a primitive type |
| 51 | +std::vector<::avro::GenericDatum> CreateTestData( |
| 52 | + const ::avro::NodePtr& avro_node, |
| 53 | + const std::function<void(::avro::GenericDatum&, int)>& value_setter, int count = 3) { |
| 54 | + std::vector<::avro::GenericDatum> avro_data; |
| 55 | + for (int i = 0; i < count; ++i) { |
| 56 | + ::avro::GenericDatum avro_datum(avro_node); |
| 57 | + value_setter(avro_datum, i); |
| 58 | + avro_data.push_back(avro_datum); |
| 59 | + } |
| 60 | + return avro_data; |
| 61 | +} |
| 62 | + |
| 63 | +/// \brief Utility function to verify AppendDatumToBuilder behavior |
| 64 | +void VerifyAppendDatumToBuilder(const Schema& projected_schema, |
| 65 | + const ::avro::NodePtr& avro_node, |
| 66 | + const std::vector<::avro::GenericDatum>& avro_data, |
| 67 | + std::string_view expected_array_json) { |
| 68 | + // Create 1 to 1 projection |
| 69 | + auto projection_result = Project(projected_schema, avro_node, /*prune_source=*/false); |
| 70 | + ASSERT_THAT(projection_result, IsOk()); |
| 71 | + auto projection = std::move(projection_result.value()); |
| 72 | + |
| 73 | + // Create arrow schema and array builder |
| 74 | + ArrowSchema arrow_c_schema; |
| 75 | + ASSERT_THAT(ToArrowSchema(projected_schema, &arrow_c_schema), IsOk()); |
| 76 | + auto arrow_schema = ::arrow::ImportSchema(&arrow_c_schema).ValueOrDie(); |
| 77 | + auto arrow_struct_type = std::make_shared<::arrow::StructType>(arrow_schema->fields()); |
| 78 | + auto builder = ::arrow::MakeBuilder(arrow_struct_type).ValueOrDie(); |
| 79 | + |
| 80 | + // Call AppendDatumToBuilder repeatedly to append the datum |
| 81 | + for (const auto& avro_datum : avro_data) { |
| 82 | + ASSERT_THAT(AppendDatumToBuilder(avro_node, avro_datum, projection, projected_schema, |
| 83 | + builder.get()), |
| 84 | + IsOk()); |
| 85 | + } |
| 86 | + |
| 87 | + // Verify the result |
| 88 | + auto array = builder->Finish().ValueOrDie(); |
| 89 | + auto expected_array = |
| 90 | + ::arrow::json::ArrayFromJSONString(arrow_struct_type, expected_array_json) |
| 91 | + .ValueOrDie(); |
| 92 | + ASSERT_TRUE(array->Equals(*expected_array)); |
| 93 | +} |
| 94 | + |
| 95 | +/// \brief Test class for primitive types using parameterized tests |
| 96 | +class AppendDatumToBuilderTest : public ::testing::TestWithParam<AppendDatumParam> {}; |
| 97 | + |
| 98 | +TEST_P(AppendDatumToBuilderTest, PrimitiveType) { |
| 99 | + const auto& test_case = GetParam(); |
| 100 | + |
| 101 | + Schema projected_schema({SchemaField::MakeRequired( |
| 102 | + /*field_id=*/1, /*name=*/"a", test_case.projected_type)}); |
| 103 | + Schema source_schema({SchemaField::MakeRequired( |
| 104 | + /*field_id=*/1, /*name=*/"a", test_case.source_type)}); |
| 105 | + |
| 106 | + ::avro::NodePtr avro_node; |
| 107 | + EXPECT_THAT(ToAvroNodeVisitor{}.Visit(source_schema, &avro_node), IsOk()); |
| 108 | + |
| 109 | + auto avro_data = CreateTestData(avro_node, test_case.value_setter); |
| 110 | + ASSERT_NO_FATAL_FAILURE(VerifyAppendDatumToBuilder(projected_schema, avro_node, |
| 111 | + avro_data, test_case.expected_json)); |
| 112 | +} |
| 113 | + |
| 114 | +// Define test cases for all primitive types |
| 115 | +const std::vector<AppendDatumParam> kPrimitiveTestCases = { |
| 116 | + { |
| 117 | + .name = "Boolean", |
| 118 | + .projected_type = std::make_shared<BooleanType>(), |
| 119 | + .source_type = std::make_shared<BooleanType>(), |
| 120 | + .value_setter = |
| 121 | + [](::avro::GenericDatum& datum, int i) { |
| 122 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<bool>() = |
| 123 | + (i % 2 == 0); |
| 124 | + }, |
| 125 | + .expected_json = R"([{"a": true}, {"a": false}, {"a": true}])", |
| 126 | + }, |
| 127 | + { |
| 128 | + .name = "Int", |
| 129 | + .projected_type = std::make_shared<IntType>(), |
| 130 | + .source_type = std::make_shared<IntType>(), |
| 131 | + .value_setter = |
| 132 | + [](::avro::GenericDatum& datum, int i) { |
| 133 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<int32_t>() = i * 100; |
| 134 | + }, |
| 135 | + .expected_json = R"([{"a": 0}, {"a": 100}, {"a": 200}])", |
| 136 | + }, |
| 137 | + { |
| 138 | + .name = "Long", |
| 139 | + .projected_type = std::make_shared<LongType>(), |
| 140 | + .source_type = std::make_shared<LongType>(), |
| 141 | + .value_setter = |
| 142 | + [](::avro::GenericDatum& datum, int i) { |
| 143 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<int64_t>() = |
| 144 | + i * 1000000LL; |
| 145 | + }, |
| 146 | + .expected_json = R"([{"a": 0}, {"a": 1000000}, {"a": 2000000}])", |
| 147 | + }, |
| 148 | + { |
| 149 | + .name = "Float", |
| 150 | + .projected_type = std::make_shared<FloatType>(), |
| 151 | + .source_type = std::make_shared<FloatType>(), |
| 152 | + .value_setter = |
| 153 | + [](::avro::GenericDatum& datum, int i) { |
| 154 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<float>() = i * 3.14f; |
| 155 | + }, |
| 156 | + .expected_json = R"([{"a": 0.0}, {"a": 3.14}, {"a": 6.28}])", |
| 157 | + }, |
| 158 | + { |
| 159 | + .name = "Double", |
| 160 | + .projected_type = std::make_shared<DoubleType>(), |
| 161 | + .source_type = std::make_shared<DoubleType>(), |
| 162 | + .value_setter = |
| 163 | + [](::avro::GenericDatum& datum, int i) { |
| 164 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<double>() = |
| 165 | + i * 1.234567890; |
| 166 | + }, |
| 167 | + .expected_json = R"([{"a": 0.0}, {"a": 1.234567890}, {"a": 2.469135780}])", |
| 168 | + }, |
| 169 | + { |
| 170 | + .name = "String", |
| 171 | + .projected_type = std::make_shared<StringType>(), |
| 172 | + .source_type = std::make_shared<StringType>(), |
| 173 | + .value_setter = |
| 174 | + [](::avro::GenericDatum& datum, int i) { |
| 175 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<std::string>() = |
| 176 | + "test_string_" + std::to_string(i); |
| 177 | + }, |
| 178 | + .expected_json = |
| 179 | + R"([{"a": "test_string_0"}, {"a": "test_string_1"}, {"a": "test_string_2"}])", |
| 180 | + }, |
| 181 | + { |
| 182 | + .name = "IntToLongPromotion", |
| 183 | + .projected_type = std::make_shared<LongType>(), |
| 184 | + .source_type = std::make_shared<IntType>(), |
| 185 | + .value_setter = |
| 186 | + [](::avro::GenericDatum& datum, int i) { |
| 187 | + datum.value<::avro::GenericRecord>().fieldAt(0).value<int32_t>() = i * 100; |
| 188 | + }, |
| 189 | + .expected_json = R"([{"a": 0}, {"a": 100}, {"a": 200}])", |
| 190 | + }, |
| 191 | + // TODO(gangwu): add test cases for other types |
| 192 | +}; |
| 193 | + |
| 194 | +INSTANTIATE_TEST_SUITE_P(AllPrimitiveTypes, AppendDatumToBuilderTest, |
| 195 | + ::testing::ValuesIn(kPrimitiveTestCases), |
| 196 | + []( const ::testing::TestParamInfo<AppendDatumParam>& info) { |
| 197 | + return info.param.name; |
| 198 | + }); |
| 199 | + |
| 200 | +TEST(AppendDatumToBuilderTest, TwoFieldsRecord) { |
| 201 | + Schema iceberg_schema({ |
| 202 | + SchemaField::MakeRequired(1, "id", std::make_shared<IntType>()), |
| 203 | + SchemaField::MakeRequired(2, "name", std::make_shared<StringType>()), |
| 204 | + }); |
| 205 | + ::avro::NodePtr avro_node; |
| 206 | + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); |
| 207 | + |
| 208 | + std::vector<::avro::GenericDatum> avro_data; |
| 209 | + ::avro::GenericDatum avro_datum(avro_node); |
| 210 | + auto& record = avro_datum.value<::avro::GenericRecord>(); |
| 211 | + record.fieldAt(0).value<int32_t>() = 42; |
| 212 | + record.fieldAt(1).value<std::string>() = "test"; |
| 213 | + avro_data.push_back(avro_datum); |
| 214 | + |
| 215 | + ASSERT_NO_FATAL_FAILURE(VerifyAppendDatumToBuilder(iceberg_schema, avro_node, avro_data, |
| 216 | + R"([{"id": 42, "name": "test"}])")); |
| 217 | +} |
| 218 | + |
| 219 | +} // namespace iceberg::avro |
0 commit comments