duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -8,7 +8,12 @@
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
 #include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
 
+#include "duckdb/main/capi/capi_internal.hpp"
+
+#ifndef DUCKDB_AMALGAMATION
 #include "duckdb/main/connection.hpp"
+#endif
+
 #include "duckdb/common/adbc/options.h"
 #include "duckdb/common/adbc/single_batch_array_stream.hpp"
 #include "duckdb/function/table/arrow.hpp"
@@ -16,8 +21,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "duckdb/main/prepared_statement_data.hpp"
-
 // We must leak the symbols of the init function
 AdbcStatusCode duckdb_adbc_init(int version, void *driver, struct AdbcError *error) {
 	if (!driver) {
@@ -59,6 +62,7 @@ enum class IngestionMode { CREATE = 0, APPEND = 1 };
 
 struct DuckDBAdbcStatementWrapper {
 	duckdb_connection connection;
+	duckdb_arrow result;
 	duckdb_prepared_statement statement;
 	char *ingestion_table_name;
 	char *db_schema;
@@ -68,10 +72,6 @@ struct DuckDBAdbcStatementWrapper {
 	uint64_t plan_length;
 };
 
-struct DuckDBAdbcStreamWrapper {
-	duckdb_result result;
-};
-
 static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
                                     struct AdbcError *error) {
 	AdbcStatement statement;
@@ -533,31 +533,8 @@ static int get_schema(struct ArrowArrayStream *stream, struct ArrowSchema *out)
 	if (!stream || !stream->private_data || !out) {
 		return DuckDBError;
 	}
-	auto result_wrapper = static_cast<DuckDBAdbcStreamWrapper *>(stream->private_data);
-	auto count = duckdb_column_count(&result_wrapper->result);
-	std::vector<duckdb_logical_type> types(count);
-
-	std::vector<std::string> owned_names(count);
-	duckdb::vector<const char *> names(count);
-	for (idx_t i = 0; i < count; i++) {
-		types[i] = duckdb_column_logical_type(&result_wrapper->result, i);
-		auto column_name = duckdb_column_name(&result_wrapper->result, i);
-		owned_names.emplace_back(column_name);
-		names[i] = owned_names.back().c_str();
-	}
-
-	auto arrow_options = duckdb_result_get_arrow_options(&result_wrapper->result);
-
-	auto res = duckdb_to_arrow_schema(arrow_options, &types[0], names.data(), count, out);
-	duckdb_destroy_arrow_options(&arrow_options);
-	for (auto &type : types) {
-		duckdb_destroy_logical_type(&type);
-	}
-	if (res) {
-		duckdb_destroy_error_data(&res);
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
+	return duckdb_query_arrow_schema(static_cast<duckdb_arrow>(stream->private_data),
+	                                 reinterpret_cast<duckdb_arrow_schema *>(&out));
 }
 
 static int get_next(struct ArrowArrayStream *stream, struct ArrowArray *out) {
@@ -565,39 +542,28 @@ static int get_next(struct ArrowArrayStream *stream, struct ArrowArray *out) {
 		return DuckDBError;
 	}
 	out->release = nullptr;
-	auto result_wrapper = static_cast<DuckDBAdbcStreamWrapper *>(stream->private_data);
-	auto duckdb_chunk = duckdb_fetch_chunk(result_wrapper->result);
-	if (!duckdb_chunk) {
-		return DuckDBSuccess;
-	}
-	auto arrow_options = duckdb_result_get_arrow_options(&result_wrapper->result);
 
-	auto conversion_success = duckdb_data_chunk_to_arrow(arrow_options, duckdb_chunk, out);
-	duckdb_destroy_arrow_options(&arrow_options);
-	duckdb_destroy_data_chunk(&duckdb_chunk);
-
-	if (conversion_success) {
-		duckdb_destroy_error_data(&conversion_success);
-		return DuckDBError;
-	}
-	return DuckDBSuccess;
+	return duckdb_query_arrow_array(static_cast<duckdb_arrow>(stream->private_data),
+	                                reinterpret_cast<duckdb_arrow_array *>(&out));
 }
 
 void release(struct ArrowArrayStream *stream) {
 	if (!stream || !stream->release) {
 		return;
 	}
-	auto result_wrapper = reinterpret_cast<DuckDBAdbcStreamWrapper *>(stream->private_data);
-	if (result_wrapper) {
-		duckdb_destroy_result(&result_wrapper->result);
+	if (stream->private_data) {
+		duckdb_destroy_arrow(reinterpret_cast<duckdb_arrow *>(&stream->private_data));
+		stream->private_data = nullptr;
 	}
-	free(stream->private_data);
-	stream->private_data = nullptr;
 	stream->release = nullptr;
 }
 
 const char *get_last_error(struct ArrowArrayStream *stream) {
+	if (!stream) {
+		return nullptr;
+	}
 	return nullptr;
+	// return duckdb_query_arrow_error(stream);
 }
 
 // this is an evil hack, normally we would need a stream factory here, but its probably much easier if the adbc clients
@@ -639,65 +605,44 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, cons
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
-	duckdb::ArrowSchemaWrapper arrow_schema_wrapper;
-	ConvertedSchemaWrapper out_types;
-
-	input->get_schema(input, &arrow_schema_wrapper.arrow_schema);
-	auto res = duckdb_schema_from_arrow(connection, &arrow_schema_wrapper.arrow_schema, out_types.GetPtr());
-	if (res) {
-		SetError(error, duckdb_error_data_message(res));
-		duckdb_destroy_error_data(&res);
-		return ADBC_STATUS_INTERNAL;
-	}
+	auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
 
-	auto &d_converted_schema = *reinterpret_cast<duckdb::ArrowTableSchema *>(out_types.Get());
-	auto types = d_converted_schema.GetTypes();
-	auto names = d_converted_schema.GetNames();
-
-	if (ingestion_mode == IngestionMode::CREATE) {
-		// We must construct the create table SQL query
-		std::ostringstream create_table;
-		create_table << "CREATE TABLE ";
-		if (schema) {
-			create_table << schema << ".";
-		}
-		create_table << table_name << " (";
-		for (idx_t i = 0; i < types.size(); i++) {
-			create_table << names[i] << " ";
-			create_table << types[i].ToString();
-			if (i + 1 < types.size()) {
-				create_table << ", ";
+	auto arrow_scan =
+	    cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(input)),
+	                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_produce)),
+	                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_schema))});
+	try {
+		switch (ingestion_mode) {
+		case IngestionMode::CREATE:
+			if (schema) {
+				arrow_scan->Create(schema, table_name, temporary);
+			} else {
+				arrow_scan->Create(table_name, temporary);
 			}
+			break;
+		case IngestionMode::APPEND: {
+			arrow_scan->CreateView("temp_adbc_view", true, true);
+			std::string query = "insert into ";
+			if (schema) {
+				query += duckdb::KeywordHelper::WriteOptionallyQuoted(schema) + ".";
+			}
+			query += duckdb::KeywordHelper::WriteOptionallyQuoted(table_name);
+			query += " select * from temp_adbc_view";
+			auto result = cconn->Query(query);
+			break;
 		}
-		create_table << ");";
-		duckdb_result result;
-		if (duckdb_query(connection, create_table.str().c_str(), &result) == DuckDBError) {
-			SetError(error, duckdb_result_error(&result));
-			duckdb_destroy_result(&result);
-			return ADBC_STATUS_INTERNAL;
 		}
-		duckdb_destroy_result(&result);
-	}
-	AppenderWrapper appender(connection, schema, table_name);
-	if (!appender.Valid()) {
-		return ADBC_STATUS_INTERNAL;
-	}
-	duckdb::ArrowArrayWrapper arrow_array_wrapper;
-
-	input->get_next(input, &arrow_array_wrapper.arrow_array);
-	while (arrow_array_wrapper.arrow_array.release) {
-		DataChunkWrapper out_chunk;
-		auto res = duckdb_data_chunk_from_arrow(connection, &arrow_array_wrapper.arrow_array, out_types.Get(),
-		                                        &out_chunk.chunk);
-		if (res) {
-			SetError(error, duckdb_error_data_message(res));
-			duckdb_destroy_error_data(&res);
+		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
+		// double-releasing it
+		input->release = nullptr;
+	} catch (std::exception &ex) {
+		if (error) {
+			duckdb::ErrorData parsed_error(ex);
+			error->message = strdup(parsed_error.RawMessage().c_str());
 		}
-		if (duckdb_append_data_chunk(appender.Get(), out_chunk.chunk) != DuckDBSuccess) {
-			return ADBC_STATUS_INTERNAL;
-		}
-		arrow_array_wrapper = duckdb::ArrowArrayWrapper();
-		input->get_next(input, &arrow_array_wrapper.arrow_array);
+		return ADBC_STATUS_INTERNAL;
+	} catch (...) {
+		return ADBC_STATUS_INTERNAL;
 	}
 	return ADBC_STATUS_OK;
 }
@@ -730,6 +675,7 @@ AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatem
 
 	statement_wrapper->connection = conn_wrapper->connection;
 	statement_wrapper->statement = nullptr;
+	statement_wrapper->result = nullptr;
 	statement_wrapper->ingestion_stream.release = nullptr;
 	statement_wrapper->ingestion_table_name = nullptr;
 	statement_wrapper->db_schema = nullptr;
@@ -748,6 +694,10 @@ AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcErro
 		duckdb_destroy_prepare(&wrapper->statement);
 		wrapper->statement = nullptr;
 	}
