duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

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

@@ -12,6 +12,7 @@
 #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"
 
 namespace duckdb {
 struct BoxRendererConfig;
@@ -20,7 +21,11 @@ enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDI
 
 //! 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 {
@@ -141,6 +146,7 @@ public:
 		}
 	}
 
+	static ArrowOptions GetArrowOptions(QueryResult &query_result);
 	static string GetConfigTimezone(QueryResult &query_result);
 
 private:

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

@@ -309,6 +309,15 @@ struct LogQueryPathSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct LockConfigurationSetting {
+	static constexpr const char *Name = "lock_configuration";
+	static constexpr const char *Description = "Whether or not the configuration can be altered";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ImmediateTransactionModeSetting {
 	static constexpr const char *Name = "immediate_transaction_mode";
 	static constexpr const char *Description =
@@ -388,6 +397,16 @@ struct PreserveInsertionOrder {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct ExportLargeBufferArrow {
+	static constexpr const char *Name = "arrow_large_buffer_size";
+	static constexpr const char *Description =
+	    "If arrow buffers for strings, blobs, uuids and bits should be exported using large buffers";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ProfilerHistorySize {
 	static constexpr const char *Name = "profiler_history_size";
 	static constexpr const char *Description = "Sets the profiler history size";

package/src/duckdb/src/include/duckdb/optimizer/unnest_rewriter.hpp

@@ -45,6 +45,8 @@ public:
 
 	//! Contains all bindings that need to be updated
 	vector<ReplaceBinding> replace_bindings;
+	//! Stores the table index of the former child of the LOGICAL_UNNEST
+	idx_t overwritten_tbl_idx;
 };
 
 //! The UnnestRewriter optimizer traverses the logical operator tree and rewrites duplicate
@@ -79,6 +81,8 @@ private:
 	vector<LHSBinding> lhs_bindings;
 	//! Stores the table index of the former child of the LOGICAL_UNNEST
 	idx_t overwritten_tbl_idx;
+	//! The number of distinct columns to unnest
+	idx_t distinct_unnest_count;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parallel/meta_pipeline.hpp

@@ -14,6 +14,13 @@ namespace duckdb {
 
 class PhysicalRecursiveCTE;
 
+struct PipelineFinishGroup {
+	explicit PipelineFinishGroup(Pipeline *group_base_p) : group_base(group_base_p) {
+	}
+	Pipeline *group_base;
+	unordered_set<Pipeline *> group_members;
+};
+
 //! MetaPipeline represents a set of pipelines that all have the same sink
 class MetaPipeline : public std::enable_shared_from_this<MetaPipeline> {
 	//! We follow these rules when building:
@@ -57,7 +64,9 @@ public:
 	//! Make sure that the given pipeline has its own PipelineFinishEvent (e.g., for IEJoin - double Finalize)
 	void AddFinishEvent(Pipeline *pipeline);
 	//! Whether the pipeline needs its own PipelineFinishEvent
-	bool HasFinishEvent(Pipeline *pipeline);
+	bool HasFinishEvent(Pipeline *pipeline) const;
+	//! Whether this pipeline is part of a PipelineFinishEvent
+	optional_ptr<Pipeline> GetFinishGroup(Pipeline *pipeline) const;
 
 public:
 	//! Build the MetaPipeline with 'op' as the first operator (excl. the shared sink)
@@ -86,8 +95,6 @@ private:
 	bool recursive_cte;
 	//! All pipelines with a different source, but the same sink
 	vector<shared_ptr<Pipeline>> pipelines;
-	//! The pipelines that must finish before the MetaPipeline is finished
-	vector<Pipeline *> final_pipelines;
 	//! Dependencies within this MetaPipeline
 	unordered_map<Pipeline *, vector<Pipeline *>> dependencies;
 	//! Other MetaPipelines that this MetaPipeline depends on
@@ -96,6 +103,8 @@ private:
 	idx_t next_batch_index;
 	//! Pipelines (other than the base pipeline) that need their own PipelineFinishEvent (e.g., for IEJoin)
 	unordered_set<Pipeline *> finish_pipelines;
+	//! Mapping from pipeline (e.g., child or union) to finish pipeline
+	unordered_map<Pipeline *, Pipeline *> finish_map;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parser.hpp

@@ -62,6 +62,8 @@ public:
 	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
 	static ColumnList ParseColumnList(const string &column_list, ParserOptions options = ParserOptions());
 
+	static bool StripUnicodeSpaces(const string &query_str, string &new_query);
+
 private:
 	ParserOptions options;
 };

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp

@@ -11,7 +11,7 @@
 #include "duckdb/parser/tableref.hpp"
 
 namespace duckdb {
-//! Represents a cross product
+
 class EmptyTableRef : public TableRef {
 public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::EMPTY;

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp

@@ -93,9 +93,9 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a JoinRef
+	//! Serializes a blob into a PivotRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a JoinRef
+	//! Deserializes a blob back into a PivotRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 
 	void FormatSerialize(FormatSerializer &serializer) const override;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -127,8 +127,6 @@ private:
 	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGCreateFunctionStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
 	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGCreateTypeStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateDatabaseStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateDatabase(duckdb_libpgquery::PGCreateDatabaseStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
 	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGAlterSeqStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement

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

@@ -56,7 +56,7 @@ public:
 	//! or throws an exception if the column could not be bound.
 	BindResult BindColumn(ColumnRefExpression &colref, idx_t depth);
 	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
-	BindResult BindColumn(PositionalReferenceExpression &ref, idx_t depth);
+	unique_ptr<ColumnRefExpression> PositionToColumn(PositionalReferenceExpression &ref);
 
 	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &table_name, const string &column_name);
 

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

@@ -95,6 +95,9 @@ public:
 	unique_ptr<BoundOrderModifier> Copy() const;
 	static bool Equals(const BoundOrderModifier &left, const BoundOrderModifier &right);
 	static bool Equals(const unique_ptr<BoundOrderModifier> &left, const unique_ptr<BoundOrderModifier> &right);
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<BoundOrderModifier> Deserialize(Deserializer &source, PlanDeserializationState &state);
 };
 
 enum class DistinctType : uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };

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

@@ -124,8 +124,8 @@ protected:
 	                          const LogicalType &list_child_type);
 	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
 	BindResult BindExpression(ParameterExpression &expr, idx_t depth);
-	BindResult BindExpression(PositionalReferenceExpression &ref, idx_t depth);
 	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
+	BindResult BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
 
 	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
 	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type);

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

@@ -83,6 +83,11 @@ public:
 		return true;
 	}
 
+	//! Allows LogicalOperators to opt out of serialization
+	virtual bool SupportSerialization() const {
+		return true;
+	};
+
 	//! Returns the set of table indexes of this operator
 	virtual vector<idx_t> GetTableIndex() const;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_copy_to_file.hpp

@@ -8,10 +8,10 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
 #include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
+#include "duckdb/function/copy_function.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -41,6 +41,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp

@@ -29,6 +29,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -37,6 +37,10 @@ public:
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 3;
 	}
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/function/table_function.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/table_filter.hpp"
 
 namespace duckdb {
@@ -62,6 +62,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return function.verify_serialization;
+	};
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/function/pragma_function.hpp"
+#include "duckdb/parser/parsed_data/pragma_info.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -34,6 +34,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp

@@ -36,6 +36,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp

@@ -45,6 +45,7 @@ public:
 	inline T ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		T result = 0;
 		switch (bytes) {
+			// LCOV_EXCL_START
 		case 1:
 			result = Load<uint8_t>(buffer + index);
 			index++;
@@ -73,6 +74,7 @@ public:
 			memcpy(&result, (void *)(buffer + index), 7);
 			index += 7;
 			return result;
+			// LCOV_EXCL_STOP
 		default:
 			if (trailing_zero < 8) {
 				result = Load<T>(buffer + index);
@@ -93,6 +95,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 	uint32_t result = 0;
 	switch (bytes) {
 	case 0:
+		// LCOV_EXCL_START
 		if (trailing_zero < 8) {
 			result = Load<uint32_t>(buffer + index);
 			index += sizeof(uint32_t);
@@ -115,6 +118,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		result = Load<uint32_t>(buffer + index);
 		index += 4;
 		return result;
+		// LCOV_EXCL_STOP
 	default:
 		throw InternalException("Write of %llu bytes attempted into address pointing to 4 byte value", bytes);
 	}

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

@@ -181,7 +181,7 @@ public:
 
 	idx_t GetTotalRows();
 
-	void GetStorageInfo(TableStorageInfo &result);
+	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
 	static bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type);
 
 	//! Initializes a special scan that is used to create an index on the table, it keeps locks on the table

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

@@ -21,43 +21,43 @@ public:
 
 	// LCOV_EXCL_START
 	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - ConvertBlock!");
 	}
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - CreateBlock!");
 	}
 	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!");
 	}
 	bool IsRootBlock(block_id_t root) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!");
 	}
 	void MarkBlockAsFree(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsFree!");
 	}
 	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsModified!");
 	}
 	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IncreaseBlockReferenceCount!");
 	}
 	block_id_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
 	}
 	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Read!");
 	}
 	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Write!");
 	}
 	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - WriteHeader!");
 	}
 	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - TotalBlocks!");
 	}
 	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - FreeBlocks!");
 	}
 	// LCOV_EXCL_STOP
 };

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

