Current section
Files
Jump to
Current section
Files
3rd_party/apache-arrow-adbc/c/driver/framework/objects.cc
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include "driver/framework/objects.h"
#include <string_view>
#include "nanoarrow/nanoarrow.hpp"
#include "driver/framework/status.h"
#include "driver/framework/utility.h"
namespace adbc::driver {
Status MakeGetObjectsSchema(struct ArrowSchema* schema) {
ArrowSchemaInit(schema);
UNWRAP_ERRNO(Internal, ArrowSchemaSetTypeStruct(schema, /*num_columns=*/2));
UNWRAP_ERRNO(Internal, ArrowSchemaSetType(schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(schema->children[0], "catalog_name"));
UNWRAP_ERRNO(Internal, ArrowSchemaSetType(schema->children[1], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(schema->children[1], "catalog_db_schemas"));
UNWRAP_ERRNO(Internal, ArrowSchemaSetTypeStruct(schema->children[1]->children[0], 2));
struct ArrowSchema* db_schema_schema = schema->children[1]->children[0];
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(db_schema_schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(db_schema_schema->children[0], "db_schema_name"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(db_schema_schema->children[1], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(db_schema_schema->children[1], "db_schema_tables"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetTypeStruct(db_schema_schema->children[1]->children[0], 4));
struct ArrowSchema* table_schema = db_schema_schema->children[1]->children[0];
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(table_schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(table_schema->children[0], "table_name"));
table_schema->children[0]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(table_schema->children[1], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(table_schema->children[1], "table_type"));
table_schema->children[1]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(table_schema->children[2], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(table_schema->children[2], "table_columns"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetTypeStruct(table_schema->children[2]->children[0], 19));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(table_schema->children[3], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(table_schema->children[3], "table_constraints"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetTypeStruct(table_schema->children[3]->children[0], 4));
struct ArrowSchema* column_schema = table_schema->children[2]->children[0];
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(column_schema->children[0], "column_name"));
column_schema->children[0]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[1], NANOARROW_TYPE_INT32));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[1], "ordinal_position"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[2], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(column_schema->children[2], "remarks"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[3], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[3], "xdbc_data_type"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[4], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[4], "xdbc_type_name"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[5], NANOARROW_TYPE_INT32));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[5], "xdbc_column_size"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[6], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[6], "xdbc_decimal_digits"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[7], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[7], "xdbc_num_prec_radix"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[8], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(column_schema->children[8], "xdbc_nullable"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[9], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[9], "xdbc_column_def"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[10], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[10], "xdbc_sql_data_type"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[11], NANOARROW_TYPE_INT16));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[11], "xdbc_datetime_sub"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[12], NANOARROW_TYPE_INT32));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[12], "xdbc_char_octet_length"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[13], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[13], "xdbc_is_nullable"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[14], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[14], "xdbc_scope_catalog"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[15], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[15], "xdbc_scope_schema"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[16], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[16], "xdbc_scope_table"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[17], NANOARROW_TYPE_BOOL));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(column_schema->children[17], "xdbc_is_autoincrement"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(column_schema->children[18], NANOARROW_TYPE_BOOL));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(column_schema->children[18],
"xdbc_is_generatedcolumn"));
struct ArrowSchema* constraint_schema = table_schema->children[3]->children[0];
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(constraint_schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(constraint_schema->children[0], "constraint_name"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(constraint_schema->children[1], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetName(constraint_schema->children[1], "constraint_type"));
constraint_schema->children[1]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(constraint_schema->children[2], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(constraint_schema->children[2],
"constraint_column_names"));
UNWRAP_ERRNO(Internal, ArrowSchemaSetType(constraint_schema->children[2]->children[0],
NANOARROW_TYPE_STRING));
constraint_schema->children[2]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(constraint_schema->children[3], NANOARROW_TYPE_LIST));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(constraint_schema->children[3],
"constraint_column_usage"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetTypeStruct(constraint_schema->children[3]->children[0], 4));
struct ArrowSchema* usage_schema = constraint_schema->children[3]->children[0];
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(usage_schema->children[0], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(usage_schema->children[0], "fk_catalog"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(usage_schema->children[1], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(usage_schema->children[1], "fk_db_schema"));
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(usage_schema->children[2], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(usage_schema->children[2], "fk_table"));
usage_schema->children[2]->flags &= ~ARROW_FLAG_NULLABLE;
UNWRAP_ERRNO(Internal,
ArrowSchemaSetType(usage_schema->children[3], NANOARROW_TYPE_STRING));
UNWRAP_ERRNO(Internal, ArrowSchemaSetName(usage_schema->children[3], "fk_column_name"));
usage_schema->children[3]->flags &= ~ARROW_FLAG_NULLABLE;
return status::Ok();
}
namespace {
/// \brief A helper to convert std::string_view to Nanoarrow's ArrowStringView.
ArrowStringView ToStringView(std::string_view s) {
return {
s.data(),
static_cast<int64_t>(s.size()),
};
}
/// \brief A helper to append an optional value to an ArrowArray.
template <typename T>
Status AppendOptional(ArrowArray* array, std::optional<T> value) {
if (!value) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(array, 1));
} else if constexpr (std::is_same_v<T, bool>) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendInt(array, *value));
} else if constexpr (std::is_same_v<T, int16_t>) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendInt(array, *value));
} else if constexpr (std::is_same_v<T, int32_t>) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendInt(array, *value));
} else if constexpr (std::is_same_v<T, std::string_view>) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(array, ToStringView(*value)));
} else {
static_assert(!sizeof(T), "unimplemented type");
}
return status::Ok();
}
struct GetObjectsBuilder {
GetObjectsBuilder(GetObjectsHelper* helper, GetObjectsDepth depth,
std::optional<std::string_view> catalog_filter,
std::optional<std::string_view> schema_filter,
std::optional<std::string_view> table_filter,
std::optional<std::string_view> column_filter,
const std::vector<std::string_view>& table_types,
struct ArrowSchema* schema, struct ArrowArray* array)
: helper(helper),
depth(depth),
catalog_filter(catalog_filter),
schema_filter(schema_filter),
table_filter(table_filter),
column_filter(column_filter),
table_types(table_types),
schema(schema),
array(array) {
std::memset(&na_error, 0, sizeof(na_error));
}
Status Build() {
UNWRAP_STATUS(InitArrowArray());
UNWRAP_STATUS(helper->Load(depth, catalog_filter, schema_filter, table_filter,
column_filter, table_types));
catalog_name_col = array->children[0];
catalog_db_schemas_col = array->children[1];
catalog_db_schemas_items = catalog_db_schemas_col->children[0];
db_schema_name_col = catalog_db_schemas_items->children[0];
db_schema_tables_col = catalog_db_schemas_items->children[1];
schema_table_items = db_schema_tables_col->children[0];
table_name_col = schema_table_items->children[0];
table_type_col = schema_table_items->children[1];
table_columns_col = schema_table_items->children[2];
table_columns_items = table_columns_col->children[0];
column_name_col = table_columns_items->children[0];
column_position_col = table_columns_items->children[1];
column_remarks_col = table_columns_items->children[2];
table_constraints_col = schema_table_items->children[3];
table_constraints_items = table_constraints_col->children[0];
constraint_name_col = table_constraints_items->children[0];
constraint_type_col = table_constraints_items->children[1];
constraint_column_names_col = table_constraints_items->children[2];
constraint_column_name_col = constraint_column_names_col->children[0];
constraint_column_usages_col = table_constraints_items->children[3];
constraint_column_usage_items = constraint_column_usages_col->children[0];
fk_catalog_col = constraint_column_usage_items->children[0];
fk_db_schema_col = constraint_column_usage_items->children[1];
fk_table_col = constraint_column_usage_items->children[2];
fk_column_name_col = constraint_column_usage_items->children[3];
UNWRAP_STATUS(AppendCatalogs());
return FinishArrowArray();
}
private:
Status InitArrowArray() {
UNWRAP_STATUS(MakeGetObjectsSchema(schema));
UNWRAP_NANOARROW(na_error, Internal,
ArrowArrayInitFromSchema(array, schema, &na_error));
UNWRAP_ERRNO(Internal, ArrowArrayStartAppending(array));
return status::Ok();
}
Status AppendCatalogs() {
UNWRAP_STATUS(helper->LoadCatalogs(catalog_filter));
while (true) {
UNWRAP_RESULT(auto maybe_catalog, helper->NextCatalog());
if (!maybe_catalog.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(catalog_name_col,
ToStringView(*maybe_catalog)));
if (depth == GetObjectsDepth::kCatalogs) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(catalog_db_schemas_col, 1));
} else {
UNWRAP_STATUS(AppendSchemas(*maybe_catalog));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(array));
}
return status::Ok();
}
Status AppendSchemas(std::string_view catalog) {
UNWRAP_STATUS(helper->LoadSchemas(catalog, schema_filter));
while (true) {
UNWRAP_RESULT(auto maybe_schema, helper->NextSchema());
if (!maybe_schema.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(db_schema_name_col,
ToStringView(*maybe_schema)));
if (depth == GetObjectsDepth::kSchemas) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(db_schema_tables_col, 1));
} else {
UNWRAP_STATUS(AppendTables(catalog, *maybe_schema));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(catalog_db_schemas_items));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(catalog_db_schemas_col));
return status::Ok();
}
Status AppendTables(std::string_view catalog, std::string_view schema) {
UNWRAP_STATUS(helper->LoadTables(catalog, schema, table_filter, table_types));
while (true) {
UNWRAP_RESULT(auto maybe_table, helper->NextTable());
if (!maybe_table.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(table_name_col,
ToStringView(maybe_table->name)));
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(table_type_col,
ToStringView(maybe_table->type)));
if (depth == GetObjectsDepth::kTables) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(table_columns_col, 1));
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(table_constraints_col, 1));
} else {
UNWRAP_STATUS(AppendColumns(catalog, schema, maybe_table->name));
UNWRAP_STATUS(AppendConstraints(catalog, schema, maybe_table->name));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(schema_table_items));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(db_schema_tables_col));
return status::Ok();
}
Status AppendColumns(std::string_view catalog, std::string_view schema,
std::string_view table) {
UNWRAP_STATUS(helper->LoadColumns(catalog, schema, table, column_filter));
while (true) {
UNWRAP_RESULT(auto maybe_column, helper->NextColumn());
if (!maybe_column.has_value()) break;
const auto& column = *maybe_column;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(column_name_col,
ToStringView(column.column_name)));
UNWRAP_ERRNO(Internal,
ArrowArrayAppendInt(column_position_col, column.ordinal_position));
if (column.remarks) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(column_remarks_col,
ToStringView(*column.remarks)));
} else {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(column_remarks_col, 1));
}
if (column.xdbc) {
UNWRAP_STATUS(AppendOptional(table_columns_items->children[3],
column.xdbc->xdbc_data_type));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[4],
column.xdbc->xdbc_type_name));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[5],
column.xdbc->xdbc_column_size));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[6],
column.xdbc->xdbc_decimal_digits));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[7],
column.xdbc->xdbc_num_prec_radix));
UNWRAP_STATUS(
AppendOptional(table_columns_items->children[8], column.xdbc->xdbc_nullable));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[9],
column.xdbc->xdbc_column_def));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[10],
column.xdbc->xdbc_sql_data_type));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[11],
column.xdbc->xdbc_datetime_sub));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[12],
column.xdbc->xdbc_char_octet_length));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[13],
column.xdbc->xdbc_is_nullable));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[14],
column.xdbc->xdbc_scope_catalog));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[15],
column.xdbc->xdbc_scope_schema));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[16],
column.xdbc->xdbc_scope_table));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[17],
column.xdbc->xdbc_is_autoincrement));
UNWRAP_STATUS(AppendOptional(table_columns_items->children[18],
column.xdbc->xdbc_is_generatedcolumn));
} else {
for (auto i = 3; i < 19; i++) {
UNWRAP_ERRNO(Internal,
ArrowArrayAppendNull(table_columns_items->children[i], 1));
}
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(table_columns_items));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(table_columns_col));
return status::Ok();
}
Status AppendConstraints(std::string_view catalog, std::string_view schema,
std::string_view table) {
while (true) {
UNWRAP_RESULT(auto maybe_constraint, helper->NextConstraint());
if (!maybe_constraint.has_value()) break;
// XXX: copy to make gcc 12.2's -Wmaybe-uninitialized happy (only
// happens with optimizations enabled)
const auto constraint = *maybe_constraint;
if (constraint.name) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(constraint_name_col,
ToStringView(*constraint.name)));
} else {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(constraint_name_col, 1));
}
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(constraint_type_col,
ToStringView(constraint.type)));
for (const auto& constraint_column_name : constraint.column_names) {
UNWRAP_ERRNO(Internal,
ArrowArrayAppendString(constraint_column_name_col,
ToStringView(constraint_column_name)));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(constraint_column_names_col));
if (constraint.usage) {
for (const auto& usage : constraint.usage.value()) {
if (usage.catalog) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(fk_catalog_col,
ToStringView(*usage.catalog)));
} else {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(fk_catalog_col, 1));
}
if (usage.schema) {
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(fk_db_schema_col,
ToStringView(*usage.schema)));
} else {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(fk_db_schema_col, 1));
}
UNWRAP_ERRNO(Internal,
ArrowArrayAppendString(fk_table_col, ToStringView(usage.table)));
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(fk_column_name_col,
ToStringView(usage.column)));
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(constraint_column_usage_items));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(constraint_column_usages_col));
} else {
UNWRAP_ERRNO(Internal, ArrowArrayAppendNull(constraint_column_usages_col, 1));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(table_constraints_items));
}
UNWRAP_ERRNO(Internal, ArrowArrayFinishElement(table_constraints_col));
return status::Ok();
}
Status FinishArrowArray() {
UNWRAP_NANOARROW(na_error, Internal,
ArrowArrayFinishBuildingDefault(array, &na_error));
return status::Ok();
}
GetObjectsHelper* helper;
GetObjectsDepth depth;
std::optional<std::string_view> catalog_filter;
std::optional<std::string_view> schema_filter;
std::optional<std::string_view> table_filter;
std::optional<std::string_view> column_filter;
const std::vector<std::string_view>& table_types;
struct ArrowSchema* schema = nullptr;
struct ArrowArray* array = nullptr;
struct ArrowError na_error;
struct ArrowArray* catalog_name_col = nullptr;
struct ArrowArray* catalog_db_schemas_col = nullptr;
struct ArrowArray* catalog_db_schemas_items = nullptr;
struct ArrowArray* db_schema_name_col = nullptr;
struct ArrowArray* db_schema_tables_col = nullptr;
struct ArrowArray* schema_table_items = nullptr;
struct ArrowArray* table_name_col = nullptr;
struct ArrowArray* table_type_col = nullptr;
struct ArrowArray* table_columns_col = nullptr;
struct ArrowArray* table_columns_items = nullptr;
struct ArrowArray* column_name_col = nullptr;
struct ArrowArray* column_position_col = nullptr;
struct ArrowArray* column_remarks_col = nullptr;
struct ArrowArray* table_constraints_col = nullptr;
struct ArrowArray* table_constraints_items = nullptr;
struct ArrowArray* constraint_name_col = nullptr;
struct ArrowArray* constraint_type_col = nullptr;
struct ArrowArray* constraint_column_names_col = nullptr;
struct ArrowArray* constraint_column_name_col = nullptr;
struct ArrowArray* constraint_column_usages_col = nullptr;
struct ArrowArray* constraint_column_usage_items = nullptr;
struct ArrowArray* fk_catalog_col = nullptr;
struct ArrowArray* fk_db_schema_col = nullptr;
struct ArrowArray* fk_table_col = nullptr;
struct ArrowArray* fk_column_name_col = nullptr;
};
} // namespace
Status BuildGetObjects(GetObjectsHelper* helper, GetObjectsDepth depth,
std::optional<std::string_view> catalog_filter,
std::optional<std::string_view> schema_filter,
std::optional<std::string_view> table_filter,
std::optional<std::string_view> column_filter,
const std::vector<std::string_view>& table_types,
struct ArrowArrayStream* out) {
nanoarrow::UniqueSchema schema;
nanoarrow::UniqueArray array;
UNWRAP_STATUS(GetObjectsBuilder(helper, depth, catalog_filter, schema_filter,
table_filter, column_filter, table_types, schema.get(),
array.get())
.Build());
MakeArrayStream(schema.get(), array.get(), out);
return status::Ok();
}
} // namespace adbc::driver