+	if (wrapper->result) {
+		duckdb_destroy_arrow(&wrapper->result);
+		wrapper->result = nullptr;
+	}
 	if (wrapper->ingestion_stream.release) {
 		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
 		wrapper->ingestion_stream.release = nullptr;
@@ -782,44 +732,35 @@ AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, stru
 	auto wrapper = static_cast<DuckDBAdbcStatementWrapper *>(statement->private_data);
 	// TODO: we might want to cache this, but then we need to return a deep copy anyways.., so I'm not sure if that
 	// would be worth the extra management
-
-	auto prepared_wrapper = reinterpret_cast<duckdb::PreparedStatementWrapper *>(wrapper->statement);
-	if (!prepared_wrapper || !prepared_wrapper->statement || !prepared_wrapper->statement->data) {
-		SetError(error, "Invalid prepared statement wrapper");
+	auto res = duckdb_prepared_arrow_schema(wrapper->statement, reinterpret_cast<duckdb_arrow_schema *>(&schema));
+	if (res != DuckDBSuccess) {
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	auto count = prepared_wrapper->statement->data->properties.parameter_count;
-	if (count == 0) {
-		count = 1;
-	}
-	std::vector<duckdb_logical_type> types(count);
-	std::vector<std::string> owned_names(count);
-	duckdb::vector<const char *> names(count);
-
-	for (idx_t i = 0; i < count; i++) {
-		// FIXME: we don't support named parameters yet, but when we do, this needs to be updated
-		// Every prepared parameter type is UNKNOWN, which we need to map to NULL according to the spec of
-		// 'AdbcStatementGetParameterSchema'
-		types[i] = duckdb_create_logical_type(DUCKDB_TYPE_SQLNULL);
-		auto column_name = std::to_string(i);
-		owned_names.emplace_back(column_name);
-		names[i] = owned_names.back().c_str();
-	}
-
-	duckdb_arrow_options arrow_options;
-	duckdb_connection_get_arrow_options(wrapper->connection, &arrow_options);
-
-	auto res = duckdb_to_arrow_schema(arrow_options, &types[0], names.data(), count, schema);
-
-	for (auto &type : types) {
-		duckdb_destroy_logical_type(&type);
-	}
-	duckdb_destroy_arrow_options(&arrow_options);
+	return ADBC_STATUS_OK;
+}
 
-	if (res) {
-		SetError(error, duckdb_error_data_message(res));
-		duckdb_destroy_error_data(&res);
-		return ADBC_STATUS_INVALID_ARGUMENT;
+AdbcStatusCode GetPreparedParameters(duckdb_connection connection, duckdb::unique_ptr<duckdb::QueryResult> &result,
+                                     ArrowArrayStream *input, AdbcError *error) {
+
+	auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
+
+	try {
+		auto arrow_scan =
+		    cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(input)),
+		                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_produce)),
+		                                        duckdb::Value::POINTER(reinterpret_cast<uintptr_t>(stream_schema))});
+		result = arrow_scan->Execute();
+		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
+		// double-releasing it
+		input->release = nullptr;
+	} catch (std::exception &ex) {
+		if (error) {
+			::duckdb::ErrorData parsed_error(ex);
+			error->message = strdup(parsed_error.RawMessage().c_str());
+		}
+		return ADBC_STATUS_INTERNAL;
+	} catch (...) {
+		return ADBC_STATUS_INTERNAL;
 	}
 	return ADBC_STATUS_OK;
 }
