duckdb 1.3.4 → 1.4.0

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

@@ -8,12 +8,7 @@
 #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"
@@ -21,6 +16,8 @@
 #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) {
@@ -62,7 +59,6 @@ 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;
@@ -72,6 +68,10 @@ 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,8 +533,31 @@ static int get_schema(struct ArrowArrayStream *stream, struct ArrowSchema *out)
 	if (!stream || !stream->private_data || !out) {
 		return DuckDBError;
 	}
-	return duckdb_query_arrow_schema(static_cast<duckdb_arrow>(stream->private_data),
-	                                 reinterpret_cast<duckdb_arrow_schema *>(&out));
+	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;
 }
 
 static int get_next(struct ArrowArrayStream *stream, struct ArrowArray *out) {
@@ -542,28 +565,39 @@ 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);
 
-	return duckdb_query_arrow_array(static_cast<duckdb_arrow>(stream->private_data),
-	                                reinterpret_cast<duckdb_arrow_array *>(&out));
+	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;
 }
 
 void release(struct ArrowArrayStream *stream) {
 	if (!stream || !stream->release) {
 		return;
 	}
-	if (stream->private_data) {
-		duckdb_destroy_arrow(reinterpret_cast<duckdb_arrow *>(&stream->private_data));
-		stream->private_data = nullptr;
+	auto result_wrapper = reinterpret_cast<DuckDBAdbcStreamWrapper *>(stream->private_data);
+	if (result_wrapper) {
+		duckdb_destroy_result(&result_wrapper->result);
 	}
+	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
@@ -605,45 +639,66 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, cons
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
-	auto cconn = reinterpret_cast<duckdb::Connection *>(connection);
+	duckdb::ArrowSchemaWrapper arrow_schema_wrapper;
+	ConvertedSchemaWrapper out_types;
 
-	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;
+	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 &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 << ", ";
+			}
 		}
-		// 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());
+		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;
 		}
-		return ADBC_STATUS_INTERNAL;
-	} catch (...) {
+		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);
+		}
+		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_OK;
 }
 
@@ -675,7 +730,6 @@ 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;
@@ -694,10 +748,6 @@ 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;
@@ -732,35 +782,44 @@ 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 res = duckdb_prepared_arrow_schema(wrapper->statement, reinterpret_cast<duckdb_arrow_schema *>(&schema));
-	if (res != DuckDBSuccess) {
+
+	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");
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	return ADBC_STATUS_OK;
-}
+	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);
 
-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;
+	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);
+
+	if (res) {
+		SetError(error, duckdb_error_data_message(res));
+		duckdb_destroy_error_data(&res);
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 	return ADBC_STATUS_OK;
 }
@@ -772,7 +831,6 @@ 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,
@@ -802,34 +860,61 @@ 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;
-		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;
+		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;
 		}
-		duckdb::unique_ptr<duckdb::DataChunk> chunk;
 		auto prepared_statement_params =
 		    reinterpret_cast<duckdb::PreparedStatementWrapper *>(wrapper->statement)->statement->named_param_map.size();
 
-		while ((chunk = result->Fetch()) != nullptr) {
+		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);
 			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);
@@ -839,34 +924,35 @@ 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_arrow(wrapper->statement, &wrapper->result);
+			auto res = duckdb_execute_prepared(wrapper->statement, &stream_wrapper->result);
 			if (res != DuckDBSuccess) {
-				SetError(error, duckdb_query_arrow_error(wrapper->result));
+				SetError(error, duckdb_result_error(&stream_wrapper->result));
+				free(stream_wrapper);
 				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_arrow(wrapper->statement, &wrapper->result);
+		auto res = duckdb_execute_prepared(wrapper->statement, &stream_wrapper->result);
 		if (res != DuckDBSuccess) {
-			SetError(error, duckdb_query_arrow_error(wrapper->result));
+			SetError(error, duckdb_result_error(&stream_wrapper->result));
 			return ADBC_STATUS_INVALID_ARGUMENT;
 		}
 	}
 
 	if (out) {
-		out->private_data = wrapper->result;
+		// We pass ownership of the statement private data to our stream
+		out->private_data = stream_wrapper;
 		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;
@@ -914,8 +1000,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
-		duckdb_destroy_extracted(&extracted_statements);
 		SetError(error, error_msg_extract_statements);
+		duckdb_destroy_extracted(&extracted_statements);
 		return ADBC_STATUS_INTERNAL;
 	}
 	// Now lets loop over the statements, and execute every one
