duckdb 0.8.2-dev2842.0 → 0.8.2-dev3007.0

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

@@ -6,12 +6,14 @@
 
 #include "duckdb.h"
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
-#include "duckdb/common/arrow/arrow.hpp"
+#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
 
 #ifndef DUCKDB_AMALGAMATION
 #include "duckdb/main/connection.hpp"
 #endif
 
+#include "duckdb/common/adbc/single_batch_array_stream.hpp"
+
 #include <string.h>
 #include <stdlib.h>
 
@@ -33,7 +35,7 @@ duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::A
 	driver->ConnectionGetTableTypes = duckdb_adbc::ConnectionGetTableTypes;
 	driver->StatementNew = duckdb_adbc::StatementNew;
 	driver->StatementRelease = duckdb_adbc::StatementRelease;
-	//	driver->StatementBind = duckdb::adbc::StatementBind;
+	driver->StatementBind = duckdb_adbc::StatementBind;
 	driver->StatementBindStream = duckdb_adbc::StatementBindStream;
 	driver->StatementExecuteQuery = duckdb_adbc::StatementExecuteQuery;
 	driver->StatementPrepare = duckdb_adbc::StatementPrepare;
@@ -44,9 +46,13 @@ duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::A
 	driver->ConnectionRollback = duckdb_adbc::ConnectionRollback;
 	driver->ConnectionReadPartition = duckdb_adbc::ConnectionReadPartition;
 	driver->StatementExecutePartitions = duckdb_adbc::StatementExecutePartitions;
+	driver->ConnectionGetInfo = duckdb_adbc::ConnectionGetInfo;
+	driver->StatementGetParameterSchema = duckdb_adbc::StatementGetParameterSchema;
 	driver->ConnectionGetTableSchema = duckdb_adbc::ConnectionGetTableSchema;
 	driver->StatementSetSubstraitPlan = duckdb_adbc::StatementSetSubstraitPlan;
 
+	driver->ConnectionGetInfo = duckdb_adbc::ConnectionGetInfo;
+	driver->StatementGetParameterSchema = duckdb_adbc::StatementGetParameterSchema;
 	return ADBC_STATUS_OK;
 }
 
@@ -58,19 +64,30 @@ struct DuckDBAdbcStatementWrapper {
 	::duckdb_arrow result;
 	::duckdb_prepared_statement statement;
 	char *ingestion_table_name;
-	ArrowArrayStream *ingestion_stream;
+	ArrowArrayStream ingestion_stream;
 	IngestionMode ingestion_mode = IngestionMode::CREATE;
 };
+
 static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