@@ -831,6 +772,7 @@ static AdbcStatusCode IngestToTableFromBoundStream(DuckDBAdbcStatementWrapper *s
 
 	// Take the input stream from the statement
 	auto stream = statement->ingestion_stream;
+	statement->ingestion_stream.release = nullptr;
 
 	// Ingest into a table from the bound stream
 	return Ingest(statement->connection, statement->ingestion_table_name, statement->db_schema, &stream, error,
@@ -860,61 +802,34 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 	if (has_stream && to_table) {
 		return IngestToTableFromBoundStream(wrapper, error);
 	}
-	auto stream_wrapper = static_cast<DuckDBAdbcStreamWrapper *>(malloc(sizeof(DuckDBAdbcStreamWrapper)));
 	if (has_stream) {
 		// A stream was bound to the statement, use that to bind parameters
+		duckdb::unique_ptr<duckdb::QueryResult> result;
 		ArrowArrayStream stream = wrapper->ingestion_stream;
-		ConvertedSchemaWrapper out_types;
-		duckdb::ArrowSchemaWrapper arrow_schema_wrapper;
-		stream.get_schema(&stream, &arrow_schema_wrapper.arrow_schema);
-		try {
-			auto res =
-			    duckdb_schema_from_arrow(wrapper->connection, &arrow_schema_wrapper.arrow_schema, out_types.GetPtr());
-			if (res) {
-				SetError(error, duckdb_error_data_message(res));
-				duckdb_destroy_error_data(&res);
-			}
-		} catch (...) {
-			free(stream_wrapper);
-			return ADBC_STATUS_INTERNAL;
+		wrapper->ingestion_stream.release = nullptr;
+		auto adbc_res = GetPreparedParameters(wrapper->connection, result, &stream, error);
+		if (adbc_res != ADBC_STATUS_OK) {
+			return adbc_res;
+		}
+		if (!result) {
+			return ADBC_STATUS_INVALID_ARGUMENT;
 		}
+		duckdb::unique_ptr<duckdb::DataChunk> chunk;
 		auto prepared_statement_params =
 		    reinterpret_cast<duckdb::PreparedStatementWrapper *>(wrapper->statement)->statement->named_param_map.size();
 
-		duckdb::ArrowArrayWrapper arrow_array_wrapper;
-
-		stream.get_next(&stream, &arrow_array_wrapper.arrow_array);
-
-		while (arrow_array_wrapper.arrow_array.release) {
-			// This is a valid arrow array, let's make it into a data chunk
-			DataChunkWrapper out_chunk;
-			auto res_conv = duckdb_data_chunk_from_arrow(wrapper->connection, &arrow_array_wrapper.arrow_array,
-			                                             out_types.Get(), &out_chunk.chunk);
-			if (res_conv) {
-				SetError(error, duckdb_error_data_message(res_conv));
-				duckdb_destroy_error_data(&res_conv);
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			if (!out_chunk.chunk) {
-				SetError(error, "Please provide a non-empty chunk to be bound");
-				free(stream_wrapper);
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			auto chunk = reinterpret_cast<duckdb::DataChunk *>(out_chunk.chunk);
+		while ((chunk = result->Fetch()) != nullptr) {
 			if (chunk->size() == 0) {
 				SetError(error, "Please provide a non-empty chunk to be bound");
-				free(stream_wrapper);
 				return ADBC_STATUS_INVALID_ARGUMENT;
 			}
 			if (chunk->size() != 1) {
 				// TODO: add support for binding multiple rows
 				SetError(error, "Binding multiple rows at once is not supported yet");
-				free(stream_wrapper);
 				return ADBC_STATUS_NOT_IMPLEMENTED;
 			}
 			if (chunk->ColumnCount() > prepared_statement_params) {
 				SetError(error, "Input data has more column than prepared statement has parameters");
-				free(stream_wrapper);
 				return ADBC_STATUS_INVALID_ARGUMENT;
 			}
 			duckdb_clear_bindings(wrapper->statement);
@@ -924,35 +839,34 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 				auto res = duckdb_bind_value(wrapper->statement, 1 + col_idx, duck_val);
 				if (res != DuckDBSuccess) {
 					SetError(error, duckdb_prepare_error(wrapper->statement));
-					free(stream_wrapper);
 					return ADBC_STATUS_INVALID_ARGUMENT;
 				}
 			}
-			auto res = duckdb_execute_prepared(wrapper->statement, &stream_wrapper->result);
+
+			auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
 			if (res != DuckDBSuccess) {
-				SetError(error, duckdb_result_error(&stream_wrapper->result));
-				free(stream_wrapper);
+				SetError(error, duckdb_query_arrow_error(wrapper->result));
 				return ADBC_STATUS_INVALID_ARGUMENT;
 			}
-			// Recreate wrappers for next iteration
-			arrow_array_wrapper = duckdb::ArrowArrayWrapper();
-			stream.get_next(&stream, &arrow_array_wrapper.arrow_array);
 		}
 	} else {
-		auto res = duckdb_execute_prepared(wrapper->statement, &stream_wrapper->result);
+		auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
 		if (res != DuckDBSuccess) {
-			SetError(error, duckdb_result_error(&stream_wrapper->result));
+			SetError(error, duckdb_query_arrow_error(wrapper->result));
 			return ADBC_STATUS_INVALID_ARGUMENT;
 		}
 	}
 
 	if (out) {
-		// We pass ownership of the statement private data to our stream
-		out->private_data = stream_wrapper;
+		out->private_data = wrapper->result;
 		out->get_schema = get_schema;
 		out->get_next = get_next;
 		out->release = release;
 		out->get_last_error = get_last_error;
+
+		// because we handed out the stream pointer its no longer our responsibility to destroy it in
+		// AdbcStatementRelease, this is now done in release()
+		wrapper->result = nullptr;
 	}
 
 	return ADBC_STATUS_OK;
@@ -1000,8 +914,8 @@ AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char
 	auto error_msg_extract_statements = duckdb_extract_statements_error(extracted_statements);
 	if (error_msg_extract_statements != nullptr) {
 		// Things went wrong when executing internal prepared statement
-		SetError(error, error_msg_extract_statements);
 		duckdb_destroy_extracted(&extracted_statements);
+		SetError(error, error_msg_extract_statements);
 		return ADBC_STATUS_INTERNAL;
 	}
 	// Now lets loop over the statements, and execute every one
@@ -1162,30 +1076,14 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *k
 AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
                                     const char *db_schema, const char *table_name, const char **table_type,
                                     const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error) {
+	if (table_type != nullptr) {
+		SetError(error, "Table types parameter not yet supported");
+		return ADBC_STATUS_NOT_IMPLEMENTED;
+	}
+
 	std::string catalog_filter = catalog ? catalog : "%";
 	std::string db_schema_filter = db_schema ? db_schema : "%";
 	std::string table_name_filter = table_name ? table_name : "%";
-	std::string table_type_condition = "";
-	if (table_type && table_type[0]) {
-		table_type_condition = " AND table_type IN (";
-		for (int i = 0; table_type[i]; ++i) {
-			if ((strcmp(table_type[i], "LOCAL TABLE") != 0) && (strcmp(table_type[i], "BASE TABLE") != 0) &&
-			    (strcmp(table_type[i], "VIEW") != 0)) {
-				duckdb::stringstream ss;
-				ss << "Table type must be \"LOCAL TABLE\", \"BASE TABLE\" or "
-				   << "\"VIEW\": \"" << table_type[i] << "\"";
-				SetError(error, ss.str());
-				return ADBC_STATUS_INVALID_ARGUMENT;
-			}
-			if (i > 0) {
-				table_type_condition += ", ";
-			}
-			table_type_condition += "'";
-			table_type_condition += table_type[i];
-			table_type_condition += "'";
-		}
-		table_type_condition += ")";
-	}
 	std::string column_name_filter = column_name ? column_name : "%";
 
 	std::string query;
@@ -1331,7 +1229,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 							)[],
 						}) db_schema_tables
 					FROM information_schema.tables
-					WHERE table_name LIKE '%s'%s
+					WHERE table_name LIKE '%s'
 					GROUP BY table_catalog, table_schema
 				),
 				db_schemas AS (
@@ -1358,7 +1256,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				WHERE catalog_name LIKE '%s'
 				GROUP BY catalog_name
 				)",
-		                                   table_name_filter, table_type_condition, db_schema_filter, catalog_filter);
+		                                   table_name_filter, db_schema_filter, catalog_filter);
 		break;
 	case ADBC_OBJECT_DEPTH_COLUMNS:
 		// Return metadata on catalogs, schemas, tables, and columns.