@@ -1076,14 +1162,30 @@ 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;
@@ -1229,7 +1331,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 							)[],
 						}) db_schema_tables
 					FROM information_schema.tables
-					WHERE table_name LIKE '%s'
+					WHERE table_name LIKE '%s'%s
 					GROUP BY table_catalog, table_schema
 				),
 				db_schemas AS (
@@ -1256,7 +1358,7 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				WHERE catalog_name LIKE '%s'
 				GROUP BY catalog_name
 				)",
-		                                   table_name_filter, db_schema_filter, catalog_filter);
+		                                   table_name_filter, table_type_condition, db_schema_filter, catalog_filter);
 		break;
 	case ADBC_OBJECT_DEPTH_COLUMNS:
 		// Return metadata on catalogs, schemas, tables, and columns.
@@ -1269,7 +1371,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,
@@ -1293,19 +1395,34 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				),
 				constraints AS (
 					SELECT
-						table_catalog,
-						table_schema,
+						database_name AS table_catalog,
+						schema_name AS table_schema,
 						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
+						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
 				),
 				tables AS (
 					SELECT
@@ -1322,7 +1439,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'
+					WHERE table_name LIKE '%s'%s
 					GROUP BY table_catalog, table_schema
 				),
 				db_schemas AS (
@@ -1349,7 +1466,8 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 				WHERE catalog_name LIKE '%s'
 				GROUP BY catalog_name
 				)",
-		                                   column_name_filter, table_name_filter, db_schema_filter, catalog_filter);
+		                                   column_name_filter, column_name_filter, table_name_filter,
+		                                   table_type_condition, 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;
 
-	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);
+	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);
 
 	(*buffer) += '(';
 	(*buffer) += std::to_string(rc);

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

@@ -0,0 +1,29 @@
+#include "duckdb/common/arrow/appender/append_data.hpp"
+
+namespace duckdb {
+
+void ArrowAppendData::AppendValidity(UnifiedVectorFormat &format, idx_t from, idx_t to) {
+	// resize the buffer, filling the validity buffer with all valid values
+	idx_t size = to - from;
+	ResizeValidity(GetValidityBuffer(), row_count + size);
+	if (format.validity.AllValid()) {
+		// if all values are valid we don't need to do anything else
+		return;
+	}
+
+	// otherwise we iterate through the validity mask
+	auto validity_data = (uint8_t *)GetValidityBuffer().data();
+	uint8_t current_bit;
+	idx_t current_byte;
+	GetBitPosition(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)) {
+			SetNull(validity_data, current_byte, current_bit);
+		}
+		NextBit(current_byte, current_bit);
+	}
+}
+
+} // namespace duckdb

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

@@ -6,7 +6,6 @@ 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) {
@@ -16,24 +15,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
-	ResizeValidity(validity_buffer, append_data.row_count + size);
-	ResizeValidity(main_buffer, append_data.row_count + size);
+	ArrowAppendData::ResizeValidity(validity_buffer, append_data.row_count + size);
+	ArrowAppendData::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;
-	GetBitPosition(append_data.row_count, current_byte, current_bit);
+	ArrowAppendData::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)) {
-			SetNull(append_data, validity_data, current_byte, current_bit);
+			append_data.SetNull(validity_data, current_byte, current_bit);
 		} else if (!data[source_idx]) {
-			UnsetBit(result_data, current_byte, current_bit);
+			ArrowAppendData::UnsetBit(result_data, current_byte, current_bit);
 		}
-		NextBit(current_byte, current_bit);
+		ArrowAppendData::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;
-	AppendValidity(append_data, format, from, to);
+	append_data.AppendValidity(format, from, to);
 	input.Flatten(input_size);
 	auto array_size = ArrayType::GetSize(input.GetType());
 	auto &child_vector = ArrayVector::GetEntry(input);