@@ -104,8 +104,10 @@ public:
 	//! Obtains a lock and calls Vacuum while holding that lock
 	void Vacuum();
 
-	//! Returns the string representation of an index
-	virtual string ToString() = 0;
+	//! Returns the string representation of an index, or only traverses and verifies the index
+	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
+	//! Obtains a lock and calls VerifyAndToString while holding that lock
+	string VerifyAndToString(const bool only_verify);
 
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;

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

@@ -28,17 +28,11 @@ typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_i
                                                  const string &name, AttachInfo &info, AccessMode access_mode);
 typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog);
-typedef unique_ptr<TableFunctionRef> (*create_database_t)(StorageExtensionInfo *info, ClientContext &context,
-                                                          const string &database_name, const string &source_path);
-typedef unique_ptr<TableFunctionRef> (*drop_database_t)(StorageExtensionInfo *storage_info, ClientContext &context,
-                                                        const string &database_name);
 
 class StorageExtension {
 public:
 	attach_function_t attach;
 	create_transaction_manager_t create_transaction_manager;
-	create_database_t create_database;
-	drop_database_t drop_database;
 
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;

package/src/duckdb/src/include/duckdb/storage/table/column_data.hpp

@@ -130,7 +130,7 @@ public:
 	                                          idx_t start_row, Deserializer &source, const LogicalType &type,
 	                                          optional_ptr<ColumnData> parent);
 