@@ -1371,7 +1269,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 						LIST({
 							column_name: column_name,
 							ordinal_position: ordinal_position,
-							remarks: '',
+							remarks : '',
 							xdbc_data_type: NULL::SMALLINT,
 							xdbc_type_name: NULL::VARCHAR,
 							xdbc_column_size: NULL::INTEGER,
@@ -1395,34 +1293,19 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				),
 				constraints AS (
 					SELECT
-						database_name AS table_catalog,
-						schema_name AS table_schema,
+						table_catalog,
+						table_schema,
 						table_name,
-						LIST({
-							constraint_name: constraint_name,
-							constraint_type: constraint_type,
-							constraint_column_names: constraint_column_names,
-							constraint_column_usage: list_transform(
-								referenced_column_names,
-								lambda name: {
-									fk_catalog: database_name,
-									fk_db_schema: schema_name,
-									fk_table: referenced_table,
-									fk_column_name: name,
-								}
-							)
-						}) table_constraints
-					FROM duckdb_constraints()
-					WHERE
-						constraint_type NOT IN ('NOT NULL') AND
-						list_has_any(
-							constraint_column_names,
-							list_filter(
-								constraint_column_names,
-								lambda name: name LIKE '%s'
-							)
-						)
-					GROUP BY database_name, schema_name, table_name
+						LIST(
+							{
+								constraint_name: constraint_name,
+								constraint_type: constraint_type,
+								constraint_column_names: []::VARCHAR[],
+								constraint_column_usage: []::STRUCT(fk_catalog VARCHAR, fk_db_schema VARCHAR, fk_table VARCHAR, fk_column_name VARCHAR)[],
+							}
+						) table_constraints
+					FROM information_schema.table_constraints
+					GROUP BY table_catalog, table_schema, table_name
 				),
 				tables AS (
 					SELECT
@@ -1439,7 +1322,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 					USING (table_catalog, table_schema, table_name)
 					LEFT JOIN constraints
 					USING (table_catalog, table_schema, table_name)
-					WHERE table_name LIKE '%s'%s
+					WHERE table_name LIKE '%s'
 					GROUP BY table_catalog, table_schema
 				),
 				db_schemas AS (
@@ -1466,8 +1349,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				WHERE catalog_name LIKE '%s'
 				GROUP BY catalog_name
 				)",
-		                                   column_name_filter, column_name_filter, table_name_filter,
-		                                   table_type_condition, db_schema_filter, catalog_filter);
+		                                   column_name_filter, table_name_filter, db_schema_filter, catalog_filter);
 		break;
 	default:
 		SetError(error, "Invalid value of Depth");

