Skip to content

GH-49079: [C++] Fix null pointer dereference in SimpleTable constructor #49086

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

Open
AliRana30 wants to merge 2 commits into
base: main
Choose a base branch
from
Open

GH-49079: [C++] Fix null pointer dereference in SimpleTable constructor #49086

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
6188125
Refactor Table::Make to return Result and update call sites
Alirana2829 Feb 1, 2026
69f2ddb
Add tests for Table::Make invalid inputs and null columns in Add/SetC…
Alirana2829 Feb 1, 2026
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
2 changes: 1 addition & 1 deletion cpp/src/arrow/acero/hash_aggregate_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -273,7 +273,7 @@ Result<Datum> MakeGroupByOutput(const std::vector<ExecBatch>& output_batches,
sort_keys.emplace_back(static_cast<int>(i));
}
std::shared_ptr<Schema> key_schema = schema(std::move(key_fields));
std::shared_ptr<Table> key_table = Table::Make(std::move(key_schema), key_columns);
std::shared_ptr<Table> key_table = Table::Make(std::move(key_schema), key_columns).ValueOrDie();
Copy link
Member

@kou kou Feb 2, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Could you use ARROW_ASSIGN_OR_RAISE()?

Suggested change
std::shared_ptr<Table> key_table = Table::Make(std::move(key_schema), key_columns).ValueOrDie();
ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Table> key_table, Table::Make(std::move(key_schema), key_columns));

SortOptions sort_options(std::move(sort_keys));
ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Array> sort_indices,
SortIndices(key_table, sort_options));
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/acero/hash_join_node_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -906,7 +906,7 @@ std::shared_ptr<Table> HashJoinSimple(
fields[i] = std::make_shared<Field>("a" + std::to_string(i), result[i]->type(), true);
}
std::shared_ptr<Schema> schema = std::make_shared<Schema>(std::move(fields));
return Table::Make(schema, result, result[0]->length());
return Table::Make(schema, result, result[0]->length()).ValueOrDie();
}

Result<std::vector<ExecBatch>> HashJoinWithExecPlan(
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/adapters/orc/adapter.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -843,7 +843,7 @@ Result<std::unique_ptr<ORCFileWriter>> 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);
}

Expand Down
20 changes: 10 additions & 10 deletions cpp/src/arrow/adapters/orc/adapter_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -219,7 +219,7 @@ std::shared_ptr<Table> GenerateRandomTable(const std::shared_ptr<Schema>& 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<std::shared_ptr<Table>>& input_tables,
Expand Down Expand Up @@ -310,9 +310,9 @@ void AssertArrayWriteReadEqual(const std::shared_ptr<Array>& input_array,
auto input_chunked_array = std::make_shared<ChunkedArray>(input_array),
expected_output_chunked_array =
std::make_shared<ChunkedArray>(expected_output_array);
std::shared_ptr<Table> input_table = Table::Make(input_schema, {input_chunked_array}),
std::shared_ptr<Table> 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);
}

Expand Down Expand Up @@ -731,7 +731,7 @@ TEST_F(TestORCWriterTrivialNoConversion, writeFilledChunkAndSelectField) {
field("binary", binary()),
});
auto batch = rand.BatchOf(local_schema->fields(), 100);
std::shared_ptr<Table> table = Table::Make(local_schema, batch->columns());
std::shared_ptr<Table> 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);
Expand Down Expand Up @@ -857,7 +857,7 @@ class TestORCWriterWithConversion : public ::testing::Test {
for (int i = static_cast<int>(num_cols - 2); i < static_cast<int>(num_cols); i++) {
av[i] = CastFixedSizeBinaryArrayToBinaryArray(input_table->column(i)->chunk(0));
}
std::shared_ptr<Table> expected_output_table = Table::Make(output_schema, av);
std::shared_ptr<Table> expected_output_table = Table::Make(output_schema, av).ValueOrDie();
AssertTableWriteReadEqual(input_table, expected_output_table, max_size);
}

