duckdb 0.8.2-dev2320.0 → 0.8.2-dev2356.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2320.0",
+  "version": "0.8.2-dev2356.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -297,6 +297,7 @@ void ParquetWriter::PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGro
 	// set up a new row group for this chunk collection
 	auto &row_group = result.row_group;
 	row_group.num_rows = buffer.Count();
+	row_group.total_byte_size = buffer.SizeInBytes();
 	row_group.__isset.file_offset = true;
 
 	auto &states = result.states;

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

@@ -202,14 +202,15 @@ AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection *connection, const
 		SetError(error, "Connection is not set");
 		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
+	if (db_schema == nullptr) {
+		// if schema is not set, we use the default schema
+		db_schema = "main";
+	}
 	if (catalog != nullptr && strlen(catalog) > 0) {
 		// In DuckDB this is the name of the database, not sure what's the expected functionality here, so for now,
 		// scream.
 		SetError(error, "Catalog Name is not used in DuckDB. It must be set to nullptr or an empty string");
 		return ADBC_STATUS_NOT_IMPLEMENTED;
-	} else if (db_schema == nullptr) {
-		SetError(error, "AdbcConnectionGetTableSchema: must provide db_schema");
-		return ADBC_STATUS_INVALID_ARGUMENT;
 	} else if (table_name == nullptr) {
 		SetError(error, "AdbcConnectionGetTableSchema: must provide table_name");
 		return ADBC_STATUS_INVALID_ARGUMENT;
@@ -686,6 +687,10 @@ AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArra
 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 (depth != 0) {
+		SetError(error, "Depth parameter not yet supported");
+		return ADBC_STATUS_NOT_IMPLEMENTED;
+	}
 	if (catalog != nullptr) {
 		if (strcmp(catalog, "duckdb") == 0) {
 			SetError(error, "catalog must be NULL or 'duckdb'");

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

@@ -14,7 +14,7 @@ namespace duckdb {
 // ArrowAppender
 //===--------------------------------------------------------------------===//
 
-ArrowAppender::ArrowAppender(vector<LogicalType> types_p, idx_t initial_capacity, ArrowOptions options)
+ArrowAppender::ArrowAppender(vector<LogicalType> types_p, idx_t initial_capacity, ClientProperties options)
     : types(std::move(types_p)) {
 	for (auto &type : types) {
 		auto entry = ArrowAppender::InitializeChild(type, initial_capacity, options);
@@ -179,14 +179,14 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::BIT:
-		if (append_data.options.offset_size == ArrowOffsetSize::LARGE) {
+		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			InitializeAppenderForType<ArrowVarcharData<string_t>>(append_data);
 		} else {
 			InitializeAppenderForType<ArrowVarcharData<string_t, ArrowVarcharConverter, uint32_t>>(append_data);
 		}
 		break;
 	case LogicalTypeId::UUID:
-		if (append_data.options.offset_size == ArrowOffsetSize::LARGE) {
+		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter>>(append_data);
 		} else {
 			InitializeAppenderForType<ArrowVarcharData<hugeint_t, ArrowUUIDConverter, uint32_t>>(append_data);
@@ -228,7 +228,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 }
 
 unique_ptr<ArrowAppendData> ArrowAppender::InitializeChild(const LogicalType &type, idx_t capacity,
-                                                           ArrowOptions &options) {
+                                                           ClientProperties &options) {
 	auto result = make_uniq<ArrowAppendData>(options);
 	InitializeFunctionPointers(*result, type);
 

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

@@ -15,12 +15,21 @@
 
 namespace duckdb {
 
-void ArrowConverter::ToArrowArray(DataChunk &input, ArrowArray *out_array, ArrowOptions options) {
+void ArrowConverter::ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options) {
 	ArrowAppender appender(input.GetTypes(), input.size(), std::move(options));
 	appender.Append(input, 0, input.size(), input.size());
 	*out_array = appender.Finalize();
 }
 
+unsafe_unique_array<char> AddName(const string &name) {
+	auto name_ptr = make_unsafe_uniq_array<char>(name.size() + 1);
+	for (size_t i = 0; i < name.size(); i++) {
+		name_ptr[i] = name[i];
+	}
+	name_ptr[name.size()] = '\0';
+	return name_ptr;
+}
+
 //===--------------------------------------------------------------------===//
 // Arrow Schema
 //===--------------------------------------------------------------------===//
@@ -45,24 +54,26 @@ static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) {
 	delete holder;
 }
 
-void InitializeChild(ArrowSchema &child, const string &name = "") {
+void InitializeChild(ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, const string &name = "") {
 	//! Child is cleaned up by parent
 	child.private_data = nullptr;
 	child.release = ReleaseDuckDBArrowSchema;
 
 	//! Store the child schema
 	child.flags = ARROW_FLAG_NULLABLE;
-	child.name = name.c_str();
+	root_holder.owned_type_names.push_back(AddName(name));
+
+	child.name = root_holder.owned_type_names.back().get();
 	child.n_children = 0;
 	child.children = nullptr;
 	child.metadata = nullptr;
 	child.dictionary = nullptr;
 }
 void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    const ArrowOptions &options);
+                    const ClientProperties &options);
 
 void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                       const ArrowOptions &options) {
+                       const ClientProperties &options) {
 	child.format = "+m";
 	//! Map has one child which is a struct
 	child.n_children = 1;
@@ -70,23 +81,14 @@ void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child,
 	root_holder.nested_children.back().resize(1);
 	root_holder.nested_children_ptr.emplace_back();
 	root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-	InitializeChild(root_holder.nested_children.back()[0]);
+	InitializeChild(root_holder.nested_children.back()[0], root_holder);
 	child.children = &root_holder.nested_children_ptr.back()[0];
 	child.children[0]->name = "entries";
 	SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options);
 }
 
-unsafe_unique_array<char> AddName(const string &name) {
-	auto name_ptr = make_unsafe_uniq_array<char>(name.size() + 1);
-	for (size_t i = 0; i < name.size(); i++) {
-		name_ptr[i] = name[i];
-	}
-	name_ptr[name.size()] = '\0';
-	return name_ptr;
-}
-
 void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type,
-                    const ArrowOptions &options) {
+                    const ClientProperties &options) {
 	switch (type.id()) {
 	case LogicalTypeId::BOOLEAN:
 		child.format = "b";
@@ -126,7 +128,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::UUID:
 	case LogicalTypeId::VARCHAR:
-		if (options.offset_size == ArrowOffsetSize::LARGE) {
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			child.format = "U";
 		} else {
 			child.format = "u";
@@ -136,7 +138,6 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "tdD";
 		break;
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		child.format = "ttu";
 		break;
 	case LogicalTypeId::TIMESTAMP:
@@ -174,7 +175,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 	}
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::BIT: {
-		if (options.offset_size == ArrowOffsetSize::LARGE) {
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			child.format = "Z";
 		} else {
 			child.format = "z";
@@ -188,7 +189,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		root_holder.nested_children.back().resize(1);
 		root_holder.nested_children_ptr.emplace_back();
 		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0]);
+		InitializeChild(root_holder.nested_children.back()[0], root_holder);
 		child.children = &root_holder.nested_children_ptr.back()[0];
 		child.children[0]->name = "l";
 		SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options);
@@ -208,7 +209,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.children = &root_holder.nested_children_ptr.back()[0];
 		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
 
-			InitializeChild(*child.children[type_idx]);
+			InitializeChild(*child.children[type_idx], root_holder);
 
 			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
 
@@ -236,7 +237,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.children = &root_holder.nested_children_ptr.back()[0];
 		for (size_t type_idx = 0; type_idx < child_types.size(); type_idx++) {
 
-			InitializeChild(*child.children[type_idx]);
+			InitializeChild(*child.children[type_idx], root_holder);
 
 			root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first));
 
@@ -272,18 +273,18 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		root_holder.nested_children.back().resize(1);
 		root_holder.nested_children_ptr.emplace_back();
 		root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]);
-		InitializeChild(root_holder.nested_children.back()[0]);
+		InitializeChild(root_holder.nested_children.back()[0], root_holder);
 		child.dictionary = root_holder.nested_children_ptr.back()[0];
 		child.dictionary->format = "u";
 		break;
 	}
 	default:
-		throw InternalException("Unsupported Arrow type " + type.ToString());
+		throw NotImplementedException("Unsupported Arrow type " + type.ToString());
 	}
 }
 
 void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector<LogicalType> &types,
-                                   const vector<string> &names, const ArrowOptions &options) {
+                                   const vector<string> &names, const ClientProperties &options) {
 	D_ASSERT(out_schema);
 	D_ASSERT(types.size() == names.size());
 	idx_t column_count = types.size();
@@ -310,7 +311,7 @@ void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector<Logical
 	for (idx_t col_idx = 0; col_idx < column_count; col_idx++) {
 
 		auto &child = root_holder->children[col_idx];
-		InitializeChild(child, names[col_idx]);
+		InitializeChild(child, *root_holder, names[col_idx]);
 		SetArrowFormat(*root_holder, child, types[col_idx], options);
 	}
 

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

@@ -69,7 +69,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	if (!my_stream->column_types.empty()) {
 		ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
-		                              QueryResult::GetArrowOptions(*my_stream->result));
+		                              my_stream->result->client_properties);
 		return 0;
 	}
 
@@ -90,7 +90,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 		my_stream->column_names = result.names;
 	}
 	ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
-	                              QueryResult::GetArrowOptions(*my_stream->result));
+	                              my_stream->result->client_properties);
 	return 0;
 }
 
@@ -119,7 +119,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	idx_t result_count;
 	PreservedError error;
-	if (!ArrowUtil::TryFetchChunk(scan_state, result.GetArrowOptions(result), my_stream->batch_size, out, result_count,
+	if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count,
 	                              error)) {
 		D_ASSERT(error);
 		my_stream->last_error = error;
@@ -165,7 +165,7 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
 }
 
-bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t batch_size, ArrowArray *out,
+bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out,
                               idx_t &count, PreservedError &error) {
 	count = 0;
 	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
@@ -209,7 +209,7 @@ bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ArrowOptions options,
 	return true;
 }
 
-idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out) {
+idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) {
 	PreservedError error;
 	idx_t result_count;
 	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2320"
+#define DUCKDB_VERSION "0.8.2-dev2356"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "02412e1015"
+#define DUCKDB_SOURCE_ID "ef2efd1b9d"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp

@@ -4,7 +4,7 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/arrow/arrow.hpp"
 #include "duckdb/common/arrow/arrow_buffer.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 #include "duckdb/common/array.hpp"
 
 namespace duckdb {
@@ -26,7 +26,7 @@ typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type
 // FIXME: we should separate the append state variables from the variables required by the ArrowArray into
 // ArrowAppendState
 struct ArrowAppendData {
-	explicit ArrowAppendData(ArrowOptions &options_p) : options(options_p) {
+	explicit ArrowAppendData(ClientProperties &options_p) : options(options_p) {
 	}
 	// the buffers of the arrow vector
 	ArrowBuffer validity;
@@ -49,7 +49,7 @@ struct ArrowAppendData {
 	duckdb::array<const void *, 3> buffers = {{nullptr, nullptr, nullptr}};
 	vector<ArrowArray *> child_pointers;
 
-	ArrowOptions options;
+	ClientProperties options;
 };
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp

@@ -62,7 +62,7 @@ struct ArrowVarcharData {
 		auto last_offset = offset_data[append_data.row_count];
 		idx_t max_offset = append_data.row_count + to - from;
 		if (max_offset > NumericLimits<uint32_t>::Maximum() &&
-		    append_data.options.offset_size == ArrowOffsetSize::REGULAR) {
+		    append_data.options.arrow_offset_size == ArrowOffsetSize::REGULAR) {
 			throw InvalidInputException("Arrow Appender: The maximum total string size for regular string buffers is "
 			                            "%u but the offset of %lu exceeds this.",
 			                            NumericLimits<uint32_t>::Maximum(), max_offset);

package/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp

@@ -19,7 +19,7 @@ struct ArrowAppendData;
 //! The ArrowAppender class can be used to incrementally construct an arrow array by appending data chunks into it
 class ArrowAppender {
 public:
-	DUCKDB_API ArrowAppender(vector<LogicalType> types, idx_t initial_capacity, ArrowOptions options);
+	DUCKDB_API ArrowAppender(vector<LogicalType> types, idx_t initial_capacity, ClientProperties options);
 	DUCKDB_API ~ArrowAppender();
 
 	//! Append a data chunk to the underlying arrow array
@@ -30,7 +30,8 @@ public:
 public:
 	static void ReleaseArray(ArrowArray *array);
 	static ArrowArray *FinalizeChild(const LogicalType &type, ArrowAppendData &append_data);
-	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, idx_t capacity, ArrowOptions &options);
+	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, idx_t capacity,
+	                                                   ClientProperties &options);
 
 private:
 	//! The types of the chunks that will be appended in
@@ -40,7 +41,7 @@ private:
 	//! The total row count that has been appended
 	idx_t row_count = 0;
 
-	ArrowOptions options;
+	ClientProperties options;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp

@@ -10,7 +10,7 @@
 
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/arrow/arrow.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 struct ArrowSchema;
 
@@ -18,8 +18,8 @@ namespace duckdb {
 
 struct ArrowConverter {
 	DUCKDB_API static void ToArrowSchema(ArrowSchema *out_schema, const vector<LogicalType> &types,
-	                                     const vector<string> &names, const ArrowOptions &options);
-	DUCKDB_API static void ToArrowArray(DataChunk &input, ArrowArray *out_array, ArrowOptions options);
+	                                     const vector<string> &names, const ClientProperties &options);
+	DUCKDB_API static void ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_wrapper.hpp

@@ -11,7 +11,7 @@
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/preserved_error.hpp"
 #include "duckdb/main/chunk_scan_state.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 //! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
 namespace duckdb {
@@ -58,9 +58,9 @@ public:
 
 class ArrowUtil {
 public:
-	static bool TryFetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out,
+	static bool TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out,
 	                          idx_t &result_count, PreservedError &error);
-	static idx_t FetchChunk(ChunkScanState &scan_state, ArrowOptions options, idx_t chunk_size, ArrowArray *out);
+	static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out);
 
 private:
 	static bool TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &out, PreservedError &error);

package/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp

@@ -13,7 +13,6 @@
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/main/appender.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
 
 #include <cstring>
 #include <cassert>
@@ -48,7 +47,7 @@ struct PendingStatementWrapper {
 struct ArrowResultWrapper {
 	unique_ptr<MaterializedQueryResult> result;
 	unique_ptr<DataChunk> current_chunk;
-	ArrowOptions options;
+	ClientProperties options;
 };
 
 struct AppenderWrapper {

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -115,8 +115,6 @@ public:
 	static ClientConfig &GetConfig(ClientContext &context);
 	static const ClientConfig &GetConfig(const ClientContext &context);
 
-	string ExtractTimezone() const;
-
 	bool AnyVerification() {
 		return query_verification_enabled || verify_external || verify_serializer;
 	}

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -24,6 +24,7 @@
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 class Appender;

package/src/duckdb/src/include/duckdb/main/client_properties.hpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/client_properties.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <string>
+
+namespace duckdb {
+enum ArrowOffsetSize { REGULAR, LARGE };
+
+//! A set of properties from the client context that can be used to interpret the query result
+struct ClientProperties {
+	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
+	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
+	}
+	ClientProperties() {};
+	string time_zone = "UTC";
+	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -28,7 +28,7 @@
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 class BufferPool;

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -12,22 +12,13 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 struct BoxRendererConfig;
 
 enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT };
 
-//! A set of properties from the client context that can be used to interpret the query result
-struct ClientProperties {
-	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
-	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
-	}
-	string time_zone;
-	ArrowOffsetSize arrow_offset_size;
-};
-
 class BaseQueryResult {
 public:
 	//! Creates a successful query result with the specified names and types
@@ -133,9 +124,6 @@ public:
 		}
 	}
 
-	static ArrowOptions GetArrowOptions(QueryResult &query_result);
-	static string GetConfigTimezone(QueryResult &query_result);
-
 private:
 	class QueryResultIterator;
 	class QueryResultRow {

package/src/duckdb/src/include/duckdb/storage/object_cache.hpp

@@ -48,7 +48,7 @@ public:
 	}
 
 	template <class T, class... Args>
-	shared_ptr<T> GetOrCreate(const string &key, Args &&...args) {
+	shared_ptr<T> GetOrCreate(const string &key, Args &&... args) {
 		lock_guard<mutex> glock(lock);
 
 		auto entry = cache.find(key);

package/src/duckdb/src/main/capi/arrow-c.cpp

@@ -95,13 +95,7 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 		return DuckDBError;
 	}
 	auto arrow_wrapper = new ArrowResultWrapper();
-	if (wrapper->statement->context->config.set_variables.find("TimeZone") ==
-	    wrapper->statement->context->config.set_variables.end()) {
-		arrow_wrapper->options.time_zone = "UTC";
-	} else {
-		arrow_wrapper->options.time_zone =
-		    wrapper->statement->context->config.set_variables["TimeZone"].GetValue<std::string>();
-	}
+	arrow_wrapper->options = wrapper->statement->context->GetClientProperties();
 
 	auto result = wrapper->statement->Execute(wrapper->values, false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);

package/src/duckdb/src/main/client_context.cpp

@@ -1155,8 +1155,21 @@ ParserOptions ClientContext::GetParserOptions() const {
 }
 
 ClientProperties ClientContext::GetClientProperties() const {
-	auto client_context = ClientConfig::GetConfig(*this);
-	return {client_context.ExtractTimezone(), db->config.options.arrow_offset_size};
+	string timezone = "UTC";
+	Value result;
+	// 1) Check Set Variable
+	auto &client_config = ClientConfig::GetConfig(*this);
+	auto tz_config = client_config.set_variables.find("timezone");
+	if (tz_config == client_config.set_variables.end()) {
+		// 2) Check for Default Value
+		auto default_value = db->config.extension_parameters.find("timezone");
+		if (default_value != db->config.extension_parameters.end()) {
+			timezone = default_value->second.default_value.GetValue<string>();
+		}
+	} else {
+		timezone = tz_config->second.GetValue<string>();
+	}
+	return {timezone, db->config.options.arrow_offset_size};
 }
 
 bool ClientContext::ExecutionIsFinished() {

package/src/duckdb/src/main/database.cpp

@@ -397,15 +397,6 @@ bool DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &resul
 	return true;
 }
 
-string ClientConfig::ExtractTimezone() const {
-	auto entry = set_variables.find("TimeZone");
-	if (entry == set_variables.end()) {
-		return "UTC";
-	} else {
-		return entry->second.GetValue<std::string>();
-	}
-}
-
 ValidChecker &DatabaseInstance::GetValidChecker() {
 	return db_validity;
 }

package/src/duckdb/src/main/query_result.cpp

@@ -151,12 +151,4 @@ string QueryResult::HeaderToString() {
 	return result;
 }
 
-ArrowOptions QueryResult::GetArrowOptions(QueryResult &query_result) {
-	return {query_result.client_properties.arrow_offset_size, query_result.client_properties.time_zone};
-}
-
-string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	return query_result.client_properties.time_zone;
-}
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_options.hpp

@@ -1,25 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/arrow/arrow_options.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-namespace duckdb {
-
-enum ArrowOffsetSize { REGULAR, LARGE };
-
-struct ArrowOptions {
-	explicit ArrowOptions(ArrowOffsetSize offset_size_p) : offset_size(offset_size_p) {
-	}
-	ArrowOptions(ArrowOffsetSize offset_size_p, string timezone_p) : offset_size(offset_size_p), time_zone(timezone_p) {
-	}
-	ArrowOptions() {
-	}
-	ArrowOffsetSize offset_size = ArrowOffsetSize::REGULAR;
-	string time_zone = "UTC";
-};
-} // namespace duckdb