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

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

@@ -0,0 +1,474 @@
+// 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 <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
+
+namespace duckdb_nanoarrow {
+
+void ArrowSchemaRelease(struct ArrowSchema *schema) {
+	if (schema->format != NULL)
+		ArrowFree((void *)schema->format);
+	if (schema->name != NULL)
+		ArrowFree((void *)schema->name);
+	if (schema->metadata != NULL)
+		ArrowFree((void *)schema->metadata);
+
+	// This object owns the memory for all the children, but those
+	// children may have been generated elsewhere and might have
+	// their own release() callback.
+	if (schema->children != NULL) {
+		for (int64_t i = 0; i < schema->n_children; i++) {
+			if (schema->children[i] != NULL) {
+				if (schema->children[i]->release != NULL) {
+					schema->children[i]->release(schema->children[i]);
+				}
+
+				ArrowFree(schema->children[i]);
+			}
+		}
+
+		ArrowFree(schema->children);
+	}
+
+	// This object owns the memory for the dictionary but it
+	// may have been generated somewhere else and have its own
+	// release() callback.
+	if (schema->dictionary != NULL) {
+		if (schema->dictionary->release != NULL) {
+			schema->dictionary->release(schema->dictionary);
+		}
+
+		ArrowFree(schema->dictionary);
+	}
+
+	// private data not currently used
+	if (schema->private_data != NULL) {
+		ArrowFree(schema->private_data);
+	}
+
+	schema->release = NULL;
+}
+
+const char *ArrowSchemaFormatTemplate(enum ArrowType data_type) {
+	switch (data_type) {
+	case NANOARROW_TYPE_UNINITIALIZED:
+		return NULL;
+	case NANOARROW_TYPE_NA:
+		return "n";
+	case NANOARROW_TYPE_BOOL:
+		return "b";
+
+	case NANOARROW_TYPE_UINT8:
+		return "C";
+	case NANOARROW_TYPE_INT8:
+		return "c";
+	case NANOARROW_TYPE_UINT16:
+		return "S";
+	case NANOARROW_TYPE_INT16:
+		return "s";
+	case NANOARROW_TYPE_UINT32:
+		return "I";
+	case NANOARROW_TYPE_INT32:
+		return "i";
+	case NANOARROW_TYPE_UINT64:
+		return "L";
+	case NANOARROW_TYPE_INT64:
+		return "l";
+
+	case NANOARROW_TYPE_HALF_FLOAT:
+		return "e";
+	case NANOARROW_TYPE_FLOAT:
+		return "f";
+	case NANOARROW_TYPE_DOUBLE:
+		return "g";
+
+	case NANOARROW_TYPE_STRING:
+		return "u";
+	case NANOARROW_TYPE_LARGE_STRING:
+		return "U";
+	case NANOARROW_TYPE_BINARY:
+		return "z";
+	case NANOARROW_TYPE_LARGE_BINARY:
+		return "Z";
+
+	case NANOARROW_TYPE_DATE32:
+		return "tdD";
+	case NANOARROW_TYPE_DATE64:
+		return "tdm";
+	case NANOARROW_TYPE_INTERVAL_MONTHS:
+		return "tiM";
+	case NANOARROW_TYPE_INTERVAL_DAY_TIME:
+		return "tiD";
+	case NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO:
+		return "tin";
+
+	case NANOARROW_TYPE_LIST:
+		return "+l";
+	case NANOARROW_TYPE_LARGE_LIST:
+		return "+L";
+	case NANOARROW_TYPE_STRUCT:
+		return "+s";
+	case NANOARROW_TYPE_MAP:
+		return "+m";
+
+	default:
+		return NULL;
+	}
+}
+
+ArrowErrorCode ArrowSchemaInit(struct ArrowSchema *schema, enum ArrowType data_type) {
+	schema->format = NULL;
+	schema->name = NULL;
+	schema->metadata = NULL;
+	schema->flags = ARROW_FLAG_NULLABLE;
+	schema->n_children = 0;
+	schema->children = NULL;
+	schema->dictionary = NULL;
+	schema->private_data = NULL;
+	schema->release = &ArrowSchemaRelease;
+
+	// We don't allocate the dictionary because it has to be nullptr
+	// for non-dictionary-encoded arrays.
+
+	// Set the format to a valid format string for data_type
+	const char *template_format = ArrowSchemaFormatTemplate(data_type);
+
+	// If data_type isn't recognized and not explicitly unset
+	if (template_format == NULL && data_type != NANOARROW_TYPE_UNINITIALIZED) {
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	int result = ArrowSchemaSetFormat(schema, template_format);
+	if (result != NANOARROW_OK) {
+		schema->release(schema);
+		return result;
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaInitFixedSize(struct ArrowSchema *schema, enum ArrowType data_type, int32_t fixed_size) {
+	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
+	if (result != NANOARROW_OK) {
+		return result;
+	}
+
+	if (fixed_size <= 0) {
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	char buffer[64];
+	int n_chars;
+	switch (data_type) {
+	case NANOARROW_TYPE_FIXED_SIZE_BINARY:
+		n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size);
+		break;
+	case NANOARROW_TYPE_FIXED_SIZE_LIST:
+		n_chars = snprintf(buffer, sizeof(buffer), "+w:%d", (int)fixed_size);
+		break;
+	default:
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	buffer[n_chars] = '\0';
+	result = ArrowSchemaSetFormat(schema, buffer);
+	if (result != NANOARROW_OK) {
+		schema->release(schema);
+	}
+
+	return result;
+}
+
+ArrowErrorCode ArrowSchemaInitDecimal(struct ArrowSchema *schema, enum ArrowType data_type, int32_t decimal_precision,
+                                      int32_t decimal_scale) {
+	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
+	if (result != NANOARROW_OK) {
+		return result;
+	}
+
+	if (decimal_precision <= 0) {
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	char buffer[64];
+	int n_chars;
+	switch (data_type) {
+	case NANOARROW_TYPE_DECIMAL128:
+		n_chars = snprintf(buffer, sizeof(buffer), "d:%d,%d", decimal_precision, decimal_scale);
+		break;
+	case NANOARROW_TYPE_DECIMAL256:
+		n_chars = snprintf(buffer, sizeof(buffer), "d:%d,%d,256", decimal_precision, decimal_scale);
+		break;
+	default:
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	buffer[n_chars] = '\0';
+
+	result = ArrowSchemaSetFormat(schema, buffer);
+	if (result != NANOARROW_OK) {
+		schema->release(schema);
+		return result;
+	}
+
+	return NANOARROW_OK;
+}
+
+static const char *ArrowTimeUnitString(enum ArrowTimeUnit time_unit) {
+	switch (time_unit) {
+	case NANOARROW_TIME_UNIT_SECOND:
+		return "s";
+	case NANOARROW_TIME_UNIT_MILLI:
+		return "m";
+	case NANOARROW_TIME_UNIT_MICRO:
+		return "u";
+	case NANOARROW_TIME_UNIT_NANO:
+		return "n";
+	default:
+		return NULL;
+	}
+}
+
+ArrowErrorCode ArrowSchemaInitDateTime(struct ArrowSchema *schema, enum ArrowType data_type,
+                                       enum ArrowTimeUnit time_unit, const char *timezone) {
+	int result = ArrowSchemaInit(schema, NANOARROW_TYPE_UNINITIALIZED);
+	if (result != NANOARROW_OK) {
+		return result;
+	}
+
+	const char *time_unit_str = ArrowTimeUnitString(time_unit);
+	if (time_unit_str == NULL) {
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	char buffer[128];
+	int n_chars;
+	switch (data_type) {
+	case NANOARROW_TYPE_TIME32:
+	case NANOARROW_TYPE_TIME64:
+		if (timezone != NULL) {
+			schema->release(schema);
+			return EINVAL;
+		}
+		n_chars = snprintf(buffer, sizeof(buffer), "tt%s", time_unit_str);
+		break;
+	case NANOARROW_TYPE_TIMESTAMP:
+		if (timezone == NULL) {
+			timezone = "";
+		}
+		n_chars = snprintf(buffer, sizeof(buffer), "ts%s:%s", time_unit_str, timezone);
+		break;
+	case NANOARROW_TYPE_DURATION:
+		if (timezone != NULL) {
+			schema->release(schema);
+			return EINVAL;
+		}
+		n_chars = snprintf(buffer, sizeof(buffer), "tD%s", time_unit_str);
+		break;
+	default:
+		schema->release(schema);
+		return EINVAL;
+	}
+
+	if (static_cast<size_t>(n_chars) >= sizeof(buffer)) {
+		schema->release(schema);
+		return ERANGE;
+	}
+
+	buffer[n_chars] = '\0';
+
+	result = ArrowSchemaSetFormat(schema, buffer);
+	if (result != NANOARROW_OK) {
+		schema->release(schema);
+		return result;
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaSetFormat(struct ArrowSchema *schema, const char *format) {
+	if (schema->format != NULL) {
+		ArrowFree((void *)schema->format);
+	}
+
+	if (format != NULL) {
+		size_t format_size = strlen(format) + 1;
+		schema->format = (const char *)ArrowMalloc(format_size);
+		if (schema->format == NULL) {
+			return ENOMEM;
+		}
+
+		memcpy((void *)schema->format, format, format_size);
+	} else {
+		schema->format = NULL;
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaSetName(struct ArrowSchema *schema, const char *name) {
+	if (schema->name != NULL) {
+		ArrowFree((void *)schema->name);
+	}
+
+	if (name != NULL) {
+		size_t name_size = strlen(name) + 1;
+		schema->name = (const char *)ArrowMalloc(name_size);
+		if (schema->name == NULL) {
+			return ENOMEM;
+		}
+
+		memcpy((void *)schema->name, name, name_size);
+	} else {
+		schema->name = NULL;
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaSetMetadata(struct ArrowSchema *schema, const char *metadata) {
+	if (schema->metadata != NULL) {
+		ArrowFree((void *)schema->metadata);
+	}
+
+	if (metadata != NULL) {
+		size_t metadata_size = ArrowMetadataSizeOf(metadata);
+		schema->metadata = (const char *)ArrowMalloc(metadata_size);
+		if (schema->metadata == NULL) {
+			return ENOMEM;
+		}
+
+		memcpy((void *)schema->metadata, metadata, metadata_size);
+	} else {
+		schema->metadata = NULL;
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaAllocateChildren(struct ArrowSchema *schema, int64_t n_children) {
+	if (schema->children != NULL) {
+		return EEXIST;
+	}
+
+	if (n_children > 0) {
+		schema->children = (struct ArrowSchema **)ArrowMalloc(n_children * sizeof(struct ArrowSchema *));
+
+		if (schema->children == NULL) {
+			return ENOMEM;
+		}
+
+		schema->n_children = n_children;
+
+		memset(schema->children, 0, n_children * sizeof(struct ArrowSchema *));
+
+		for (int64_t i = 0; i < n_children; i++) {
+			schema->children[i] = (struct ArrowSchema *)ArrowMalloc(sizeof(struct ArrowSchema));
+
+			if (schema->children[i] == NULL) {
+				return ENOMEM;
+			}
+
+			schema->children[i]->release = NULL;
+		}
+	}
+
+	return NANOARROW_OK;
+}
+
+ArrowErrorCode ArrowSchemaAllocateDictionary(struct ArrowSchema *schema) {
+	if (schema->dictionary != NULL) {
+		return EEXIST;
+	}
+
+	schema->dictionary = (struct ArrowSchema *)ArrowMalloc(sizeof(struct ArrowSchema));
+	if (schema->dictionary == NULL) {
+		return ENOMEM;
+	}
+
+	schema->dictionary->release = NULL;
+	return NANOARROW_OK;
+}
+
+int ArrowSchemaDeepCopy(struct ArrowSchema *schema, struct ArrowSchema *schema_out) {
+	int result;
+	result = ArrowSchemaInit(schema_out, NANOARROW_TYPE_NA);
+	if (result != NANOARROW_OK) {
+		return result;
+	}
+
+	result = ArrowSchemaSetFormat(schema_out, schema->format);
+	if (result != NANOARROW_OK) {
+		schema_out->release(schema_out);
+		return result;
+	}
+
+	result = ArrowSchemaSetName(schema_out, schema->name);
+	if (result != NANOARROW_OK) {
+		schema_out->release(schema_out);
+		return result;
+	}
+
+	result = ArrowSchemaSetMetadata(schema_out, schema->metadata);
+	if (result != NANOARROW_OK) {
+		schema_out->release(schema_out);
+		return result;
+	}
+
+	result = ArrowSchemaAllocateChildren(schema_out, schema->n_children);
+	if (result != NANOARROW_OK) {
+		schema_out->release(schema_out);
+		return result;
+	}
+
+	for (int64_t i = 0; i < schema->n_children; i++) {
+		result = ArrowSchemaDeepCopy(schema->children[i], schema_out->children[i]);
+		if (result != NANOARROW_OK) {
+			schema_out->release(schema_out);
+			return result;
+		}
+	}
+
+	if (schema->dictionary != NULL) {
+		result = ArrowSchemaAllocateDictionary(schema_out);
+		if (result != NANOARROW_OK) {
+			schema_out->release(schema_out);
+			return result;
+		}
+
+		result = ArrowSchemaDeepCopy(schema->dictionary, schema_out->dictionary);
+		if (result != NANOARROW_OK) {
+			schema_out->release(schema_out);
+			return result;
+		}
+	}
+
+	return NANOARROW_OK;
+}
+
+} // namespace duckdb_nanoarrow

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

@@ -0,0 +1,84 @@
+#include "duckdb/common/adbc/single_batch_array_stream.hpp"
+#include "duckdb/common/arrow/nanoarrow/nanoarrow.h"
+#include "duckdb/common/adbc/adbc.hpp"
+
+#include "duckdb.h"
+#include "duckdb/common/arrow/arrow_wrapper.hpp"
+#include "duckdb/common/arrow/nanoarrow/nanoarrow.hpp"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace duckdb_adbc {
+
+using duckdb_nanoarrow::ArrowSchemaDeepCopy;
+
+static const char *SingleBatchArrayStreamGetLastError(struct ArrowArrayStream *stream) {
+	return NULL;
+}
+
+static int SingleBatchArrayStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *batch) {
+	if (!stream || !stream->private_data) {
+		return EINVAL;
+	}
+	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
+
+	memcpy(batch, &impl->batch, sizeof(*batch));
+	memset(&impl->batch, 0, sizeof(*batch));
+	return 0;
+}
+
+static int SingleBatchArrayStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *schema) {
+	if (!stream || !stream->private_data) {
+		return EINVAL;
+	}
+	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
+
+	return ArrowSchemaDeepCopy(&impl->schema, schema);
+}
+
+static void SingleBatchArrayStreamRelease(struct ArrowArrayStream *stream) {
+	if (!stream || !stream->private_data) {
+		return;
+	}
+	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)stream->private_data;
+	impl->schema.release(&impl->schema);
+	if (impl->batch.release) {
+		impl->batch.release(&impl->batch);
+	}
+	free(impl);
+
+	memset(stream, 0, sizeof(*stream));
+}
+
+AdbcStatusCode BatchToArrayStream(struct ArrowArray *values, struct ArrowSchema *schema,
+                                  struct ArrowArrayStream *stream, struct AdbcError *error) {
+	if (!values->release) {
+		SetError(error, "ArrowArray is not initialized");
+		return ADBC_STATUS_INTERNAL;
+	} else if (!schema->release) {
+		SetError(error, "ArrowSchema is not initialized");
+		return ADBC_STATUS_INTERNAL;
+	} else if (stream->release) {
+		SetError(error, "ArrowArrayStream is already initialized");
+		return ADBC_STATUS_INTERNAL;
+	}
+
+	struct SingleBatchArrayStream *impl = (struct SingleBatchArrayStream *)malloc(sizeof(*impl));
+	memcpy(&impl->schema, schema, sizeof(*schema));
+	memcpy(&impl->batch, values, sizeof(*values));
+	memset(schema, 0, sizeof(*schema));
+	memset(values, 0, sizeof(*values));
+	stream->private_data = impl;
+	stream->get_last_error = SingleBatchArrayStreamGetLastError;
+	stream->get_next = SingleBatchArrayStreamGetNext;
+	stream->get_schema = SingleBatchArrayStreamGetSchema;
+	stream->release = SingleBatchArrayStreamRelease;
+
+	return ADBC_STATUS_OK;
+}
+
+} // namespace duckdb_adbc

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -43,6 +43,7 @@ struct DuckDBArrowSchemaHolder {
 	std::list<vector<ArrowSchema *>> nested_children_ptr;
 	//! This holds strings created to represent decimal types
 	vector<unsafe_unique_array<char>> owned_type_names;
+	vector<unsafe_unique_array<char>> owned_column_names;
 };
 
 static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
@@ -59,7 +60,7 @@ void InitializeChild(ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, c
 	child.private_data = nullptr;
 	child.release = ReleaseDuckDBArrowSchema;
 
-	//! Store the child schema
+	// Store the child schema
 	child.flags = ARROW_FLAG_NULLABLE;
 	root_holder.owned_type_names.push_back(AddName(name));
 
@@ -69,6 +70,7 @@ void InitializeChild(ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, c
 	child.metadata = nullptr;
 	child.dictionary = nullptr;
 }
+
 void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
                     const ClientProperties &options);
 
@@ -309,7 +311,7 @@ void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector<Logical
 
 	// Configure all child schemas
 	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
-
+		root_holder->owned_column_names.push_back(AddName(names[col_idx]));
 		auto &child = root_holder->children[col_idx];
 		InitializeChild(child, *root_holder, names[col_idx]);
 		SetArrowFormat(*root_holder, child, types[col_idx], options);

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -550,6 +550,12 @@ Value MultiFileReaderOptions::GetHivePartitionValue(const string &base, const st
 	if (it == hive_types_schema.end()) {
 		return value;
 	}
+
+	// Handle nulls
+	if (base.empty() || StringUtil::CIEquals(base, "NULL")) {
+		return Value(it->second);
+	}
+
 	if (!value.TryCastAs(context, it->second)) {
 		throw InvalidInputException("Unable to cast '%s' (from hive partition column '%s') to: '%s'", value.ToString(),
 		                            StringUtil::Upper(it->first), it->second.ToString());

package/src/duckdb/src/execution/window_executor.cpp

@@ -1163,9 +1163,9 @@ void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorState &lstate, Vector
 		}
 		int64_t val_idx = (int64_t)row_idx;
 		if (wexpr.type == ExpressionType::WINDOW_LEAD) {
-			val_idx += offset;
+			val_idx = AddOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
 		} else {
-			val_idx -= offset;
+			val_idx = SubtractOperatorOverflowCheck::Operation<int64_t, int64_t, int64_t>(val_idx, offset);
 		}
 
 		idx_t delta = 0;
@@ -1200,10 +1200,9 @@ void WindowFirstValueExecutor::EvaluateInternal(WindowExecutorState &lstate, Vec
 	auto &lbstate = lstate.Cast<WindowExecutorBoundsState>();
 	auto window_begin = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_BEGIN]);
 	auto window_end = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_END]);
-	auto &rmask = FlatVector::Validity(result);
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		if (window_begin[i] >= window_end[i]) {
-			rmask.SetInvalid(i);
+			FlatVector::SetNull(result, i, true);
 			continue;
 		}
 		//	Same as NTH_VALUE(..., 1)
@@ -1228,10 +1227,9 @@ void WindowLastValueExecutor::EvaluateInternal(WindowExecutorState &lstate, Vect
 	auto &lbstate = lstate.Cast<WindowExecutorBoundsState>();
 	auto window_begin = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_BEGIN]);
 	auto window_end = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_END]);
-	auto &rmask = FlatVector::Validity(result);
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		if (window_begin[i] >= window_end[i]) {
-			rmask.SetInvalid(i);
+			FlatVector::SetNull(result, i, true);
 			continue;
 		}
 		idx_t n = 1;
@@ -1257,10 +1255,9 @@ void WindowNthValueExecutor::EvaluateInternal(WindowExecutorState &lstate, Vecto
 	auto &lbstate = lstate.Cast<WindowExecutorBoundsState>();
 	auto window_begin = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_BEGIN]);
 	auto window_end = FlatVector::GetData<const idx_t>(lbstate.bounds.data[WINDOW_END]);
-	auto &rmask = FlatVector::Validity(result);
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		if (window_begin[i] >= window_end[i]) {
-			rmask.SetInvalid(i);
+			FlatVector::SetNull(result, i, true);
 			continue;
 		}
 		// Returns value evaluated at the row that is the n'th row of the window frame (counting from 1);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2842"
+#define DUCKDB_VERSION "0.8.2-dev3007"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "6421a36e94"
+#define DUCKDB_SOURCE_ID "dd7f0c0870"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/adbc/adbc.h

@@ -52,6 +52,7 @@
 
 //! @cond Doxygen_Suppress
 namespace duckdb_adbc {
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp

@@ -84,10 +84,10 @@ AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struc
                                           struct AdbcPartitions *partitions, int64_t *rows_affected,
                                           struct AdbcError *error);
 
+//! This method should only be called when the string is guaranteed to not be NULL
 void SetError(struct AdbcError *error, const std::string &message);
+void SetError(struct AdbcError *error, const char *message);
 
-void InitiliazeADBCError(AdbcError *error);
-
-AdbcStatusCode SetErrorMaybe(const void *result, AdbcError *error, const std::string &error_message);
+void InitializeADBCError(AdbcError *error);
 
 } // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/adbc/single_batch_array_stream.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "duckdb/common/arrow/arrow.hpp"
+#include "duckdb/common/adbc/adbc.h"
+
+namespace duckdb_adbc {
+
+struct SingleBatchArrayStream {
+	struct ArrowSchema schema;
+	struct ArrowArray batch;
+};
+
+AdbcStatusCode BatchToArrayStream(struct ArrowArray *values, struct ArrowSchema *schema,
+                                  struct ArrowArrayStream *stream, struct AdbcError *error);
+
+} // namespace duckdb_adbc