wip

Author: peasee

src/function/table/arrow.cpp

@@ -14,23 +14,19 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "utf8proc_wrapper.hpp"
 #include "duckdb/common/arrow/schema_metadata.hpp"
-#include <iostream>
 
 namespace duckdb {
 
 void ArrowTableFunction::PopulateArrowTableType(DBConfig &config, ArrowTableType &arrow_table,
                                                 const ArrowSchemaWrapper &schema_p, vector<string> &names,
                                                 vector<LogicalType> &return_types) {
 	for (idx_t col_idx = 0; col_idx < static_cast<idx_t>(schema_p.arrow_schema.n_children); col_idx++) {
-		std::cout << "DEBUG: processing column index " << col_idx << std::endl;
 		if (schema_p.arrow_schema.children[col_idx] == nullptr) {
 			throw InvalidInputException("arrow_scan: null schema pointer for column %d", col_idx);
 		}
 
 		auto &schema = *schema_p.arrow_schema.children[col_idx];
-		std::cout << "DEBUG: column name: '" << schema.name << "'" << std::endl;
 		if (!schema.release) {
-			std::cout << "DEBUG: released schema passed" << std::endl;
 			throw InvalidInputException("arrow_scan: released schema passed");
 		}
 		auto arrow_type = ArrowType::GetArrowLogicalType(config, schema);
@@ -75,18 +71,14 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr, std::move(dependency));
 
 	auto &data = *res;
-	std::cout << "DEBUG: retrieving arrow schema from stream factory" << std::endl;
 	stream_factory_get_schema(reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr), data.schema_root.arrow_schema);
-	std::cout << "DEBUG: populating arrow table type from schema" << std::endl;
 	PopulateArrowTableType(DBConfig::GetConfig(context), res->arrow_table, data.schema_root, names, return_types);
-	std::cout << "DEBUG: deduplicating column names" << std::endl;
 	QueryResult::DeduplicateColumns(names);
 	res->all_types = return_types;
 	if (return_types.empty()) {
 		throw InvalidInputException("Provided table/dataframe must have at least one column");
 	}
 
-	std::cout << "DEBUG: completed arrow scan bind" << std::endl;
 	return std::move(res);
 }
 
@@ -183,7 +175,6 @@ unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(Execu
 }
 
 void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	std::cout << "DEBUG: starting arrow scan function" << std::endl;
 	if (!data_p.local_state) {
 		return;
 	}

src/main/capi/arrow-c.cpp

@@ -3,7 +3,6 @@
 #include "duckdb/function/table/arrow.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
-#include <iostream>
 
 using duckdb::ArrowConverter;
 using duckdb::ArrowResultWrapper;
@@ -248,7 +247,13 @@ const char *GetLastError(struct ArrowArrayStream *stream) {
 
 void Release(struct ArrowArrayStream *stream) {
 	if (stream->private_data != nullptr) {
-		delete reinterpret_cast<PrivateData *>(stream->private_data);
+		auto private_data = reinterpret_cast<PrivateData *>(stream->private_data);
+		if (private_data->schema && private_data->schema->release) {
+			private_data->schema->release(private_data->schema);
+			private_data->schema = nullptr;
+		}
+
+		delete private_data;
 	}
 
 	stream->private_data = nullptr;
@@ -257,7 +262,6 @@ void Release(struct ArrowArrayStream *stream) {
 
 duckdb_state Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input) {
 	try {
-		std::cout << "DEBUG: creating arrow scan table function" << std::endl;
 		auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
 		cconn
 		    ->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
@@ -286,7 +290,6 @@ duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_n
 		return DuckDBError;
 	}
 
-	std::cout << "DEBUG: ingesting arrow array stream into table '" << table_name << "'" << std::endl;
 	return arrow_array_stream_wrapper::Ingest(connection, table_name, stream);
 }
 
@@ -303,13 +306,11 @@ duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *t
 		return DuckDBError;
 	}
 
-	std::cout << "DEBUG: building private data for arrow array stream" << std::endl;
 	auto private_data = new arrow_array_stream_wrapper::PrivateData;
 	private_data->schema = reinterpret_cast<ArrowSchema *>(arrow_schema);
 	private_data->array = reinterpret_cast<ArrowArray *>(arrow_array);
 	private_data->done = false;
 
-	std::cout << "DEBUG: creating arrow array stream" << std::endl;
 	ArrowArrayStream *stream = new ArrowArrayStream;
 	*out_stream = reinterpret_cast<duckdb_arrow_stream>(stream);
 	stream->get_schema = arrow_array_stream_wrapper::GetSchema;
@@ -318,6 +319,5 @@ duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *t
 	stream->release = arrow_array_stream_wrapper::Release;
 	stream->private_data = private_data;
 
-	std::cout << "DEBUG: ingesting arrow array stream into table '" << table_name << "'" << std::endl;
 	return duckdb_arrow_scan(connection, table_name, reinterpret_cast<duckdb_arrow_stream>(stream));
 }