-                                    struct AdbcError *error);
-AdbcStatusCode SetErrorMaybe(const void *result, AdbcError *error, const std::string &error_message) {
-	if (!error) {
-		return ADBC_STATUS_INVALID_ARGUMENT;
+                                    struct AdbcError *error) {
+	AdbcStatement statement;
+
+	auto status = StatementNew(connection, &statement, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
 	}
-	if (!result) {
-		SetError(error, error_message);
-		return ADBC_STATUS_INVALID_ARGUMENT;
+	status = StatementSetSqlQuery(&statement, query, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
 	}
+	status = StatementExecuteQuery(&statement, out, nullptr, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
+	}
+
 	return ADBC_STATUS_OK;
 }
 
@@ -83,12 +100,20 @@ struct DuckDBAdbcDatabaseWrapper {
 	std::string path;
 };
 
-void InitiliazeADBCError(AdbcError *error) {
+static void EmptyErrorRelease(AdbcError *error) {
+	// The object is valid but doesn't contain any data that needs to be cleaned up
+	// Just set the release to nullptr to indicate that it's no longer valid.
+	error->release = nullptr;
+	return;
+}
+
+void InitializeADBCError(AdbcError *error) {
 	if (!error) {
 		return;
 	}
 	error->message = nullptr;
-	error->release = nullptr;
+	// Don't set to nullptr, as that indicates that it's invalid
+	error->release = EmptyErrorRelease;
 	std::memset(error->sqlstate, '\0', sizeof(error->sqlstate));
 	error->vendor_code = -1;
 }
@@ -106,18 +131,18 @@ AdbcStatusCode CheckResult(duckdb_state &res, AdbcError *error, const char *erro
 }
 
 AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error) {
-	auto status = SetErrorMaybe(database, error, "Missing database object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!database) {
+		SetError(error, "Missing database object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 	database->private_data = nullptr;
 	// you can't malloc a struct with a non-trivial C++ constructor
 	// and std::string has a non-trivial constructor. so we need
 	// to use new and delete rather than malloc and free.
 	auto wrapper = new DuckDBAdbcDatabaseWrapper;
-	status = SetErrorMaybe(wrapper, error, "Allocation error");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!wrapper) {
+		SetError(error, "Allocation error");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 	database->private_data = wrapper;
 	auto res = duckdb_create_config(&wrapper->config);
@@ -148,14 +173,13 @@ AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement *statement, const
 
 AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
                                  struct AdbcError *error) {
-	auto status = SetErrorMaybe(database, error, "Missing database object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!database) {
+		SetError(error, "Missing database object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(key, error, "Missing key");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!key) {
+		SetError(error, "Missing key");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
 	auto wrapper = (DuckDBAdbcDatabaseWrapper *)database->private_data;
@@ -236,9 +260,9 @@ AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *connection, const
 }
 
 AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError *error) {
-	auto status = SetErrorMaybe(connection, error, "Missing connection object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!connection) {
+		SetError(error, "Missing connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
 	connection->private_data = nullptr;
@@ -345,19 +369,129 @@ AdbcStatusCode ConnectionRollback(struct AdbcConnection *connection, struct Adbc
 	return ExecuteQuery(conn, "START TRANSACTION", error);
 }
 
+enum class AdbcInfoCode : uint32_t {
+	VENDOR_NAME,
+	VENDOR_VERSION,
+	DRIVER_NAME,
+	DRIVER_VERSION,
+	DRIVER_ARROW_VERSION,
+	UNRECOGNIZED // always the last entry of the enum
+};
+
+static AdbcInfoCode ConvertToInfoCode(uint32_t info_code) {
+	switch (info_code) {
+	case 0:
+		return AdbcInfoCode::VENDOR_NAME;
+	case 1:
+		return AdbcInfoCode::VENDOR_VERSION;
+	case 2:
+		return AdbcInfoCode::DRIVER_NAME;
+	case 3:
+		return AdbcInfoCode::DRIVER_VERSION;
+	case 4:
+		return AdbcInfoCode::DRIVER_ARROW_VERSION;
+	default:
+		return AdbcInfoCode::UNRECOGNIZED;
+	}
+}
+
+AdbcStatusCode ConnectionGetInfo(struct AdbcConnection *connection, uint32_t *info_codes, size_t info_codes_length,
+                                 struct ArrowArrayStream *out, struct AdbcError *error) {
+	if (!connection) {
+		SetError(error, "Missing connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!connection->private_data) {
+		SetError(error, "Connection is invalid");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!out) {
+		SetError(error, "Output parameter was not provided");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+
+	// If 'info_codes' is NULL, we should output all the info codes we recognize
+	size_t length = info_codes ? info_codes_length : (size_t)AdbcInfoCode::UNRECOGNIZED;
+
+	duckdb::string q = R"EOF(
+		select
+			name::UINTEGER as info_name,
+			info::UNION(
+				string_value VARCHAR,
+				bool_value BOOL,
+				int64_value BIGINT,
+				int32_bitmask INTEGER,
+				string_list VARCHAR[],
+				int32_to_int32_list_map MAP(INTEGER, INTEGER[])
+			) as info_value from values
+	)EOF";
+
+	duckdb::string results = "";
+
+	for (size_t i = 0; i < length; i++) {
+		uint32_t code = info_codes ? info_codes[i] : i;
+		auto info_code = ConvertToInfoCode(code);
+		switch (info_code) {
+		case AdbcInfoCode::VENDOR_NAME: {
+			results += "(0, 'duckdb'),";
+			break;
+		}
+		case AdbcInfoCode::VENDOR_VERSION: {
+			results += duckdb::StringUtil::Format("(1, '%s'),", duckdb_library_version());
+			break;
+		}
+		case AdbcInfoCode::DRIVER_NAME: {
+			results += "(2, 'ADBC DuckDB Driver'),";
+			break;
+		}
+		case AdbcInfoCode::DRIVER_VERSION: {
+			// TODO: fill in driver version
+			results += "(3, '(unknown)'),";
+			break;
+		}
+		case AdbcInfoCode::DRIVER_ARROW_VERSION: {
+			// TODO: fill in arrow version
+			results += "(4, '(unknown)'),";
+			break;
+		}
+		case AdbcInfoCode::UNRECOGNIZED: {
+			// Unrecognized codes are not an error, just ignored
+			continue;
+		}
+		default: {
+			// Codes that we have implemented but not handled here are a developer error
+			SetError(error, "Info code recognized but not handled");
+			return ADBC_STATUS_INTERNAL;
+		}
+		}
+	}
+	if (results.empty()) {
+		// Add a group of values so the query parses
+		q += "(NULL, NULL)";
+	} else {
+		q += results;
+	}
+	q += " tbl(name, info)";
+	if (results.empty()) {
+		// Add an impossible where clause to return an empty result set
+		q += " where true = false";
+	}
+	return QueryInternal(connection, out, q.c_str(), error);
+}
+
 AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
                               struct AdbcError *error) {
-	auto status = SetErrorMaybe(database, error, "Missing database");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!database) {
+		SetError(error, "Missing database object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	status = SetErrorMaybe(database->private_data, error, "Invalid database");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!database->private_data) {
+		SetError(error, "Invalid database");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	status = SetErrorMaybe(connection, error, "Missing connection");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!connection) {
+		SetError(error, "Missing connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 	auto database_wrapper = (DuckDBAdbcDatabaseWrapper *)database->private_data;
 
@@ -433,20 +567,19 @@ void stream_schema(uintptr_t factory_ptr, duckdb::ArrowSchemaWrapper &schema) {
 AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input,
                       struct AdbcError *error, IngestionMode ingestion_mode) {
 
-	auto status = SetErrorMaybe(connection, error, "Invalid connection");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!connection) {
+		SetError(error, "Missing connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(input, error, "Missing input arrow stream pointer");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!input) {
+		SetError(error, "Missing input arrow stream pointer");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(table_name, error, "Missing database object name");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!table_name) {
+		SetError(error, "Missing database object name");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
+
 	auto cconn = (duckdb::Connection *)connection;
 
 	auto arrow_scan = cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
@@ -458,7 +591,7 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, stru
 			arrow_scan->Create(table_name);
 		} else {
 			arrow_scan->CreateView("temp_adbc_view", true, true);
-			auto query = "insert into " + std::string(table_name) + " select * from temp_adbc_view";
+			auto query = duckdb::StringUtil::Format("insert into \"%s\" select * from temp_adbc_view", table_name);
 			auto result = cconn->Query(query);
 		}
 		// After creating a table, the arrow array stream is released. Hence we must set it as released to avoid
@@ -477,79 +610,134 @@ AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, stru
 
 AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
                             struct AdbcError *error) {
-
-	auto status = SetErrorMaybe(connection, error, "Missing connection object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!connection) {
+		SetError(error, "Missing connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(connection->private_data, error, "Invalid connection object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!connection->private_data) {
+		SetError(error, "Invalid connection object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
 	statement->private_data = nullptr;
 
 	auto statement_wrapper = (DuckDBAdbcStatementWrapper *)malloc(sizeof(DuckDBAdbcStatementWrapper));
-	status = SetErrorMaybe(statement_wrapper, error, "Allocation error");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement_wrapper) {
+		SetError(error, "Allocation error");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
 	statement->private_data = statement_wrapper;
 	statement_wrapper->connection = (duckdb_connection)connection->private_data;
 	statement_wrapper->statement = nullptr;
 	statement_wrapper->result = nullptr;
-	statement_wrapper->ingestion_stream = nullptr;
+	statement_wrapper->ingestion_stream.release = nullptr;
 	statement_wrapper->ingestion_table_name = nullptr;
 	statement_wrapper->ingestion_mode = IngestionMode::CREATE;
 	return ADBC_STATUS_OK;
 }
 
 AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcError *error) {
+	if (!statement || !statement->private_data) {
+		return ADBC_STATUS_OK;
+	}
+	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
+	if (wrapper->statement) {
+		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;
+	}
+	if (wrapper->ingestion_table_name) {
+		free(wrapper->ingestion_table_name);
+		wrapper->ingestion_table_name = nullptr;
+	}
+	free(statement->private_data);
+	statement->private_data = nullptr;
+	return ADBC_STATUS_OK;
+}
 
-	if (statement && statement->private_data) {
-		auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
-		if (wrapper->statement) {
-			duckdb_destroy_prepare(&wrapper->statement);
-			wrapper->statement = nullptr;
-		}
-		if (wrapper->result) {
-			duckdb_destroy_arrow(&wrapper->result);
-			wrapper->result = nullptr;
-		}
-		if (wrapper->ingestion_stream) {
-			wrapper->ingestion_stream->release(wrapper->ingestion_stream);
-			wrapper->ingestion_stream->release = nullptr;
-			wrapper->ingestion_stream = nullptr;
-		}
-		if (wrapper->ingestion_table_name) {
-			free(wrapper->ingestion_table_name);
-			wrapper->ingestion_table_name = nullptr;
+AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement *statement, struct ArrowSchema *schema,
+                                           struct AdbcError *error) {
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!schema) {
+		SetError(error, "Missing schema object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	auto wrapper = (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, (duckdb_arrow_schema *)&schema);
+	if (res != DuckDBSuccess) {
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode GetPreparedParameters(duckdb_connection connection, duckdb::unique_ptr<duckdb::QueryResult> &result,
+                                     ArrowArrayStream *input, AdbcError *error) {
+
+	auto cconn = (duckdb::Connection *)connection;
+
+	try {
+		auto arrow_scan = cconn->TableFunction("arrow_scan", {duckdb::Value::POINTER((uintptr_t)input),
+		                                                      duckdb::Value::POINTER((uintptr_t)stream_produce),
+		                                                      duckdb::Value::POINTER((uintptr_t)input->get_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) {
+			error->message = strdup(ex.what());
 		}
-		free(statement->private_data);
-		statement->private_data = nullptr;
+		return ADBC_STATUS_INTERNAL;
+	} catch (...) {
+		return ADBC_STATUS_INTERNAL;
 	}
 	return ADBC_STATUS_OK;
 }
 
+static AdbcStatusCode IngestToTableFromBoundStream(DuckDBAdbcStatementWrapper *statement, AdbcError *error) {
+	// See ADBC_INGEST_OPTION_TARGET_TABLE
+	D_ASSERT(statement->ingestion_stream.release);
+	D_ASSERT(statement->ingestion_table_name);
+
+	// 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, &stream, error, statement->ingestion_mode);
+}
+
 AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
                                      int64_t *rows_affected, struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 
 	// TODO: Set affected rows, careful with early return
@@ -557,16 +745,59 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 		*rows_affected = 0;
 	}
 
-	if (wrapper->ingestion_stream && wrapper->ingestion_table_name) {
-		auto stream = wrapper->ingestion_stream;
-		wrapper->ingestion_stream = nullptr;
-		return Ingest(wrapper->connection, wrapper->ingestion_table_name, stream, error, wrapper->ingestion_mode);
+	const auto has_stream = wrapper->ingestion_stream.release != nullptr;
+	const auto to_table = wrapper->ingestion_table_name != nullptr;
+
+	if (has_stream && to_table) {
+		return IngestToTableFromBoundStream(wrapper, error);
 	}
 
-	auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
-	if (res != DuckDBSuccess) {
-		SetError(error, duckdb_query_arrow_error(wrapper->result));
-		return ADBC_STATUS_INVALID_ARGUMENT;
+	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;
+		}
+		duckdb::unique_ptr<duckdb::DataChunk> chunk;
+		while ((chunk = result->Fetch()) != nullptr) {
+			if (chunk->size() == 0) {
+				SetError(error, "Please provide a non-empty chunk to be bound");
+				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");
+				return ADBC_STATUS_NOT_IMPLEMENTED;
+			}
+			duckdb_clear_bindings(wrapper->statement);
+			for (idx_t col_idx = 0; col_idx < chunk->ColumnCount(); col_idx++) {
+				auto val = chunk->GetValue(col_idx, 0);
+				auto duck_val = (duckdb_value)&val;
+				auto res = duckdb_bind_value(wrapper->statement, 1 + col_idx, duck_val);
+				if (res != DuckDBSuccess) {
+					SetError(error, duckdb_prepare_error(wrapper->statement));
+					return ADBC_STATUS_INVALID_ARGUMENT;
+				}
+			}
+
+			auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
+			if (res != DuckDBSuccess) {
+				SetError(error, duckdb_query_arrow_error(wrapper->result));
+				return ADBC_STATUS_INVALID_ARGUMENT;
+			}
+		}
+	} else {
+		auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
+		if (res != DuckDBSuccess) {
+			SetError(error, duckdb_query_arrow_error(wrapper->result));
+			return ADBC_STATUS_INVALID_ARGUMENT;
+		}
 	}
 
 	if (out) {
@@ -590,21 +821,25 @@ AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcErro
 		SetError(error, "Missing statement object");
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	if (!error) {
-		SetError(error, "Missing error object");
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 	return ADBC_STATUS_OK;
 }
 
 AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	status = SetErrorMaybe(query, error, "Missing query");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!query) {
+		SetError(error, "Missing query");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
 
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
@@ -613,31 +848,74 @@ AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char
 	return CheckResult(res, error, error_msg);
 }
 
+AdbcStatusCode StatementBind(struct AdbcStatement *statement, struct ArrowArray *values, struct ArrowSchema *schemas,
+                             struct AdbcError *error) {
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!values) {
+		SetError(error, "Missing values object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!schemas) {
+		SetError(error, "Invalid schemas object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+
+	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
+	if (wrapper->ingestion_stream.release) {
+		// Free the stream that was previously bound
+		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
+	}
+	auto status = BatchToArrayStream(values, schemas, &wrapper->ingestion_stream, error);
+	return status;
+}
+
 AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *values,
                                    struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	status = SetErrorMaybe(values, error, "Missing stream object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!values) {
+		SetError(error, "Missing values object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
+
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
-	wrapper->ingestion_stream = values;
+	if (wrapper->ingestion_stream.release) {
+		// Release any resources currently held by the ingestion stream before we overwrite it
+		wrapper->ingestion_stream.release(&wrapper->ingestion_stream);
+	}
+	wrapper->ingestion_stream = *values;
+	values->release = nullptr;
 	return ADBC_STATUS_OK;
 }
 
 AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
                                   struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-	status = SetErrorMaybe(key, error, "Missing key object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement->private_data) {
+		SetError(error, "Invalid statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!key) {
+		SetError(error, "Missing key object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
+
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 
 	if (strcmp(key, ADBC_INGEST_OPTION_TARGET_TABLE) == 0) {
@@ -659,29 +937,6 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *k
 	return ADBC_STATUS_INVALID_ARGUMENT;
 }
 
-AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
-                             struct AdbcError *error) {
-	AdbcStatement statement;
-
-	auto status = StatementNew(connection, &statement, error);
-	if (status != ADBC_STATUS_OK) {
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-	status = StatementSetSqlQuery(&statement, query, error);
-	if (status != ADBC_STATUS_OK) {
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-	status = StatementExecuteQuery(&statement, out, nullptr, error);
-	if (status != ADBC_STATUS_OK) {
-		SetError(error, "unable to initialize statement");
-		return status;
-	}
-
-	return ADBC_STATUS_OK;
-}
-
 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) {