-	virtual void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result);
+	virtual void GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path, vector<ColumnSegmentInfo> &result);
 	virtual void Verify(RowGroup &parent);
 
 	bool CheckZonemap(TableFilter &filter);

package/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp

@@ -58,7 +58,8 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
+	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
 private:
 	uint64_t FetchListOffset(idx_t row_idx);

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -31,7 +31,7 @@ class RowGroupCollection;
 class RowGroupWriter;
 class UpdateSegment;
 class TableStatistics;
-class TableStorageInfo;
+struct ColumnSegmentInfo;
 class Vector;
 struct ColumnCheckpointState;
 struct RowGroupPointer;
@@ -141,7 +141,7 @@ public:
 	void MergeIntoStatistics(idx_t column_idx, BaseStatistics &other);
 	unique_ptr<BaseStatistics> GetStatistics(idx_t column_idx);
 
-	void GetStorageInfo(idx_t row_group_index, TableStorageInfo &result);
+	void GetColumnSegmentInfo(idx_t row_group_index, vector<ColumnSegmentInfo> &result);
 
 	void Verify();
 

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -26,6 +26,7 @@ struct TableAppendState;
 class DuckTransaction;
 class BoundConstraint;
 class RowGroupSegmentTree;
+struct ColumnSegmentInfo;
 
 class RowGroupCollection {
 public:
@@ -88,7 +89,7 @@ public:
 	void CommitDropColumn(idx_t index);
 	void CommitDropTable();
 
-	void GetStorageInfo(TableStorageInfo &result);
+	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
 	const vector<LogicalType> &GetTypes() const;
 
 	shared_ptr<RowGroupCollection> AddColumn(ClientContext &context, ColumnDefinition &new_column,

package/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp

@@ -56,7 +56,8 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
+	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
 	void Verify(RowGroup &parent) override;
 };

package/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp

@@ -59,7 +59,8 @@ public:
 
 	void DeserializeColumn(Deserializer &source) override;
 
-	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
+	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
 	void Verify(RowGroup &parent) override;
 };

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