package/src/duckdb/src/common/adbc/driver_manager.cpp

@@ -51,9 +51,9 @@ void GetWinError(std::string *buffer) {
 	DWORD rc = GetLastError();
 	LPVOID message;
 
-	FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-	               /*lpSource=*/nullptr, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-	               reinterpret_cast<LPSTR>(&message), /*nSize=*/0, /*Arguments=*/nullptr);
+	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+	              /*lpSource=*/nullptr, rc, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+	              reinterpret_cast<LPSTR>(&message), /*nSize=*/0, /*Arguments=*/nullptr);
 
 	(*buffer) += '(';
 	(*buffer) += std::to_string(rc);

package/src/duckdb/src/common/arrow/appender/bool_data.cpp

@@ -6,6 +6,7 @@ namespace duckdb {
 void ArrowBoolData::Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
 	auto byte_count = (capacity + 7) / 8;
 	result.GetMainBuffer().reserve(byte_count);
+	(void)AppendValidity; // silence a compiler warning about unused static function
 }
 
 void ArrowBoolData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
@@ -15,24 +16,24 @@ void ArrowBoolData::Append(ArrowAppendData &append_data, Vector &input, idx_t fr
 	auto &main_buffer = append_data.GetMainBuffer();
 	auto &validity_buffer = append_data.GetValidityBuffer();
 	// we initialize both the validity and the bit set to 1's
-	ArrowAppendData::ResizeValidity(validity_buffer, append_data.row_count + size);
-	ArrowAppendData::ResizeValidity(main_buffer, append_data.row_count + size);
+	ResizeValidity(validity_buffer, append_data.row_count + size);
+	ResizeValidity(main_buffer, append_data.row_count + size);
 	auto data = UnifiedVectorFormat::GetData<bool>(format);
 
 	auto result_data = main_buffer.GetData<uint8_t>();
 	auto validity_data = validity_buffer.GetData<uint8_t>();
 	uint8_t current_bit;
 	idx_t current_byte;
-	ArrowAppendData::GetBitPosition(append_data.row_count, current_byte, current_bit);
+	GetBitPosition(append_data.row_count, current_byte, current_bit);
 	for (idx_t i = from; i < to; i++) {
 		auto source_idx = format.sel->get_index(i);
 		// append the validity mask
 		if (!format.validity.RowIsValid(source_idx)) {
-			append_data.SetNull(validity_data, current_byte, current_bit);
+			SetNull(append_data, validity_data, current_byte, current_bit);
 		} else if (!data[source_idx]) {
-			ArrowAppendData::UnsetBit(result_data, current_byte, current_bit);
+			UnsetBit(result_data, current_byte, current_bit);
 		}
-		ArrowAppendData::NextBit(current_byte, current_bit);
+		NextBit(current_byte, current_bit);
 	}
 	append_data.row_count += size;
 }