Expand Down Expand Up @@ -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<ChunkedArray>(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<ChunkedArray>(vect);
std::shared_ptr<Table> 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);
}
Expand All @@ -1148,8 +1148,8 @@ TEST_F(TestORCWriterMultipleWrite, MultipleWritesIncoherentSchema) {
auto array_int2 = rand.ArrayOf(int64(), num_rows, 0);
std::shared_ptr<Schema> input_schema2 = schema({field("col0", array_int2->type())});

std::shared_ptr<Table> input_table = Table::Make(input_schema, {array_int});
std::shared_ptr<Table> input_table2 = Table::Make(input_schema2, {array_int2});
std::shared_ptr<Table> input_table = Table::Make(input_schema, {array_int}).ValueOrDie();
std::shared_ptr<Table> 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();
Expand All @@ -1175,7 +1175,7 @@ TEST_F(TestORCWriterMultipleWrite, MultipleWritesIntFieldRecordBatch) {
}
auto expected_output_chunked_array = std::make_shared<ChunkedArray>(vect);
std::shared_ptr<Table> 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);
}
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/array/array_dict_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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());
Expand Down
8 changes: 4 additions & 4 deletions cpp/src/arrow/compute/kernels/vector_selection_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2831,11 +2831,11 @@ TEST_F(TestDropNullKernelWithTable, DropNullTableWithSlices) {
ChunkedArrayVector table_content_w_slices{
std::make_shared<ChunkedArray>(std::move(slices_a)),
std::make_shared<ChunkedArray>(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<ChunkedArray>(col_a),
std::make_shared<ChunkedArray>(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
Expand All @@ -2854,11 +2854,11 @@ TEST_F(TestDropNullKernelWithTable, DropNullTableWithSlices) {
ChunkedArrayVector table_content_w_slices{
std::make_shared<ChunkedArray>(std::move(slices_a)),
std::make_shared<ChunkedArray>(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<ChunkedArray>(col_a),
std::make_shared<ChunkedArray>(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();
});
}

Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/compute/kernels/vector_sort_benchmark.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand Down
6 changes: 3 additions & 3 deletions cpp/src/arrow/compute/kernels/vector_sort_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)});
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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;
}
Expand Down
4 changes: 2 additions & 2 deletions cpp/src/arrow/dataset/file_parquet_encryption_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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<dataset::DirectoryPartitioning>(arrow::schema({}));
}

Expand Down Expand Up @@ -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<dataset::DirectoryPartitioning>(arrow::schema({}));
}
};
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/datum.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,7 @@ Datum::Datum(const ChunkedArray& value)
: value(std::make_shared<ChunkedArray>(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())) {}
Expand Down
2 changes: 1 addition & 1 deletion cpp/src/arrow/datum_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -166,7 +166,7 @@ TEST(Datum, TotalBufferSize) {
Datum chunked_datum(chunked_arr);
std::shared_ptr<Schema> 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());
Expand Down
6 changes: 3 additions & 3 deletions cpp/src/arrow/field_ref_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -440,7 +440,7 @@ TEST_F(TestFieldPath, GetFromEmptyChunked) {
for (const auto& f : fields) {
table_columns.push_back(std::make_shared<ChunkedArray>(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);
Expand Down Expand Up @@ -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}
Expand Down
44 changes: 22 additions & 22 deletions cpp/src/arrow/flight/sql/server_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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<Table>& 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);
}
Expand Down Expand Up @@ -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<Table> 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);
}

Expand All @@ -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<Table>& 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);
}
Expand Down Expand Up @@ -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<Table>& 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);
}
Expand Down Expand Up @@ -350,9 +350,9 @@ TEST_F(TestFlightSqlServer, TestCommandGetTablesWithIncludedSchemas) {
std::shared_ptr<Array> table_schema;
ArrayFromVector<BinaryType, std::string>({schema_buffer->ToString()}, &table_schema);

const std::shared_ptr<Table>& 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);
}
Expand Down Expand Up @@ -419,8 +419,8 @@ TEST_F(TestFlightSqlServer, TestCommandGetTableTypes) {

const auto table_type = ArrayFromJSON(utf8(), R"(["table"])");

const std::shared_ptr<Table>& 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);
}

Expand Down Expand Up @@ -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<Table>& 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);
}
Expand Down Expand Up @@ -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<Table>& 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);
}
Expand Down Expand Up @@ -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<Table>& expected_table =
const std::shared_ptr<Table> 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);
}

Expand Down Expand Up @@ -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<Table>& expected_table =
const std::shared_ptr<Table> 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);
}

Expand Down Expand Up @@ -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<Table>& expected_table =
const std::shared_ptr<Table> 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);
}

Expand Down
Loading
Loading