@@ -43,8 +43,6 @@ public:
 	idx_t cardinality = DConstants::INVALID_INDEX;
 	//! Info of the indexes of a table
 	vector<IndexInfo> index_info;
-	//! Info of the column segments of the table
-	vector<ColumnSegmentInfo> column_segments;
 };
 
 } // namespace duckdb

package/src/duckdb/src/main/attached_database.cpp

@@ -124,4 +124,12 @@ Catalog &AttachedDatabase::ParentCatalog() {
 	return *parent_catalog;
 }
 
+bool AttachedDatabase::IsInitialDatabase() const {
+	return is_initial_database;
+}
+
+void AttachedDatabase::SetInitialDatabase() {
+	is_initial_database = true;
+}
+
 } // namespace duckdb

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

@@ -25,7 +25,7 @@ duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema
 	}
 	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	ArrowConverter::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
-	                              wrapper->timezone_config);
+	                              wrapper->options);
 	return DuckDBSuccess;
 }
 
@@ -41,7 +41,7 @@ duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *o
 	if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) {
 		return DuckDBSuccess;
 	}
-	ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast<ArrowArray *>(*out_array));
+	ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast<ArrowArray *>(*out_array), wrapper->options);
 	return DuckDBSuccess;
 }
 
@@ -96,9 +96,9 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 	auto arrow_wrapper = new ArrowResultWrapper();
 	if (wrapper->statement->context->config.set_variables.find("TimeZone") ==
 	    wrapper->statement->context->config.set_variables.end()) {
-		arrow_wrapper->timezone_config = "UTC";
+		arrow_wrapper->options.time_zone = "UTC";
 	} else {
-		arrow_wrapper->timezone_config =
+		arrow_wrapper->options.time_zone =
 		    wrapper->statement->context->config.set_variables["TimeZone"].GetValue<std::string>();
 	}
 

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

@@ -42,13 +42,10 @@ duckdb_state duckdb_set_config(duckdb_config config, const char *name, const cha
 	if (!config || !name || !option) {
 		return DuckDBError;
 	}
-	auto config_option = DBConfig::GetOptionByName(name);
-	if (!config_option) {
-		return DuckDBError;
-	}
+
 	try {
 		auto db_config = (DBConfig *)config;
-		db_config->SetOption(*config_option, Value(option));
+		db_config->SetOptionByName(name, Value(option));
 	} catch (...) {
 		return DuckDBError;
 	}

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

@@ -319,6 +319,8 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 			planner.parameter_data.emplace_back(value);
 		}
 	}
+
+	client_data->http_state = make_shared<HTTPState>();
 	planner.CreatePlan(std::move(statement));
 	D_ASSERT(planner.plan || !planner.properties.bound_all_parameters);
 	profiler.EndPhase();
@@ -1153,9 +1155,8 @@ ParserOptions ClientContext::GetParserOptions() const {
 }
 
 ClientProperties ClientContext::GetClientProperties() const {
-	ClientProperties properties;
-	properties.time_zone = ClientConfig::GetConfig(*this).ExtractTimezone();
-	return properties;
+	auto client_context = ClientConfig::GetConfig(*this);
+	return {client_context.ExtractTimezone(), db->config.options.arrow_offset_size};
 }
 
 bool ClientContext::ExecutionIsFinished() {