diff --git a/cpp/src/arrow/acero/hash_aggregate_test.cc b/cpp/src/arrow/acero/hash_aggregate_test.cc index 12d24429cb6c..17baaf2b1ef4 100644 --- a/cpp/src/arrow/acero/hash_aggregate_test.cc +++ b/cpp/src/arrow/acero/hash_aggregate_test.cc @@ -273,7 +273,7 @@ Result MakeGroupByOutput(const std::vector& output_batches, sort_keys.emplace_back(static_cast(i)); } std::shared_ptr key_schema = schema(std::move(key_fields)); - std::shared_ptr key_table = Table::Make(std::move(key_schema), key_columns); + std::shared_ptr
key_table = Table::Make(std::move(key_schema), key_columns).ValueOrDie(); SortOptions sort_options(std::move(sort_keys)); ARROW_ASSIGN_OR_RAISE(std::shared_ptr sort_indices, SortIndices(key_table, sort_options)); diff --git a/cpp/src/arrow/acero/hash_join_node_test.cc b/cpp/src/arrow/acero/hash_join_node_test.cc index 73355af8c4b4..b98b0c90b394 100644 --- a/cpp/src/arrow/acero/hash_join_node_test.cc +++ b/cpp/src/arrow/acero/hash_join_node_test.cc @@ -906,7 +906,7 @@ std::shared_ptr
HashJoinSimple( fields[i] = std::make_shared("a" + std::to_string(i), result[i]->type(), true); } std::shared_ptr schema = std::make_shared(std::move(fields)); - return Table::Make(schema, result, result[0]->length()); + return Table::Make(schema, result, result[0]->length()).ValueOrDie(); } Result> HashJoinWithExecPlan( diff --git a/cpp/src/arrow/adapters/orc/adapter.cc b/cpp/src/arrow/adapters/orc/adapter.cc index 51cca497485c..083f5550015e 100644 --- a/cpp/src/arrow/adapters/orc/adapter.cc +++ b/cpp/src/arrow/adapters/orc/adapter.cc @@ -843,7 +843,7 @@ Result> ORCFileWriter::Open( Status ORCFileWriter::Write(const Table& table) { return impl_->Write(table); } Status ORCFileWriter::Write(const RecordBatch& record_batch) { - auto table = Table::Make(record_batch.schema(), record_batch.columns()); + auto table = Table::Make(record_batch.schema(), record_batch.columns()).ValueOrDie(); return impl_->Write(*table); } diff --git a/cpp/src/arrow/adapters/orc/adapter_test.cc b/cpp/src/arrow/adapters/orc/adapter_test.cc index 714e61b22b11..b435f405e6da 100644 --- a/cpp/src/arrow/adapters/orc/adapter_test.cc +++ b/cpp/src/arrow/adapters/orc/adapter_test.cc @@ -219,7 +219,7 @@ std::shared_ptr
GenerateRandomTable(const std::shared_ptr& schema min_num_chunks, max_num_chunks, null_probability)); } - return Table::Make(schema, cv); + return Table::Make(schema, cv).ValueOrDie(); } void AssertTableWriteReadEqual(const std::vector>& input_tables, @@ -310,9 +310,9 @@ void AssertArrayWriteReadEqual(const std::shared_ptr& input_array, auto input_chunked_array = std::make_shared(input_array), expected_output_chunked_array = std::make_shared(expected_output_array); - std::shared_ptr
input_table = Table::Make(input_schema, {input_chunked_array}), + std::shared_ptr
input_table = Table::Make(input_schema, {input_chunked_array}).ValueOrDie(), expected_output_table = - Table::Make(output_schema, {expected_output_chunked_array}); + Table::Make(output_schema, {expected_output_chunked_array}).ValueOrDie(); AssertTableWriteReadEqual(input_table, expected_output_table, max_size); } @@ -731,7 +731,7 @@ TEST_F(TestORCWriterTrivialNoConversion, writeFilledChunkAndSelectField) { field("binary", binary()), }); auto batch = rand.BatchOf(local_schema->fields(), 100); - std::shared_ptr
table = Table::Make(local_schema, batch->columns()); + std::shared_ptr
table = Table::Make(local_schema, batch->columns()).ValueOrDie(); EXPECT_OK_AND_ASSIGN(auto table_selected, table->SelectColumns(selected_indices)); AssertTableWriteReadEqual(table, table_selected, kDefaultSmallMemStreamSize, &selected_indices); @@ -857,7 +857,7 @@ class TestORCWriterWithConversion : public ::testing::Test { for (int i = static_cast(num_cols - 2); i < static_cast(num_cols); i++) { av[i] = CastFixedSizeBinaryArrayToBinaryArray(input_table->column(i)->chunk(0)); } - std::shared_ptr
expected_output_table = Table::Make(output_schema, av); + std::shared_ptr
expected_output_table = Table::Make(output_schema, av).ValueOrDie(); AssertTableWriteReadEqual(input_table, expected_output_table, max_size); } @@ -1132,11 +1132,11 @@ TEST_F(TestORCWriterMultipleWrite, MultipleWritesIntField) { auto array_int = rand.ArrayOf(int32(), num_rows, 0); vect.push_back(array_int); auto input_chunked_array = std::make_shared(array_int); - input_tables.emplace_back(Table::Make(input_schema, {input_chunked_array})); + input_tables.emplace_back(Table::Make(input_schema, {input_chunked_array}).ValueOrDie()); } auto expected_output_chunked_array = std::make_shared(vect); std::shared_ptr
expected_output_table = - Table::Make(input_schema, {expected_output_chunked_array}); + Table::Make(input_schema, {expected_output_chunked_array}).ValueOrDie(); AssertTableWriteReadEqual(input_tables, expected_output_table, kDefaultSmallMemStreamSize * 100); } @@ -1148,8 +1148,8 @@ TEST_F(TestORCWriterMultipleWrite, MultipleWritesIncoherentSchema) { auto array_int2 = rand.ArrayOf(int64(), num_rows, 0); std::shared_ptr input_schema2 = schema({field("col0", array_int2->type())}); - std::shared_ptr
input_table = Table::Make(input_schema, {array_int}); - std::shared_ptr
input_table2 = Table::Make(input_schema2, {array_int2}); + std::shared_ptr
input_table = Table::Make(input_schema, {array_int}).ValueOrDie(); + std::shared_ptr
input_table2 = Table::Make(input_schema2, {array_int2}).ValueOrDie(); EXPECT_OK_AND_ASSIGN(auto buffer_output_stream, io::BufferOutputStream::Create(kDefaultSmallMemStreamSize)); auto write_options = adapters::orc::WriteOptions(); @@ -1175,7 +1175,7 @@ TEST_F(TestORCWriterMultipleWrite, MultipleWritesIntFieldRecordBatch) { } auto expected_output_chunked_array = std::make_shared(vect); std::shared_ptr
expected_output_table = - Table::Make(input_schema, {expected_output_chunked_array}); + Table::Make(input_schema, {expected_output_chunked_array}).ValueOrDie(); AssertBatchWriteReadEqual(input_batches, expected_output_table, kDefaultSmallMemStreamSize * 100); } diff --git a/cpp/src/arrow/array/array_dict_test.cc b/cpp/src/arrow/array/array_dict_test.cc index 22d6d1fc5ae9..2fdcd80a5cdd 100644 --- a/cpp/src/arrow/array/array_dict_test.cc +++ b/cpp/src/arrow/array/array_dict_test.cc @@ -1753,7 +1753,7 @@ TEST(TestDictionaryUnifier, ChunkedArrayNestedDict) { TEST(TestDictionaryUnifier, TableZeroColumns) { auto schema = ::arrow::schema(FieldVector{}); - auto table = Table::Make(schema, ArrayVector{}, /*num_rows=*/42); + auto table = Table::Make(schema, ArrayVector{}, /*num_rows=*/42).ValueOrDie(); ASSERT_OK_AND_ASSIGN(auto unified, DictionaryUnifier::UnifyTable(*table)); AssertSchemaEqual(*schema, *unified->schema()); diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc index 5fa2d6824dc1..1dce0be26416 100644 --- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc +++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc @@ -2831,11 +2831,11 @@ TEST_F(TestDropNullKernelWithTable, DropNullTableWithSlices) { ChunkedArrayVector table_content_w_slices{ std::make_shared(std::move(slices_a)), std::make_shared(std::move(slices_b))}; - *out_table_w_slices = Table::Make(schm, std::move(table_content_w_slices), size); + *out_table_w_slices = Table::Make(schm, std::move(table_content_w_slices), size).ValueOrDie(); ChunkedArrayVector table_content_wo_slices{std::make_shared(col_a), std::make_shared(col_b)}; - *out_table_wo_slices = Table::Make(schm, std::move(table_content_wo_slices), size); + *out_table_wo_slices = Table::Make(schm, std::move(table_content_wo_slices), size).ValueOrDie(); }); // Without Null Arrays @@ -2854,11 +2854,11 @@ TEST_F(TestDropNullKernelWithTable, DropNullTableWithSlices) { ChunkedArrayVector table_content_w_slices{ std::make_shared(std::move(slices_a)), std::make_shared(std::move(slices_b))}; - *out_table_w_slices = Table::Make(schm, std::move(table_content_w_slices), size); + *out_table_w_slices = Table::Make(schm, std::move(table_content_w_slices), size).ValueOrDie(); ChunkedArrayVector table_content_wo_slices{std::make_shared(col_a), std::make_shared(col_b)}; - *out_table_wo_slices = Table::Make(schm, std::move(table_content_wo_slices), size); + *out_table_wo_slices = Table::Make(schm, std::move(table_content_wo_slices), size).ValueOrDie(); }); } diff --git a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc index 787b32b63630..c9d8c296ffd0 100644 --- a/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc +++ b/cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc @@ -419,7 +419,7 @@ static void TableSortIndicesInt64(benchmark::State& state, int64_t min, int64_t TableSortIndicesArgs args(state); auto data = MakeBatchOrTableBenchmarkDataInt64(args, args.num_chunks, min, max); - auto table = Table::Make(data.schema, data.columns, args.num_records); + auto table = Table::Make(data.schema, data.columns, args.num_records).ValueOrDie(); SortOptions options(data.sort_keys); DatumSortIndicesBenchmark(state, Datum(*table), options); } diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc index 90f8eb7a56b9..1bb8316280a5 100644 --- a/cpp/src/arrow/compute/kernels/vector_sort_test.cc +++ b/cpp/src/arrow/compute/kernels/vector_sort_test.cc @@ -1748,7 +1748,7 @@ TEST_F(TestTableSortIndices, HeterogenousChunking) { ChunkedArrayFromJSON(float32(), {"[null, 1]", "[]", "[3, null, NaN, NaN, NaN, 1]"}); auto col_b = ChunkedArrayFromJSON(float64(), {"[5]", "[3, null, null]", "[null, NaN, 5]", "[5]"}); - auto table = Table::Make(schema, {col_a, col_b}); + auto table = Table::Make(schema, {col_a, col_b}).ValueOrDie(); SortOptions options( {SortKey("a", SortOrder::Ascending), SortKey("b", SortOrder::Descending)}); @@ -2062,7 +2062,7 @@ TEST_P(TestTableSortIndicesRandom, Sort) { ASSERT_EQ(columns.back()->length(), length); } - auto table = Table::Make(schema, std::move(columns)); + auto table = Table::Make(schema, std::move(columns)).ValueOrDie(); for (auto null_placement : AllNullPlacements()) { ARROW_SCOPED_TRACE("null_placement = ", null_placement); options.null_placement = null_placement; @@ -2165,7 +2165,7 @@ class TestNestedSortIndices : public ::testing::Test { auto chunked = GetChunkedArray(); auto columns = *chunked->Flatten(); auto table = - Table::Make(arrow::schema(chunked->type()->fields()), std::move(columns)); + Table::Make(arrow::schema(chunked->type()->fields()), std::move(columns)).ValueOrDie(); ARROW_CHECK_OK(table->ValidateFull()); return table; } diff --git a/cpp/src/arrow/dataset/file_parquet_encryption_test.cc b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc index 94a07624b6d8..514b06f7629b 100644 --- a/cpp/src/arrow/dataset/file_parquet_encryption_test.cc +++ b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc @@ -446,7 +446,7 @@ class NestedFieldsEncryptionTest void PrepareTableAndPartitioning() override { // Prepare table and partitioning. auto table_schema = schema({field("id", int8()), field("a", column_type_)}); - table_ = arrow::Table::Make(table_schema, {id_data_, column_data_}); + table_ = arrow::Table::Make(table_schema, {id_data_, column_data_}).ValueOrDie(); partitioning_ = std::make_shared(arrow::schema({})); } @@ -612,7 +612,7 @@ class LargeRowCountEncryptionTest auto table_schema = schema({field("a", float32())}); // Prepare table and partitioning. - table_ = arrow::Table::Make(table_schema, {column}); + table_ = arrow::Table::Make(table_schema, {column}).ValueOrDie(); partitioning_ = std::make_shared(arrow::schema({})); } }; diff --git a/cpp/src/arrow/datum.cc b/cpp/src/arrow/datum.cc index 399007809863..dbc3584ad7a9 100644 --- a/cpp/src/arrow/datum.cc +++ b/cpp/src/arrow/datum.cc @@ -63,7 +63,7 @@ Datum::Datum(const ChunkedArray& value) : value(std::make_shared(value.chunks(), value.type())) {} Datum::Datum(const Table& value) - : value(Table::Make(value.schema(), value.columns(), value.num_rows())) {} + : value(Table::Make(value.schema(), value.columns(), value.num_rows()).ValueOrDie()) {} Datum::Datum(const RecordBatch& value) : value(RecordBatch::Make(value.schema(), value.num_rows(), value.columns())) {} diff --git a/cpp/src/arrow/datum_test.cc b/cpp/src/arrow/datum_test.cc index 909d2577e68f..9f55d9fc294c 100644 --- a/cpp/src/arrow/datum_test.cc +++ b/cpp/src/arrow/datum_test.cc @@ -166,7 +166,7 @@ TEST(Datum, TotalBufferSize) { Datum chunked_datum(chunked_arr); std::shared_ptr schm = schema({field("a", int8())}); Datum rb_datum(RecordBatch::Make(schm, 4, {arr})); - Datum tab_datum(Table::Make(std::move(schm), {std::move(arr)}, 4)); + Datum tab_datum(Table::Make(std::move(schm), {std::move(arr)}, 4).ValueOrDie()); ASSERT_EQ(4, arr_datum.TotalBufferSize()); ASSERT_EQ(4, chunked_datum.TotalBufferSize()); diff --git a/cpp/src/arrow/field_ref_test.cc b/cpp/src/arrow/field_ref_test.cc index 25c8aa0b7162..053f87dae22d 100644 --- a/cpp/src/arrow/field_ref_test.cc +++ b/cpp/src/arrow/field_ref_test.cc @@ -196,7 +196,7 @@ struct FieldPathTestCase { } // Finalize the input Table out.table = - Table::Make(out.schema, {out.v0.chunked_array, out.v1.chunked_array}, kNumRows); + Table::Make(out.schema, {out.v0.chunked_array, out.v1.chunked_array}, kNumRows).ValueOrDie(); ARROW_RETURN_NOT_OK(out.table->ValidateFull()); return out; @@ -440,7 +440,7 @@ TEST_F(TestFieldPath, GetFromEmptyChunked) { for (const auto& f : fields) { table_columns.push_back(std::make_shared(ArrayVector{}, f->type())); } - auto table = Table::Make(schema(fields), table_columns, 0); + auto table = Table::Make(schema(fields), table_columns, 0).ValueOrDie(); ASSERT_OK(table->ValidateFull()); for (const auto& column : table->columns()) { ASSERT_EQ(column->num_chunks(), 0); @@ -535,7 +535,7 @@ TEST_F(TestFieldRef, FindAllForTable) { auto a2 = gen_.ArrayOf(int32(), kNumRows); auto a3 = gen_.ArrayOf(int32(), kNumRows); - auto table_ptr = Table::Make(schema, {a0, a1, a2, a3}); + auto table_ptr = Table::Make(schema, {a0, a1, a2, a3}).ValueOrDie(); ASSERT_OK(table_ptr->ValidateFull()); // lookup by index returns Indices{index} diff --git a/cpp/src/arrow/flight/sql/server_test.cc b/cpp/src/arrow/flight/sql/server_test.cc index 42e0c7d7a1f1..ca19315be4d4 100644 --- a/cpp/src/arrow/flight/sql/server_test.cc +++ b/cpp/src/arrow/flight/sql/server_test.cc @@ -189,8 +189,8 @@ TEST_F(TestFlightSqlServer, TestCommandStatementQuery) { const auto value_array = ArrayFromJSON(int64(), R"([1, 0, -1, null, null])"); const auto foreignId_array = ArrayFromJSON(int64(), R"([1, 1, 1, null, null])"); - const std::shared_ptr
& expected_table = Table::Make( - expected_schema, {id_array, keyname_array, value_array, foreignId_array}); + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( + expected_schema, {id_array, keyname_array, value_array, foreignId_array}})); AssertTablesEqual(*expected_table, *table); } @@ -219,8 +219,8 @@ TEST_F(TestFlightSqlServer, TestCommandGetTables) { ArrayFromJSON(utf8(), R"(["foreignTable", "intTable", "sqlite_sequence"])"); const auto table_type = ArrayFromJSON(utf8(), R"(["table", "table", "table"])"); - std::shared_ptr
expected_table = Table::Make( - SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type}); + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( + SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type})); AssertTablesEqual(*expected_table, *table); } @@ -247,8 +247,8 @@ TEST_F(TestFlightSqlServer, TestCommandGetTablesWithTableFilter) { const auto table_name = ArrayFromJSON(utf8(), R"(["intTable"])"); const auto table_type = ArrayFromJSON(utf8(), R"(["table"])"); - const std::shared_ptr
& expected_table = Table::Make( - SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type}); + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( + SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type})); AssertTablesEqual(*expected_table, *table); } @@ -300,8 +300,8 @@ TEST_F(TestFlightSqlServer, TestCommandGetTablesWithUnexistenceTableTypeFilter) ArrayFromJSON(utf8(), R"(["foreignTable", "intTable", "sqlite_sequence"])"); const auto table_type = ArrayFromJSON(utf8(), R"(["table", "table", "table"])"); - const std::shared_ptr
& expected_table = Table::Make( - SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type}); + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( + SqlSchema::GetTablesSchema(), {catalog_name, schema_name, table_name, table_type})); AssertTablesEqual(*expected_table, *table); } @@ -350,9 +350,9 @@ TEST_F(TestFlightSqlServer, TestCommandGetTablesWithIncludedSchemas) { std::shared_ptr table_schema; ArrayFromVector({schema_buffer->ToString()}, &table_schema); - const std::shared_ptr
& expected_table = + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make(SqlSchema::GetTablesSchemaWithIncludedSchema(), - {catalog_name, schema_name, table_name, table_type, table_schema}); + {catalog_name, schema_name, table_name, table_type, table_schema})); AssertTablesEqual(*expected_table, *table); } @@ -419,8 +419,8 @@ TEST_F(TestFlightSqlServer, TestCommandGetTableTypes) { const auto table_type = ArrayFromJSON(utf8(), R"(["table"])"); - const std::shared_ptr
& expected_table = - Table::Make(SqlSchema::GetTableTypesSchema(), {table_type}); + ASSERT_OK_AND_ASSIGN(auto expected_table, + Table::Make(SqlSchema::GetTableTypesSchema(), {table_type})); AssertTablesEqual(*expected_table, *table); } @@ -478,8 +478,8 @@ TEST_F(TestFlightSqlServer, TestCommandPreparedStatementQuery) { const auto value_array = ArrayFromJSON(int64(), R"([1, 0, -1, null, null])"); const auto foreignId_array = ArrayFromJSON(int64(), R"([1, 1, 1, null, null])"); - const std::shared_ptr
& expected_table = Table::Make( - expected_schema, {id_array, keyname_array, value_array, foreignId_array}); + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( + expected_schema, {id_array, keyname_array, value_array, foreignId_array}})); AssertTablesEqual(*expected_table, *table); } @@ -613,9 +613,9 @@ TEST_F(TestFlightSqlServer, TestCommandGetPrimaryKeys) { const auto column_name = ArrayFromJSON(utf8(), R"(["id"])"); const auto key_sequence = ArrayFromJSON(int32(), R"([1])"); - const std::shared_ptr
& expected_table = Table::Make( + ASSERT_OK_AND_ASSIGN(auto expected_table, Table::Make( SqlSchema::GetPrimaryKeysSchema(), - {catalog_name, schema_name, table_name, column_name, key_sequence, key_name}); + {catalog_name, schema_name, table_name, column_name, key_sequence, key_name})); AssertTablesEqual(*expected_table, *table); } @@ -644,11 +644,11 @@ TEST_F(TestFlightSqlServer, TestCommandGetImportedKeys) { const auto update_rule = ArrayFromJSON(uint8(), R"([3])"); const auto delete_rule = ArrayFromJSON(uint8(), R"([3])"); - const std::shared_ptr
& expected_table = + const std::shared_ptr
expected_table = Table::Make(SqlSchema::GetImportedKeysSchema(), {pk_catalog_name, pk_schema_name, pk_table_name, pk_column_name, fk_catalog_name, fk_schema_name, fk_table_name, fk_column_name, - key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}); + key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}).ValueOrDie(); AssertTablesEqual(*expected_table, *table); } @@ -676,11 +676,11 @@ TEST_F(TestFlightSqlServer, TestCommandGetExportedKeys) { const auto update_rule = ArrayFromJSON(uint8(), R"([3])"); const auto delete_rule = ArrayFromJSON(uint8(), R"([3])"); - const std::shared_ptr
& expected_table = + const std::shared_ptr
expected_table = Table::Make(SqlSchema::GetExportedKeysSchema(), {pk_catalog_name, pk_schema_name, pk_table_name, pk_column_name, fk_catalog_name, fk_schema_name, fk_table_name, fk_column_name, - key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}); + key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}).ValueOrDie(); AssertTablesEqual(*expected_table, *table); } @@ -710,11 +710,11 @@ TEST_F(TestFlightSqlServer, TestCommandGetCrossReference) { const auto update_rule = ArrayFromJSON(uint8(), R"([3])"); const auto delete_rule = ArrayFromJSON(uint8(), R"([3])"); - const std::shared_ptr
& expected_table = + const std::shared_ptr
expected_table = Table::Make(SqlSchema::GetCrossReferenceSchema(), {pk_catalog_name, pk_schema_name, pk_table_name, pk_column_name, fk_catalog_name, fk_schema_name, fk_table_name, fk_column_name, - key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}); + key_sequence, fk_key_name, pk_key_name, update_rule, delete_rule}).ValueOrDie(); AssertTablesEqual(*expected_table, *table); } diff --git a/cpp/src/arrow/ipc/feather.cc b/cpp/src/arrow/ipc/feather.cc index f6c6f342a099..628521bd8664 100644 --- a/cpp/src/arrow/ipc/feather.cc +++ b/cpp/src/arrow/ipc/feather.cc @@ -342,7 +342,7 @@ class ReaderV1 : public Reader { columns.emplace_back(); RETURN_NOT_OK(GetColumn(i, &columns.back())); } - *out = Table::Make(this->schema(), std::move(columns), this->num_rows()); + ARROW_ASSIGN_OR_RAISE(*out, Table::Make(this->schema(), std::move(columns), this->num_rows())); return Status::OK(); } @@ -359,8 +359,9 @@ class ReaderV1 : public Reader { RETURN_NOT_OK(GetColumn(field_index, &columns.back())); fields.push_back(my_schema->field(field_index)); } - *out = Table::Make(::arrow::schema(std::move(fields)), std::move(columns), - this->num_rows()); + ARROW_ASSIGN_OR_RAISE( + *out, Table::Make(::arrow::schema(std::move(fields)), std::move(columns), + this->num_rows())); return Status::OK(); } @@ -379,8 +380,9 @@ class ReaderV1 : public Reader { RETURN_NOT_OK(GetColumn(field_index, &columns.back())); fields.push_back(sch->field(field_index)); } - *out = Table::Make(::arrow::schema(std::move(fields)), std::move(columns), - this->num_rows()); + ARROW_ASSIGN_OR_RAISE( + *out, Table::Make(::arrow::schema(std::move(fields)), std::move(columns), + this->num_rows())); return Status::OK(); } diff --git a/cpp/src/arrow/ipc/feather_test.cc b/cpp/src/arrow/ipc/feather_test.cc index e1dc6046a110..40aa115cb676 100644 --- a/cpp/src/arrow/ipc/feather_test.cc +++ b/cpp/src/arrow/ipc/feather_test.cc @@ -175,7 +175,8 @@ TEST_P(TestFeather, ReadIndicesOrNames) { DoWrite(*table); // int32 type is at the column f4 of the result of MakeIntRecordBatch - auto expected = Table::Make(schema({field("f4", int32())}), {batch1->column(4)}); + auto expected = + Table::Make(schema({field("f4", int32())}), {batch1->column(4)}).ValueOrDie(); std::shared_ptr
result1, result2; @@ -190,7 +191,7 @@ TEST_P(TestFeather, ReadIndicesOrNames) { TEST_P(TestFeather, EmptyTable) { std::vector> columns; - auto table = Table::Make(schema({}), columns, 0); + auto table = Table::Make(schema({}), columns, 0).ValueOrDie(); DoWrite(*table); @@ -201,7 +202,7 @@ TEST_P(TestFeather, EmptyTable) { TEST_P(TestFeather, SetNumRows) { std::vector> columns; - auto table = Table::Make(schema({}), columns, 1000); + auto table = Table::Make(schema({}), columns, 1000).ValueOrDie(); DoWrite(*table); std::shared_ptr
result; ASSERT_OK(reader_->Read(&result)); diff --git a/cpp/src/arrow/json/reader_test.cc b/cpp/src/arrow/json/reader_test.cc index a52626413d68..8a7567ec7628 100644 --- a/cpp/src/arrow/json/reader_test.cc +++ b/cpp/src/arrow/json/reader_test.cc @@ -86,7 +86,7 @@ TEST_P(ReaderTest, Empty) { SetUpReader("{}\n{}\n"); ASSERT_OK_AND_ASSIGN(table_, reader_->Read()); - auto expected_table = Table::Make(schema({}), ArrayVector(), 2); + auto expected_table = Table::Make(schema({}), ArrayVector(), 2).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -94,7 +94,7 @@ TEST_P(ReaderTest, EmptyNoNewlineAtEnd) { SetUpReader("{}\n{}"); ASSERT_OK_AND_ASSIGN(table_, reader_->Read()); - auto expected_table = Table::Make(schema({}), ArrayVector(), 2); + auto expected_table = Table::Make(schema({}), ArrayVector(), 2).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -102,7 +102,7 @@ TEST_P(ReaderTest, EmptyManyNewlines) { SetUpReader("{}\n\r\n{}\n\r\n"); ASSERT_OK_AND_ASSIGN(table_, reader_->Read()); - auto expected_table = Table::Make(schema({}), ArrayVector(), 2); + auto expected_table = Table::Make(schema({}), ArrayVector(), 2).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -121,7 +121,7 @@ TEST_P(ReaderTest, Basics) { ArrayFromJSON(schema->field(1)->type(), "[false, null, null, true]"), ArrayFromJSON(schema->field(2)->type(), "[\"thing\", null, \"\xe5\xbf\x8d\", null]"), - }); + }).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -142,7 +142,7 @@ TEST_P(ReaderTest, Nested) { auto a3 = ArrayFromJSON(schema->field(3)->type(), "[[1, 2, 3], [2], [], null]"); auto a4 = ArrayFromJSON(schema->field(4)->type(), R"([{"ps":null}, null, {"ps":78}, {"ps":90}])"); - auto expected_table = Table::Make(schema, {a0, a1, a2, a3, a4}); + auto expected_table = Table::Make(schema, {a0, a1, a2, a3, a4}).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -173,7 +173,7 @@ TEST_P(ReaderTest, PartialSchema) { ArrayFromJSON(schema->field(3)->type(), "[false, null, null, true]"), ArrayFromJSON(schema->field(4)->type(), "[\"thing\", null, \"\xe5\xbf\x8d\", null]"), - }); + }).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -191,7 +191,7 @@ TEST_P(ReaderTest, TypeInference) { auto expected_table = Table::Make( schema, {ArrayFromJSON(schema->field(0)->type(), R"([null, "1970-01-01", "2018-11-13 17:11:10"])"), - ArrayFromJSON(schema->field(1)->type(), R"([null, 3, 3.125])")}); + ArrayFromJSON(schema->field(1)->type(), R"([null, 3, 3.125])")}).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } @@ -215,7 +215,7 @@ TEST_P(ReaderTest, MultipleChunks) { ChunkedFromJSON(schema->field(1), {"[false]", "[null]", "[null, true]", "[]"}), ChunkedFromJSON(schema->field(2), {"[\"thing\"]", "[null]", "[\"\xe5\xbf\x8d\", null]", "[]"}), - }); + }).ValueOrDie(); AssertTablesEqual(*expected_table, *table_); } diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc index c90b03bbda38..c5cb6270cbca 100644 --- a/cpp/src/arrow/pretty_print_test.cc +++ b/cpp/src/arrow/pretty_print_test.cc @@ -1365,7 +1365,7 @@ TEST_F(TestPrettyPrint, TablePrimitive) { auto array = ArrayFromJSON(int_field->type(), "[0, 1, null, 3, null]"); auto column = std::make_shared(ArrayVector({array})); std::shared_ptr table_schema = schema({int_field}); - std::shared_ptr
table = Table::Make(table_schema, {column}); + std::shared_ptr
table = Table::Make(table_schema, {column}).ValueOrDie(); static const char* expected = R"expected(column: int32 ---- diff --git a/cpp/src/arrow/stl.h b/cpp/src/arrow/stl.h index 2a9e4bdf77eb..59405fbb1e5e 100644 --- a/cpp/src/arrow/stl.h +++ b/cpp/src/arrow/stl.h @@ -452,9 +452,7 @@ Status TableFromTupleRange(MemoryPool* pool, Range&& rows, arrays.emplace_back(array); } - *table = Table::Make(std::move(schema), std::move(arrays)); - - return Status::OK(); + return Table::Make(std::move(schema), std::move(arrays)).Value(table); } template diff --git a/cpp/src/arrow/stl_test.cc b/cpp/src/arrow/stl_test.cc index ce5adf0c0e26..29f25702c3fb 100644 --- a/cpp/src/arrow/stl_test.cc +++ b/cpp/src/arrow/stl_test.cc @@ -222,7 +222,7 @@ TEST(TestTableFromTupleVector, PrimitiveTypes) { auto expected_table = Table::Make(expected_schema, {int8_array, int16_array, int32_array, int64_array, uint8_array, - uint16_array, uint32_array, uint64_array, bool_array, string_array}); + uint16_array, uint32_array, uint64_array, bool_array, string_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -234,7 +234,7 @@ TEST(TestTableFromTupleVector, ListType) { std::make_shared(FieldVector{field("column1", list(int64()), false)}); std::shared_ptr expected_array = ArrayFromJSON(list(int64()), "[[1, 1, 2, 34], [2, -4]]"); - std::shared_ptr
expected_table = Table::Make(expected_schema, {expected_array}); + std::shared_ptr
expected_table = Table::Make(expected_schema, {expected_array}).ValueOrDie(); std::vector rows{tuple_type(std::vector{1, 1, 2, 34}), tuple_type(std::vector{2, -4})}; @@ -252,7 +252,7 @@ TEST(TestTableFromTupleVector, FixedSizeListType) { FieldVector{field("column1", fixed_size_list(int64(), 4), false)}); std::shared_ptr expected_array = ArrayFromJSON(fixed_size_list(int64(), 4), "[[1, 1, 2, 34], [2, -4, 1, 1]]"); - std::shared_ptr
expected_table = Table::Make(expected_schema, {expected_array}); + std::shared_ptr
expected_table = Table::Make(expected_schema, {expected_array}).ValueOrDie(); std::vector rows{tuple_type(std::array{1, 1, 2, 34}), tuple_type(std::array{2, -4, 1, 1})}; @@ -299,7 +299,7 @@ TEST(TestTableFromTupleVector, ReferenceTuple) { auto expected_table = Table::Make(expected_schema, {int8_array, int16_array, int32_array, int64_array, uint8_array, - uint16_array, uint32_array, uint64_array, bool_array, string_array}); + uint16_array, uint32_array, uint64_array, bool_array, string_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -339,7 +339,7 @@ TEST(TestTableFromTupleVector, NullableTypesWithBoostOptional) { auto expected_table = Table::Make(expected_schema, {int8_array, int16_array, int32_array, int64_array, uint8_array, - uint16_array, uint32_array, uint64_array, bool_array, string_array}); + uint16_array, uint32_array, uint64_array, bool_array, string_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -388,7 +388,7 @@ TEST(TestTableFromTupleVector, NullableTypesWithRawPointer) { auto expected_table = Table::Make(expected_schema, {int8_array, int16_array, int32_array, int64_array, uint8_array, - uint16_array, uint32_array, uint64_array, bool_array, string_array}); + uint16_array, uint32_array, uint64_array, bool_array, string_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -402,7 +402,7 @@ TEST(TestTableFromTupleVector, NullableTypesDoNotBreakUserSpecialization) { std::shared_ptr expected_schema = schema({field("column1", utf8(), true)}); std::shared_ptr string_array = ArrayFromJSON(utf8(), R"([null, "mock yes", "mock no"])"); - auto expected_table = Table::Make(expected_schema, {string_array}); + auto expected_table = Table::Make(expected_schema, {string_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -421,7 +421,7 @@ TEST(TestTableFromTupleVector, AppendingMultipleRows) { schema({field("column1", list(int32()), false)}); std::shared_ptr int_array = ArrayFromJSON(list(int32()), "[[1, 2, 3], [10, 20, 30]]"); - auto expected_table = Table::Make(expected_schema, {int_array}); + auto expected_table = Table::Make(expected_schema, {int_array}).ValueOrDie(); ASSERT_TRUE(expected_table->Equals(*table)); } @@ -454,7 +454,7 @@ TEST(TestTupleVectorFromTable, PrimitiveTypes) { auto string_array = ArrayFromJSON(utf8(), R"(["Tests", "Other"])"); auto table = Table::Make( schema, {int8_array, int16_array, int32_array, int64_array, uint8_array, - uint16_array, uint32_array, uint64_array, bool_array, string_array}); + uint16_array, uint32_array, uint64_array, bool_array, string_array}).ValueOrDie(); std::vector rows(2); ASSERT_OK(TupleRangeFromTable(*table, cast_options, &ctx, &rows)); @@ -478,7 +478,7 @@ TEST(TestTupleVectorFromTable, ListType) { std::make_shared(FieldVector{field("column1", list(int64()), false)}); std::shared_ptr expected_array = ArrayFromJSON(list(int64()), "[[1, 1, 2, 34], [2, -4]]"); - std::shared_ptr
table = Table::Make(expected_schema, {expected_array}); + std::shared_ptr
table = Table::Make(expected_schema, {expected_array}).ValueOrDie(); std::vector expected_rows{tuple_type(std::vector{1, 1, 2, 34}), tuple_type(std::vector{2, -4})}; @@ -497,7 +497,7 @@ TEST(TestTupleVectorFromTable, FixedSizeListType) { FieldVector{field("column1", fixed_size_list(int64(), 4), false)}); std::shared_ptr expected_array = ArrayFromJSON(fixed_size_list(int64(), 4), "[[1, 1, 2, 34], [2, -4, 1, 1]]"); - std::shared_ptr
table = Table::Make(expected_schema, {expected_array}); + std::shared_ptr
table = Table::Make(expected_schema, {expected_array}).ValueOrDie(); ASSERT_OK(table->ValidateFull()); std::vector expected_rows{tuple_type(std::array{1, 1, 2, 34}), @@ -517,7 +517,7 @@ TEST(TestTupleVectorFromTable, CastingNeeded) { std::make_shared(FieldVector{field("column1", list(int16()), false)}); std::shared_ptr expected_array = ArrayFromJSON(list(int16()), "[[1, 1, 2, 34], [2, -4]]"); - std::shared_ptr
table = Table::Make(expected_schema, {expected_array}); + std::shared_ptr
table = Table::Make(expected_schema, {expected_array}).ValueOrDie(); std::vector expected_rows{tuple_type(std::vector{1, 1, 2, 34}), tuple_type(std::vector{2, -4})}; diff --git a/cpp/src/arrow/table.cc b/cpp/src/arrow/table.cc index 68a8a1951f1c..018a692b1473 100644 --- a/cpp/src/arrow/table.cc +++ b/cpp/src/arrow/table.cc @@ -105,7 +105,7 @@ class SimpleTable : public Table { column = column->Slice(offset, length); num_rows = column->length(); } - return Table::Make(schema_, std::move(sliced), num_rows); + return Table::Make(schema_, std::move(sliced), num_rows).ValueOrDie(); } Result> RemoveColumn(int i) const override { @@ -118,7 +118,9 @@ class SimpleTable : public Table { Result> AddColumn( int i, std::shared_ptr field_arg, std::shared_ptr col) const override { - DCHECK(col != nullptr); + if (col == nullptr) { + return Status::Invalid("Column should not be null"); + } if (col->length() != num_rows_) { return Status::Invalid( @@ -138,7 +140,9 @@ class SimpleTable : public Table { Result> SetColumn( int i, std::shared_ptr field_arg, std::shared_ptr col) const override { - DCHECK(col != nullptr); + if (col == nullptr) { + return Status::Invalid("Column should not be null"); + } if (col->length() != num_rows_) { return Status::Invalid( @@ -158,7 +162,7 @@ class SimpleTable : public Table { std::shared_ptr
ReplaceSchemaMetadata( const std::shared_ptr& metadata) const override { auto new_schema = schema_->WithMetadata(metadata); - return Table::Make(std::move(new_schema), columns_); + return Table::Make(std::move(new_schema), columns_).ValueOrDie(); } Result> Flatten(MemoryPool* pool) const override { @@ -257,15 +261,31 @@ std::vector> Table::fields() const { return result; } -std::shared_ptr
Table::Make(std::shared_ptr schema, - std::vector> columns, - int64_t num_rows) { +Result> Table::Make(std::shared_ptr schema, + std::vector> columns, + int64_t num_rows) { + if (schema->num_fields() != static_cast(columns.size())) { + return Status::Invalid("Schema and columns have different number of fields: ", + schema->num_fields(), " vs ", columns.size()); + } + if (std::any_of(columns.begin(), columns.end(), + [](const auto& column) { return !column; })) { + return Status::Invalid("Column should not be null"); + } return std::make_shared(std::move(schema), std::move(columns), num_rows); } -std::shared_ptr
Table::Make(std::shared_ptr schema, - const std::vector>& arrays, - int64_t num_rows) { +Result> Table::Make(std::shared_ptr schema, + const std::vector>& arrays, + int64_t num_rows) { + if (schema->num_fields() != static_cast(arrays.size())) { + return Status::Invalid("Schema and arrays have different number of fields: ", + schema->num_fields(), " vs ", arrays.size()); + } + if (std::any_of(arrays.begin(), arrays.end(), + [](const auto& array) { return !array; })) { + return Status::Invalid("Array should not be null"); + } return std::make_shared(std::move(schema), arrays, num_rows); } diff --git a/cpp/src/arrow/table.h b/cpp/src/arrow/table.h index dee6f6fdd3cb..f89293ac1489 100644 --- a/cpp/src/arrow/table.h +++ b/cpp/src/arrow/table.h @@ -51,18 +51,18 @@ class ARROW_EXPORT Table { /// \param[in] schema The table schema (column types) /// \param[in] columns The table's columns as chunked arrays /// \param[in] num_rows number of rows in table, -1 (default) to infer from columns - static std::shared_ptr
Make(std::shared_ptr schema, - std::vector> columns, - int64_t num_rows = -1); + static Result> Make(std::shared_ptr schema, + std::vector> columns, + int64_t num_rows = -1); /// \brief Construct a Table from schema and arrays /// /// \param[in] schema The table schema (column types) /// \param[in] arrays The table's columns as arrays /// \param[in] num_rows number of rows in table, -1 (default) to infer from columns - static std::shared_ptr
Make(std::shared_ptr schema, - const std::vector>& arrays, - int64_t num_rows = -1); + static Result> Make(std::shared_ptr schema, + const std::vector>& arrays, + int64_t num_rows = -1); /// \brief Create an empty Table of a given schema /// diff --git a/cpp/src/arrow/table_test.cc b/cpp/src/arrow/table_test.cc index 692671910b89..cc6488fd1ed0 100644 --- a/cpp/src/arrow/table_test.cc +++ b/cpp/src/arrow/table_test.cc @@ -67,9 +67,24 @@ class TestTable : public ::testing::Test { std::vector> columns_; }; +TEST_F(TestTable, MakeInvalidInputs) { + auto schema = ::arrow::schema({field("f0", int8())}); + + // Null column + std::vector> arrays = {nullptr}; + ASSERT_RAISES(Invalid, Table::Make(schema, arrays)); + + std::vector> chunked_arrays = {nullptr}; + ASSERT_RAISES(Invalid, Table::Make(schema, chunked_arrays)); + + // Mismatched field count + ASSERT_RAISES(Invalid, Table::Make(schema, std::vector>{})); + ASSERT_RAISES(Invalid, Table::Make(schema, std::vector>{})); +} + TEST_F(TestTable, EmptySchema) { auto empty_schema = ::arrow::schema({}); - table_ = Table::Make(empty_schema, columns_); + table_ = Table::Make(empty_schema, columns_).ValueOrDie(); ASSERT_OK(table_->ValidateFull()); ASSERT_EQ(0, table_->num_rows()); ASSERT_EQ(0, table_->num_columns()); @@ -79,19 +94,19 @@ TEST_F(TestTable, Ctors) { const int length = 100; MakeExample1(length); - table_ = Table::Make(schema_, columns_); + table_ = Table::Make(schema_, columns_).ValueOrDie(); ASSERT_OK(table_->ValidateFull()); ASSERT_EQ(length, table_->num_rows()); ASSERT_EQ(3, table_->num_columns()); - auto array_ctor = Table::Make(schema_, arrays_); + auto array_ctor = Table::Make(schema_, arrays_).ValueOrDie(); ASSERT_TRUE(table_->Equals(*array_ctor)); - table_ = Table::Make(schema_, columns_, length); + table_ = Table::Make(schema_, columns_, length).ValueOrDie(); ASSERT_OK(table_->ValidateFull()); ASSERT_EQ(length, table_->num_rows()); - table_ = Table::Make(schema_, arrays_); + table_ = Table::Make(schema_, arrays_).ValueOrDie(); ASSERT_OK(table_->ValidateFull()); ASSERT_EQ(length, table_->num_rows()); ASSERT_EQ(3, table_->num_columns()); @@ -101,7 +116,7 @@ TEST_F(TestTable, Metadata) { const int length = 100; MakeExample1(length); - table_ = Table::Make(schema_, columns_); + table_ = Table::Make(schema_, columns_).ValueOrDie(); ASSERT_TRUE(table_->schema()->Equals(*schema_)); @@ -114,26 +129,25 @@ TEST_F(TestTable, InvalidColumns) { const int length = 100; MakeExample1(length); - table_ = Table::Make(schema_, columns_, length - 1); + table_ = Table::Make(schema_, columns_, length - 1).ValueOrDie(); ASSERT_RAISES(Invalid, table_->ValidateFull()); // Wrong number of columns columns_.clear(); - table_ = Table::Make(schema_, columns_, length); - ASSERT_RAISES(Invalid, table_->ValidateFull()); + ASSERT_RAISES(Invalid, Table::Make(schema_, columns_, length)); columns_ = {std::make_shared(gen_.ArrayOf(int32(), length)), std::make_shared(gen_.ArrayOf(uint8(), length)), std::make_shared(gen_.ArrayOf(int16(), length - 1))}; - table_ = Table::Make(schema_, columns_, length); + table_ = Table::Make(schema_, columns_, length).ValueOrDie(); ASSERT_RAISES(Invalid, table_->ValidateFull()); } TEST_F(TestTable, AllColumnsAndFields) { const int length = 100; MakeExample1(length); - table_ = Table::Make(schema_, columns_); + table_ = Table::Make(schema_, columns_).ValueOrDie(); auto columns = table_->columns(); auto fields = table_->fields(); @@ -145,7 +159,7 @@ TEST_F(TestTable, AllColumnsAndFields) { // Zero length std::vector> t2_columns; - auto t2 = Table::Make(::arrow::schema({}), t2_columns); + auto t2 = Table::Make(::arrow::schema({}), t2_columns).ValueOrDie(); columns = t2->columns(); fields = t2->fields(); @@ -176,13 +190,13 @@ TEST(TestTableEquality, Equals) { auto a_f1_different = gen.ArrayOf(uint8(), length); auto a_f2_different = gen.ArrayOf(uint16(), length); - auto table = Table::Make(schema, {a_f0, a_f1, a_f2}, length); - auto table_same = Table::Make(schema_same, {a_f0, a_f1, a_f2}, length); - auto table_fewer_fields = Table::Make(schema_fewer_fields, {a_f0, a_f1}, length); + auto table = Table::Make(schema, {a_f0, a_f1, a_f2}, length).ValueOrDie(); + auto table_same = Table::Make(schema_same, {a_f0, a_f1, a_f2}, length).ValueOrDie(); + auto table_fewer_fields = Table::Make(schema_fewer_fields, {a_f0, a_f1}, length).ValueOrDie(); auto table_half = - Table::Make(schema_fewer_fields, {a_f0_half, a_f1_half, a_f2_half}, length / 2); + Table::Make(schema_fewer_fields, {a_f0_half, a_f1_half, a_f2_half}, length / 2).ValueOrDie(); auto table_different = Table::Make( - schema_fewer_fields, {a_f0_different, a_f1_different, a_f2_different}, length); + schema_fewer_fields, {a_f0_different, a_f1_different, a_f2_different}, length).ValueOrDie(); // Same Values ASSERT_TRUE(table->Equals(*table_same)); @@ -219,11 +233,11 @@ TEST(TestTableEquality, MetadataAndSchema) { auto a_f2_renamed = a_f2; // All Tables have the same values but different schemas. - auto table = Table::Make(schema, {a_f0, a_f1, a_f2}, length); + auto table = Table::Make(schema, {a_f0, a_f1, a_f2}, length).ValueOrDie(); auto table_with_metadata = - Table::Make(schema_with_metadata, {a_f0, a_f1, a_f2}, length); + Table::Make(schema_with_metadata, {a_f0, a_f1, a_f2}, length).ValueOrDie(); auto table_renamed_field = - Table::Make(schema_renamed_field, {a_f0, a_f1, a_f2_renamed}, length); + Table::Make(schema_renamed_field, {a_f0, a_f1, a_f2_renamed}, length).ValueOrDie(); auto options = EqualOptions::Defaults(); @@ -381,7 +395,7 @@ TEST_F(TestTable, FromRecordBatches) { ASSERT_OK_AND_ASSIGN(auto result, Table::FromRecordBatches({batch1})); - auto expected = Table::Make(schema_, columns_); + auto expected = Table::Make(schema_, columns_).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); std::vector> other_columns; @@ -391,7 +405,7 @@ TEST_F(TestTable, FromRecordBatches) { } ASSERT_OK_AND_ASSIGN(result, Table::FromRecordBatches({batch1, batch1})); - expected = Table::Make(schema_, other_columns); + expected = Table::Make(schema_, other_columns).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); // Error states @@ -524,7 +538,7 @@ std::shared_ptr
MakeTableWithOneNullFilledColumn( const std::string& column_name, const std::shared_ptr& data_type, const int length) { auto array_of_nulls = *MakeArrayOfNull(data_type, length); - return Table::Make(schema({field(column_name, data_type)}), {array_of_nulls}); + return Table::Make(schema({field(column_name, data_type)}), {array_of_nulls}).ValueOrDie(); } using TestPromoteTableToSchema = TestTable; @@ -534,7 +548,7 @@ TEST_F(TestPromoteTableToSchema, IdenticalSchema) { auto metadata = std::make_shared(std::vector{"foo"}, std::vector{"bar"}); MakeExample1(length); - std::shared_ptr
table = Table::Make(schema_, arrays_); + std::shared_ptr
table = Table::Make(schema_, arrays_).ValueOrDie(); ASSERT_OK_AND_ASSIGN(auto result, PromoteTableToSchema(table, schema_->WithMetadata(metadata))); @@ -553,7 +567,7 @@ TEST_F(TestPromoteTableToSchema, FieldsReorderedAfterPromotion) { schema_->fields().crend()); std::vector> reversed_arrays(arrays_.crbegin(), arrays_.crend()); - std::shared_ptr
table = Table::Make(schema(reversed_fields), reversed_arrays); + std::shared_ptr
table = Table::Make(schema(reversed_fields), reversed_arrays).ValueOrDie(); ASSERT_OK_AND_ASSIGN(auto result, PromoteTableToSchema(table, schema_)); @@ -578,7 +592,7 @@ TEST_F(TestPromoteTableToSchema, PromoteNullTypeField) { TEST_F(TestPromoteTableToSchema, AddMissingField) { const int length = 10; auto f0 = field("f0", int32()); - auto table = Table::Make(schema({}), std::vector>(), length); + auto table = Table::Make(schema({}), std::vector>(), length).ValueOrDie(); auto promoted_schema = schema({field("field", int32())}); ASSERT_OK_AND_ASSIGN(auto result, PromoteTableToSchema(table, promoted_schema)); @@ -611,7 +625,7 @@ TEST_F(TestPromoteTableToSchema, DuplicateFieldNames) { const int length = 10; auto table = Table::Make(schema({field("field", int32()), field("field", null())}), - {gen_.ArrayOf(int32(), length), gen_.ArrayOf(null(), length)}); + {gen_.ArrayOf(int32(), length), gen_.ArrayOf(null(), length)}).ValueOrDie(); ASSERT_RAISES(Invalid, PromoteTableToSchema(table, schema({field("field", int32())}))); } @@ -620,7 +634,7 @@ TEST_F(TestPromoteTableToSchema, TableFieldAbsentFromSchema) { const int length = 10; auto table = - Table::Make(schema({field("f0", int32())}), {gen_.ArrayOf(int32(), length)}); + Table::Make(schema({field("f0", int32())}), {gen_.ArrayOf(int32(), length)}).ValueOrDie(); std::shared_ptr
result; ASSERT_RAISES(Invalid, PromoteTableToSchema(table, schema({field("f1", int32())}))); @@ -745,7 +759,7 @@ TEST_F(TestTable, RemoveColumn) { const int64_t length = 10; MakeExample1(length); - auto table_sp = Table::Make(schema_, columns_); + auto table_sp = Table::Make(schema_, columns_).ValueOrDie(); const Table& table = *table_sp; ASSERT_OK_AND_ASSIGN(auto result, table.RemoveColumn(0)); @@ -754,20 +768,20 @@ TEST_F(TestTable, RemoveColumn) { std::vector> ex_columns = {table.column(1), table.column(2)}; - auto expected = Table::Make(ex_schema, ex_columns); + auto expected = Table::Make(ex_schema, ex_columns).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); ASSERT_OK_AND_ASSIGN(result, table.RemoveColumn(1)); ex_schema = ::arrow::schema({schema_->field(0), schema_->field(2)}); ex_columns = {table.column(0), table.column(2)}; - expected = Table::Make(ex_schema, ex_columns); + expected = Table::Make(ex_schema, ex_columns).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); ASSERT_OK_AND_ASSIGN(result, table.RemoveColumn(2)); ex_schema = ::arrow::schema({schema_->field(0), schema_->field(1)}); ex_columns = {table.column(0), table.column(1)}; - expected = Table::Make(ex_schema, ex_columns); + expected = Table::Make(ex_schema, ex_columns).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); } @@ -775,7 +789,7 @@ TEST_F(TestTable, SetColumn) { const int64_t length = 10; MakeExample1(length); - auto table_sp = Table::Make(schema_, columns_); + auto table_sp = Table::Make(schema_, columns_).ValueOrDie(); const Table& table = *table_sp; ASSERT_OK_AND_ASSIGN(auto result, @@ -785,13 +799,16 @@ TEST_F(TestTable, SetColumn) { ::arrow::schema({schema_->field(1), schema_->field(1), schema_->field(2)}); auto expected = - Table::Make(ex_schema, {table.column(1), table.column(1), table.column(2)}); + Table::Make(ex_schema, {table.column(1), table.column(1), table.column(2)}).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); + + // Set null column + ASSERT_RAISES(Invalid, table.SetColumn(0, schema_->field(1), nullptr)); } TEST_F(TestTable, RenameColumns) { MakeExample1(10); - auto table = Table::Make(schema_, columns_); + auto table = Table::Make(schema_, columns_).ValueOrDie(); EXPECT_THAT(table->ColumnNames(), testing::ElementsAre("f0", "f1", "f2")); ASSERT_OK_AND_ASSIGN(auto renamed, table->RenameColumns({"zero", "one", "two"})); @@ -803,13 +820,13 @@ TEST_F(TestTable, RenameColumns) { TEST_F(TestTable, SelectColumns) { MakeExample1(10); - auto table = Table::Make(schema_, columns_); + auto table = Table::Make(schema_, columns_).ValueOrDie(); ASSERT_OK_AND_ASSIGN(auto subset, table->SelectColumns({0, 2})); ASSERT_OK(subset->ValidateFull()); auto expected_schema = ::arrow::schema({schema_->field(0), schema_->field(2)}); - auto expected = Table::Make(expected_schema, {table->column(0), table->column(2)}); + auto expected = Table::Make(expected_schema, {table->column(0), table->column(2)}).ValueOrDie(); ASSERT_TRUE(subset->Equals(*expected)); // Out of bounds indices @@ -825,7 +842,7 @@ TEST_F(TestTable, RemoveColumnEmpty) { auto schema = ::arrow::schema({f0}); auto a0 = gen_.ArrayOf(int32(), length); - auto table = Table::Make(schema, {std::make_shared(a0)}); + auto table = Table::Make(schema, {std::make_shared(a0)}).ValueOrDie(); ASSERT_OK_AND_ASSIGN(auto empty, table->RemoveColumn(0)); @@ -839,7 +856,7 @@ TEST_F(TestTable, AddColumn) { const int64_t length = 10; MakeExample1(length); - auto table_sp = Table::Make(schema_, columns_); + auto table_sp = Table::Make(schema_, columns_).ValueOrDie(); const Table& table = *table_sp; auto f0 = schema_->field(0); @@ -853,13 +870,16 @@ TEST_F(TestTable, AddColumn) { auto longer_col = std::make_shared(gen_.ArrayOf(int32(), length + 1)); ASSERT_RAISES(Invalid, table.AddColumn(0, f0, longer_col)); + // Add null column + ASSERT_RAISES(Invalid, table.AddColumn(0, f0, nullptr)); + // Add column 0 in different places - ASSERT_OK_AND_ASSIGN(auto result, table.AddColumn(0, f0, columns_[0])); + ASSERT_OK_AND_ASSIGN(auto result, table.AddColumn(0, f0, columns_[0]).ValueOrDie()); auto ex_schema = ::arrow::schema( {schema_->field(0), schema_->field(0), schema_->field(1), schema_->field(2)}); auto expected = Table::Make( - ex_schema, {table.column(0), table.column(0), table.column(1), table.column(2)}); + ex_schema, {table.column(0), table.column(0), table.column(1), table.column(2)}).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); ASSERT_OK_AND_ASSIGN(result, table.AddColumn(1, f0, columns_[0])); @@ -867,21 +887,21 @@ TEST_F(TestTable, AddColumn) { {schema_->field(0), schema_->field(0), schema_->field(1), schema_->field(2)}); expected = Table::Make( - ex_schema, {table.column(0), table.column(0), table.column(1), table.column(2)}); + ex_schema, {table.column(0), table.column(0), table.column(1), table.column(2)}).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); ASSERT_OK_AND_ASSIGN(result, table.AddColumn(2, f0, columns_[0])); ex_schema = ::arrow::schema( {schema_->field(0), schema_->field(1), schema_->field(0), schema_->field(2)}); expected = Table::Make( - ex_schema, {table.column(0), table.column(1), table.column(0), table.column(2)}); + ex_schema, {table.column(0), table.column(1), table.column(0), table.column(2)}).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); ASSERT_OK_AND_ASSIGN(result, table.AddColumn(3, f0, columns_[0])); ex_schema = ::arrow::schema( {schema_->field(0), schema_->field(1), schema_->field(2), schema_->field(0)}); expected = Table::Make( - ex_schema, {table.column(0), table.column(1), table.column(2), table.column(0)}); + ex_schema, {table.column(0), table.column(1), table.column(2), table.column(0)}).ValueOrDie(); ASSERT_TRUE(result->Equals(*expected)); } @@ -908,7 +928,7 @@ TEST_F(TestTableBatchReader, ReadNext) { std::vector> arrays_2 = {a2, a2}; columns = {std::make_shared(arrays_1), std::make_shared(arrays_2)}; - auto t1 = Table::Make(sch1, columns); + auto t1 = Table::Make(sch1, columns).ValueOrDie(); TableBatchReader i1(*t1); @@ -928,7 +948,7 @@ TEST_F(TestTableBatchReader, ReadNext) { arrays_2 = {a4}; columns = {std::make_shared(arrays_1), std::make_shared(arrays_2)}; - auto t2 = Table::Make(sch1, columns); + auto t2 = Table::Make(sch1, columns).ValueOrDie(); TableBatchReader i2(*t2); @@ -951,7 +971,7 @@ TEST_F(TestTableBatchReader, Chunksize) { auto sch1 = arrow::schema({field("f1", int32())}); std::vector> arrays = {a1, a2, a3}; - auto t1 = Table::Make(sch1, {std::make_shared(arrays)}); + auto t1 = Table::Make(sch1, {std::make_shared(arrays)}).ValueOrDie(); TableBatchReader i1(*t1); @@ -980,7 +1000,7 @@ TEST_F(TestTableBatchReader, Chunksize) { TEST_F(TestTableBatchReader, NoColumns) { std::shared_ptr
table = - Table::Make(schema({}), std::vector>{}, 100); + Table::Make(schema({}), std::vector>{}, 100).ValueOrDie(); TableBatchReader reader(*table); reader.set_chunksize(60); @@ -999,7 +1019,7 @@ TEST_F(TestTableBatchReader, NoColumns) { TEST_F(TestTableBatchReader, OwnedTableNoColumns) { std::shared_ptr
table = - Table::Make(schema({}), std::vector>{}, 100); + Table::Make(schema({}), std::vector>{}, 100).ValueOrDie(); TableBatchReader reader(table); table.reset(); reader.set_chunksize(80); diff --git a/cpp/src/arrow/util/align_util_test.cc b/cpp/src/arrow/util/align_util_test.cc index 457cbbd30f4f..a589ee1fa595 100644 --- a/cpp/src/arrow/util/align_util_test.cc +++ b/cpp/src/arrow/util/align_util_test.cc @@ -331,7 +331,7 @@ TEST(EnsureAlignment, Table) { std::vector> fields = {f0, f1}; auto schema = ::arrow::schema({f0, f1}); - auto table = Table::Make(schema, {chunked_array_1, chunked_array_2}); + auto table = Table::Make(schema, {chunked_array_1, chunked_array_2}).ValueOrDie(); std::vector needs_alignment; ASSERT_EQ(util::CheckAlignment(*table, 2048, &needs_alignment), false); diff --git a/cpp/src/arrow/util/byte_size_test.cc b/cpp/src/arrow/util/byte_size_test.cc index 0aaf0a76a2a4..b2a85d59e783 100644 --- a/cpp/src/arrow/util/byte_size_test.cc +++ b/cpp/src/arrow/util/byte_size_test.cc @@ -97,7 +97,7 @@ TEST(TotalBufferSize, Table) { ASSERT_OK_AND_ASSIGN(std::shared_ptr c2, ChunkedArray::Make(std::move(c2_arrays))); std::shared_ptr schm = schema({field("a", int32()), field("b", int64())}); - std::shared_ptr
table = Table::Make(std::move(schm), {c1, c2}); + std::shared_ptr
table = Table::Make(std::move(schm), {c1, c2}).ValueOrDie(); ASSERT_EQ(5 * 10 * 4 + 10 * 5 * 8, TotalBufferSize(*table)); }