package/src/duckdb/src/common/arrow/appender/fixed_size_list_data.cpp

@@ -18,7 +18,7 @@ void ArrowFixedSizeListData::Append(ArrowAppendData &append_data, Vector &input,
 	UnifiedVectorFormat format;
 	input.ToUnifiedFormat(input_size, format);
 	idx_t size = to - from;
-	append_data.AppendValidity(format, from, to);
+	AppendValidity(append_data, format, from, to);
 	input.Flatten(input_size);
 	auto array_size = ArrayType::GetSize(input.GetType());
 	auto &child_vector = ArrayVector::GetEntry(input);

package/src/duckdb/src/common/arrow/appender/struct_data.cpp

@@ -18,7 +18,7 @@ void ArrowStructData::Append(ArrowAppendData &append_data, Vector &input, idx_t
 	UnifiedVectorFormat format;
 	input.ToUnifiedFormat(input_size, format);
 	idx_t size = to - from;
-	append_data.AppendValidity(format, from, to);
+	AppendValidity(append_data, format, from, to);
 	// append the children of the struct
 	auto &children = StructVector::GetEntries(input);
 	for (idx_t child_idx = 0; child_idx < children.size(); child_idx++) {

package/src/duckdb/src/common/arrow/appender/union_data.cpp

@@ -14,6 +14,7 @@ void ArrowUnionData::Initialize(ArrowAppendData &result, const LogicalType &type
 		auto child_buffer = ArrowAppender::InitializeChild(child.second, capacity, result.options);
 		result.child_data.push_back(std::move(child_buffer));
 	}
+	(void)AppendValidity; // silence a compiler warning about unused static functiondep
 }
 
 void ArrowUnionData::Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {