duckdb 0.8.2-dev2283.0 → 0.8.2-dev2356.0

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

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/preserved_error.hpp"
+
+namespace duckdb {
+
+class DataChunk;
+
+//! Abstract chunk fetcher
+class ChunkScanState {
+public:
+	explicit ChunkScanState() {
+	}
+	virtual ~ChunkScanState() {
+	}
+
+public:
+	ChunkScanState(const ChunkScanState &other) = delete;
+	ChunkScanState(ChunkScanState &&other) = default;
+	ChunkScanState &operator=(const ChunkScanState &other) = delete;
+	ChunkScanState &operator=(ChunkScanState &&other) = default;
+
+public:
+	virtual bool LoadNextChunk(PreservedError &error) = 0;
+	virtual bool HasError() const = 0;
+	virtual PreservedError &GetError() = 0;
+	virtual const vector<LogicalType> &Types() const = 0;
+	virtual const vector<string> &Names() const = 0;
+	idx_t CurrentOffset() const;
+	idx_t RemainingInChunk() const;
+	DataChunk &CurrentChunk();
+	bool ChunkIsEmpty() const;
+	bool Finished() const;
+	bool ScanStarted() const;
+	void IncreaseOffset(idx_t increment, bool unsafe = false);
+
+protected:
+	idx_t offset = 0;
+	bool finished = false;
+	unique_ptr<DataChunk> current_chunk;
+};
+
+} // namespace duckdb

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/extension_entries.hpp

@@ -162,6 +162,9 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"st_removerepeatedpoints", "spatial"},
                                                          {"st_geomfromgeojson", "spatial"},
                                                          {"st_readosm", "spatial"},
+                                                         {"st_reduceprecision", "spatial"},
+                                                         {"st_geomfromhexwkb", "spatial"},
+                                                         {"st_geomfromhexewkb", "spatial"},
                                                          {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {

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
@@ -63,16 +54,7 @@ protected:
 	//! The error (in case execution was not successful)
 	PreservedError error;
 };
-struct CurrentChunk {
-	//! The current data chunk
-	unique_ptr<DataChunk> data_chunk;
-	//! The current position in the data chunk
-	idx_t position;
-	//! If we have a current chunk we must scan for result production
-	bool Valid();
-	//! The remaining size of the current chunk
-	idx_t RemainingSize();
-};
+
 //! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
 //! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
 //! incrementally fetch data from the database.
@@ -89,10 +71,6 @@ public:
 	ClientProperties client_properties;
 	//! The next result (if any)
 	unique_ptr<QueryResult> next;
-	//! In case we are converting the result from Native DuckDB to a different library (e.g., Arrow, Polars)
-	//! We might be producing chunks of a pre-determined size.
-	//! To comply, we use the following variable to store the current chunk, and it's position.
-	CurrentChunk current_chunk;
 
 public:
 	template <class TARGET>
@@ -146,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/parser/transformer.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/stack_checker.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/group_by_node.hpp"
@@ -26,7 +27,6 @@
 namespace duckdb {
 
 class ColumnDefinition;
-class StackChecker;
 struct OrderByNode;
 struct CopyInfo;
 struct CommonTableExpressionInfo;
@@ -39,7 +39,7 @@ struct PivotColumn;
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
 class Transformer {
-	friend class StackChecker;
+	friend class StackChecker<Transformer>;
 
 	struct CreatePivotEntry {
 		string enum_name;
@@ -343,7 +343,7 @@ private:
 	idx_t stack_depth;
 
 	void InitializeStackCheck();
-	StackChecker StackCheck(idx_t extra_stack = 1);
+	StackChecker<Transformer> StackCheck(idx_t extra_stack = 1);
 
 public:
 	template <class T>
@@ -356,18 +356,6 @@ public:
 	}
 };
 
-class StackChecker {
-public:
-	StackChecker(Transformer &transformer, idx_t stack_usage);
-	~StackChecker();
-	StackChecker(StackChecker &&) noexcept;
-	StackChecker(const StackChecker &) = delete;
-
-private:
-	Transformer &transformer;
-	idx_t stack_usage;
-};
-
 vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list);
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -9,11 +9,12 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/stack_checker.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/tokens.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
 
@@ -51,6 +52,8 @@ struct BindResult {
 };
 
 class ExpressionBinder {
+	friend class StackChecker<ExpressionBinder>;
+
 public:
 	ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder = false);
 	virtual ~ExpressionBinder();
@@ -110,6 +113,15 @@ public:
 
 	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
 
+private:
+	//! Maximum stack depth
+	static constexpr const idx_t MAXIMUM_STACK_DEPTH = 128;
+	//! Current stack depth
+	idx_t stack_depth = DConstants::INVALID_INDEX;
+
+	void InitializeStackCheck();
+	StackChecker<ExpressionBinder> StackCheck(const ParsedExpression &expr, idx_t extra_stack = 1);
+
 protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);

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/chunk_scan_state/query_result.cpp

@@ -0,0 +1,53 @@
+#include "duckdb/main/query_result.hpp"
+#include "duckdb/main/stream_query_result.hpp"
+#include "duckdb/main/chunk_scan_state/query_result.hpp"
+
+namespace duckdb {
+
+QueryResultChunkScanState::QueryResultChunkScanState(QueryResult &result) : ChunkScanState(), result(result) {
+}
+
+QueryResultChunkScanState::~QueryResultChunkScanState() {
+}
+
+bool QueryResultChunkScanState::InternalLoad(PreservedError &error) {
+	D_ASSERT(!finished);
+	if (result.type == QueryResultType::STREAM_RESULT) {
+		auto &stream_result = result.Cast<StreamQueryResult>();
+		if (!stream_result.IsOpen()) {
+			return true;
+		}
+	}
+	return result.TryFetch(current_chunk, error);
+}
+
+bool QueryResultChunkScanState::HasError() const {
+	return result.HasError();
+}
+
+PreservedError &QueryResultChunkScanState::GetError() {
+	D_ASSERT(result.HasError());
+	return result.GetErrorObject();
+}
+
+const vector<LogicalType> &QueryResultChunkScanState::Types() const {
+	return result.types;
+}
+
+const vector<string> &QueryResultChunkScanState::Names() const {
+	return result.names;
+}
+
+bool QueryResultChunkScanState::LoadNextChunk(PreservedError &error) {
+	if (finished) {
+		return !finished;
+	}
+	auto load_result = InternalLoad(error);
+	if (!load_result) {
+		finished = true;
+	}
+	offset = 0;
+	return !finished;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/chunk_scan_state.cpp

@@ -0,0 +1,42 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
+
+namespace duckdb {
+
+idx_t ChunkScanState::CurrentOffset() const {
+	return offset;
+}
+
+void ChunkScanState::IncreaseOffset(idx_t increment, bool unsafe) {
+	D_ASSERT(unsafe || increment <= RemainingInChunk());
+	offset += increment;
+}
+
+bool ChunkScanState::ChunkIsEmpty() const {
+	return !current_chunk || current_chunk->size() == 0;
+}
+
+bool ChunkScanState::Finished() const {
+	return finished;
+}
+
+bool ChunkScanState::ScanStarted() const {
+	return !ChunkIsEmpty();
+}
+
+DataChunk &ChunkScanState::CurrentChunk() {
+	// Scan must already be started
+	D_ASSERT(current_chunk);
+	return *current_chunk;
+}
+
+idx_t ChunkScanState::RemainingInChunk() const {
+	if (ChunkIsEmpty()) {
+		return 0;
+	}
+	D_ASSERT(current_chunk);
+	D_ASSERT(offset <= current_chunk->size());
+	return current_chunk->size() - offset;
+}
+
+} // namespace duckdb

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

@@ -57,19 +57,6 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
       client_properties(std::move(client_properties_p)) {
 }
 
-bool CurrentChunk::Valid() {
-	if (data_chunk) {
-		if (position < data_chunk->size()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-idx_t CurrentChunk::RemainingSize() {
-	return data_chunk->size() - position;
-}
-
 QueryResult::QueryResult(QueryResultType type, PreservedError error)
     : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR) {
 }
@@ -164,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/parser/transformer.cpp

@@ -9,20 +9,6 @@
 
 namespace duckdb {
 
-StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
-    : transformer(transformer_p), stack_usage(stack_usage_p) {
-	transformer.stack_depth += stack_usage;
-}
-
-StackChecker::~StackChecker() {
-	transformer.stack_depth -= stack_usage;
-}
-
-StackChecker::StackChecker(StackChecker &&other) noexcept
-    : transformer(other.transformer), stack_usage(other.stack_usage) {
-	other.stack_usage = 0;
-}
-
 Transformer::Transformer(ParserOptions &options)
     : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
@@ -59,7 +45,7 @@ void Transformer::InitializeStackCheck() {
 	stack_depth = 0;
 }
 
-StackChecker Transformer::StackCheck(idx_t extra_stack) {
+StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
 	auto &root = RootTransformer();
 	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
 	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
@@ -67,7 +53,7 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		                      "increase the maximum expression depth.",
 		                      options.max_expression_depth);
 	}
-	return StackChecker(root, extra_stack);
+	return StackChecker<Transformer>(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {

package/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp

@@ -1,12 +1,12 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
-#include "duckdb/function/scalar_macro_function.hpp"
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -79,8 +79,10 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 
-	// replace current expression with stored macro expression, and replace params
+	// replace current expression with stored macro expression
 	expr = macro_def.expression->Copy();
+
+	// now replace the parameters
 	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -134,33 +134,6 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	base.types = query_node.types;
 }
 
-static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
-	switch (expr->GetExpressionClass()) {
-	case ExpressionClass::FUNCTION: {
-		auto &func = expr->Cast<FunctionExpression>();
-		auto function = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog, func.schema,
-		                                  func.function_name, OnEntryNotFound::RETURN_NULL);
-		if (function) {
-			func.catalog = function->ParentCatalog().GetName();
-			func.schema = function->ParentSchema().name;
-		}
-		break;
-	}
-	case ExpressionClass::SUBQUERY: {
-		// replacing parameters within a subquery is slightly different
-		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
-		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-		break;
-	}
-	default: // fall through
-		break;
-	}
-	// unfold child expressions
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
-}
-
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = info.Cast<CreateMacroInfo>();
 	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
@@ -190,7 +163,6 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto this_macro_binding = make_uniq<DummyBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
 	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
-	QualifyFunctionNames(context, scalar_function.expression);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = scalar_function.expression->Copy();

package/src/duckdb/src/planner/expression_binder.cpp

@@ -10,6 +10,7 @@ namespace duckdb {
 
 ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
     : binder(binder), context(context) {
+	InitializeStackCheck();
 	if (replace_binder) {
 		stored_binder = &binder.GetActiveBinder();
 		binder.SetActiveBinder(*this);
@@ -28,7 +29,26 @@ ExpressionBinder::~ExpressionBinder() {
 	}
 }
 
+void ExpressionBinder::InitializeStackCheck() {
+	if (binder.HasActiveBinder()) {
+		stack_depth = binder.GetActiveBinder().stack_depth;
+	} else {
+		stack_depth = 0;
+	}
+}
+
+StackChecker<ExpressionBinder> ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) {
+	D_ASSERT(stack_depth != DConstants::INVALID_INDEX);
+	if (stack_depth + extra_stack >= MAXIMUM_STACK_DEPTH) {
+		throw BinderException("Maximum recursion depth exceeded (Maximum: %llu) while binding \"%s\"",
+		                      MAXIMUM_STACK_DEPTH, expr.ToString());
+	}
+	return StackChecker<ExpressionBinder>(*this, extra_stack);
+}
+
 BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
+	auto stack_checker = StackCheck(*expr);
+
 	auto &expr_ref = *expr;
 	switch (expr_ref.expression_class) {
 	case ExpressionClass::BETWEEN:

package/src/duckdb/ub_src_main.cpp

@@ -10,6 +10,8 @@
 
 #include "src/main/client_verify.cpp"
 
+#include "src/main/chunk_scan_state.cpp"
+
 #include "src/main/config.cpp"
 
 #include "src/main/connection.cpp"

package/src/duckdb/ub_src_main_chunk_scan_state.cpp

@@ -0,0 +1,2 @@
+#include "src/main/chunk_scan_state/query_result.cpp"
+

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