duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -11,6 +11,8 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -97,6 +99,85 @@ public:
 		function.return_type = return_type;
 		return function;
 	}
+
+	template <class FUNC>
+	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
+	                            optional_ptr<FunctionData> bind_info) {
+		D_ASSERT(!function.name.empty());
+		serializer.WriteProperty(500, "name", function.name);
+		serializer.WriteProperty(501, "arguments", function.arguments);
+		serializer.WriteProperty(502, "original_arguments", function.original_arguments);
+		bool has_serialize = function.format_serialize;
+		serializer.WriteProperty(503, "has_serialize", has_serialize);
+		if (has_serialize) {
+			serializer.BeginObject(504, "function_data");
+			function.format_serialize(serializer, bind_info, function);
+			serializer.EndObject();
+			D_ASSERT(function.format_deserialize);
+		}
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static FUNC DeserializeFunction(ClientContext &context, CatalogType catalog_type, const string &name,
+	                                vector<LogicalType> arguments, vector<LogicalType> original_arguments) {
+		auto &func_catalog = Catalog::GetEntry(context, catalog_type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
+		if (func_catalog.type != catalog_type) {
+			throw InternalException("DeserializeFunction - cant find catalog entry for function %s", name);
+		}
+		auto &functions = func_catalog.Cast<CATALOG_ENTRY>();
+		auto function = functions.functions.GetFunctionByArguments(
+		    context, original_arguments.empty() ? arguments : original_arguments);
+		function.arguments = std::move(arguments);
+		function.original_arguments = std::move(original_arguments);
+		return function;
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto name = deserializer.ReadProperty<string>(500, "name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>(502, "original_arguments");
+		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
+		                                                         std::move(original_arguments));
+		auto has_serialize = deserializer.ReadProperty<bool>(503, "has_serialize");
+		return make_pair(std::move(function), has_serialize);
+	}
+
+	template <class FUNC>
+	static unique_ptr<FunctionData> FunctionDeserialize(FormatDeserializer &deserializer, FUNC &function) {
+		if (!function.format_deserialize) {
+			throw SerializationException("Function requires deserialization but no deserialization function for %s",
+			                             function.name);
+		}
+		deserializer.BeginObject(504, "function_data");
+		auto result = function.format_deserialize(deserializer, function);
+		deserializer.EndObject();
+		return result;
+	}
+
+	template <class FUNC, class CATALOG_ENTRY>
+	static pair<FUNC, unique_ptr<FunctionData>> FormatDeserialize(FormatDeserializer &deserializer,
+	                                                              CatalogType catalog_type,
+	                                                              vector<unique_ptr<Expression>> &children) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto entry = FormatDeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
+		auto &function = entry.first;
+		auto has_serialize = entry.second;
+
+		unique_ptr<FunctionData> bind_data;
+		if (has_serialize) {
+			bind_data = FunctionDeserialize<FUNC>(deserializer, function);
+		} else if (function.bind) {
+			try {
+				bind_data = function.bind(context, function, children);
+			} catch (Exception &ex) {
+				// FIXME
+				throw SerializationException("Error during bind of function in deserialization: %s", ex.what());
+			}
+		}
+		return make_pair(std::move(function), std::move(bind_data));
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/macro_function.hpp

@@ -48,6 +48,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	virtual void SerializeInternal(FieldWriter &writer) const = 0;
 

package/src/duckdb/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/compressed_materialization_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct CompressedMaterializationFunctions {
+	//! The types we compress integral types to
+	static const vector<LogicalType> IntegralTypes();
+	//! The types we compress strings to
+	static const vector<LogicalType> StringTypes();
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments);
+};
+
+//! Needed for (de)serialization without binding
+enum class CompressedMaterializationDirection : uint8_t { INVALID = 0, COMPRESS = 1, DECOMPRESS = 2 };
+
+struct CMIntegralCompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMIntegralDecompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type, const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMStringCompressFun {
+	static ScalarFunction GetFunction(const LogicalType &result_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CMStringDecompressFun {
+	static ScalarFunction GetFunction(const LogicalType &input_type);
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/list/contains_or_position.hpp

@@ -130,7 +130,7 @@ void ListContainsOrPosition(DataChunk &args, Vector &result) {
 		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result, true);
 		break;
 	default:
-		throw NotImplementedException("This function has not been implemented for physical type %s",
+		throw NotImplementedException("This function has not been implemented for logical type %s",
 		                              TypeIdToString(physical_type));
 	}
 }

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -99,6 +99,11 @@ struct ListPositionFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListResizeFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct StructExtractFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -121,6 +121,8 @@ protected:
 
 struct StrpTimeFormat : public StrTimeFormat {
 public:
+	StrpTimeFormat();
+
 	//! Type-safe parsing argument
 	struct ParseResult {
 		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
@@ -148,12 +150,18 @@ public:
 	date_t ParseDate(string_t str);
 	timestamp_t ParseTimestamp(string_t str);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static StrpTimeFormat FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	static string FormatStrpTimeError(const string &input, idx_t position);
 	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
 	int NumericSpecifierWidth(StrTimeSpecifier specifier);
 	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
 	                           idx_t collection_count);
+
+private:
+	explicit StrpTimeFormat(const string &format_string);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -83,12 +83,14 @@ struct LengthFun {
 };
 
 struct LikeFun {
+	static ScalarFunction GetLikeFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 	DUCKDB_API static bool Glob(const char *s, idx_t slen, const char *pattern, idx_t plen,
 	                            bool allow_question_mark = true);
 };
 
 struct LikeEscapeFun {
+	static ScalarFunction GetLikeEscapeFun();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -69,6 +69,11 @@ typedef void (*function_serialize_t)(FieldWriter &writer, const FunctionData *bi
 typedef unique_ptr<FunctionData> (*function_deserialize_t)(PlanDeserializationState &state, FieldReader &reader,
                                                            ScalarFunction &function);
 
+typedef void (*function_format_serialize_t)(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                            const ScalarFunction &function);
+typedef unique_ptr<FunctionData> (*function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                  ScalarFunction &function);
+
 class ScalarFunction : public BaseScalarFunction {
 public:
 	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
@@ -100,14 +105,14 @@ public:
 	function_serialize_t serialize;
 	function_deserialize_t deserialize;
 
+	function_format_serialize_t format_serialize;
+	function_format_deserialize_t format_deserialize;
+
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
 
 	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
 
-private:
-	bool CompareScalarFunctionT(const scalar_function_t &other) const;
-
 public:
 	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
 

package/src/duckdb/src/include/duckdb/function/scalar_macro_function.hpp

@@ -36,6 +36,9 @@ public:
 
 	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(FieldWriter &writer) const override;
 };

package/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp

@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/table/arrow_duck_schema.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/unique_ptr.hpp"
+
+namespace duckdb {
+//===--------------------------------------------------------------------===//
+// Arrow Variable Size Types
+//===--------------------------------------------------------------------===//
+enum class ArrowVariableSizeType : uint8_t { FIXED_SIZE = 0, NORMAL = 1, SUPER_SIZE = 2 };
+
+//===--------------------------------------------------------------------===//
+// Arrow Time/Date Types
+//===--------------------------------------------------------------------===//
+enum class ArrowDateTimeType : uint8_t {
+	MILLISECONDS = 0,
+	MICROSECONDS = 1,
+	NANOSECONDS = 2,
+	SECONDS = 3,
+	DAYS = 4,
+	MONTHS = 5,
+	MONTH_DAY_NANO = 6
+};
+
+class ArrowType {
+public:
+	//! From a DuckDB type
+	ArrowType(LogicalType type_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
+	      date_time_precision(ArrowDateTimeType::DAYS) {};
+
+	//! From a DuckDB type + fixed_size
+	ArrowType(LogicalType type_p, idx_t fixed_size_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::FIXED_SIZE),
+	      date_time_precision(ArrowDateTimeType::DAYS), fixed_size(fixed_size_p) {};
+
+	//! From a DuckDB type + variable size type
+	ArrowType(LogicalType type_p, ArrowVariableSizeType size_type_p)
+	    : type(std::move(type_p)), size_type(size_type_p), date_time_precision(ArrowDateTimeType::DAYS) {};
+
+	//! From a DuckDB type + datetime type
+	ArrowType(LogicalType type_p, ArrowDateTimeType date_time_precision_p)
+	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
+	      date_time_precision(date_time_precision_p) {};
+
+	void AddChild(unique_ptr<ArrowType> child);
+
+	void AssignChildren(vector<unique_ptr<ArrowType>> children);
+
+	const LogicalType &GetDuckType() const;
+
+	ArrowVariableSizeType GetSizeType() const;
+
+	idx_t FixedSize() const;
+
+	void SetDictionary(unique_ptr<ArrowType> dictionary);
+
+	ArrowDateTimeType GetDateTimeType() const;
+
+	const ArrowType &GetDictionary() const;
+
+	const ArrowType &operator[](idx_t index) const;
+
+private:
+	LogicalType type;
+	//! If we have a nested type, their children's type.
+	vector<unique_ptr<ArrowType>> children;
+	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
+	ArrowVariableSizeType size_type;
+	//! If this is a date/time holds its precision
+	ArrowDateTimeType date_time_precision;
+	//! Only for size types with fixed size
+	idx_t fixed_size = 0;
+	//! Hold the optional type if the array is a dictionary
+	unique_ptr<ArrowType> dictionary_type;
+};
+
+using arrow_column_map_t = unordered_map<idx_t, unique_ptr<ArrowType>>;
+
+struct ArrowTableType {
+public:
+	void AddColumn(idx_t index, unique_ptr<ArrowType> type);
+	const arrow_column_map_t &GetColumns() const;
+
+private:
+	arrow_column_map_t arrow_convert_data;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -16,25 +16,9 @@
 #include "duckdb/common/thread.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 
 namespace duckdb {
-//===--------------------------------------------------------------------===//
-// Arrow Variable Size Types
-//===--------------------------------------------------------------------===//
-enum class ArrowVariableSizeType : uint8_t { FIXED_SIZE = 0, NORMAL = 1, SUPER_SIZE = 2 };
-
-//===--------------------------------------------------------------------===//
-// Arrow Time/Date Types
-//===--------------------------------------------------------------------===//
-enum class ArrowDateTimeType : uint8_t {
-	MILLISECONDS = 0,
-	MICROSECONDS = 1,
-	NANOSECONDS = 2,
-	SECONDS = 3,
-	DAYS = 4,
-	MONTHS = 5,
-	MONTH_DAY_NANO = 6
-};
 
 struct ArrowInterval {
 	int32_t months;
@@ -46,18 +30,6 @@ struct ArrowInterval {
 	}
 };
 
-struct ArrowConvertData {
-	ArrowConvertData(LogicalType type) : dictionary_type(type) {};
-	ArrowConvertData() {};
-
-	//! Hold type of dictionary
-	LogicalType dictionary_type;
-	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
-	vector<pair<ArrowVariableSizeType, idx_t>> variable_sz_type;
-	//! If this is a date/time holds its precision
-	vector<ArrowDateTimeType> date_time_precision;
-};
-
 struct ArrowProjectedColumns {
 	unordered_map<idx_t, string> projection_map;
 	vector<string> columns;
@@ -73,11 +45,10 @@ typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(uintptr_
 typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper &schema);
 
 struct ArrowScanFunctionData : public PyTableFunctionData {
+public:
 	ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p)
 	    : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p) {
 	}
-	//! This holds the original list type (col_idx, [ArrowListType,size])
-	unordered_map<idx_t, unique_ptr<ArrowConvertData>> arrow_convert_data;
 	vector<LogicalType> all_types;
 	atomic<idx_t> lines_read;
 	ArrowSchemaWrapper schema_root;
@@ -86,6 +57,8 @@ struct ArrowScanFunctionData : public PyTableFunctionData {
 	uintptr_t stream_factory_ptr;
 	//! Pointer to the scanner factory produce
 	stream_factory_produce_t scanner_producer;
+	//! Arrow table data
+	ArrowTableType arrow_table;
 };
 
 struct ArrowScanLocalState : public LocalTableFunctionState {
@@ -132,8 +105,7 @@ public:
 	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
 	                                              vector<LogicalType> &return_types, vector<string> &names);
 	//! Actual conversion from Arrow to DuckDB
-	static void ArrowToDuckDB(ArrowScanLocalState &scan_state,
-	                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
+	static void ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data,
 	                          DataChunk &output, idx_t start, bool arrow_scan_is_projected = true);
 
 	//! Get next scan state
@@ -172,9 +144,7 @@ protected:
 	//! Renames repeated columns and case sensitive columns
 	static void RenameArrowColumns(vector<string> &names);
 	//! Helper function to get the DuckDB logical type
-	static LogicalType GetArrowLogicalType(ArrowSchema &schema,
-	                                       std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
-	                                       idx_t col_idx);
+	static unique_ptr<ArrowType> GetArrowLogicalType(ArrowSchema &schema);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -76,6 +76,10 @@ struct ColumnInfo {
 		info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 		return info;
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnInfo FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<std::string> names;
 	vector<LogicalType> types;
 };
@@ -105,6 +109,9 @@ struct ReadCSVData : public BaseCSVData {
 		this->initial_reader = std::move(reader);
 	}
 	void FinalizeRead(ClientContext &context);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ReadCSVData> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct CSVCopyFunction {

package/src/duckdb/src/include/duckdb/function/table/system_functions.hpp

@@ -37,6 +37,10 @@ struct PragmaVersion {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct PragmaPlatform {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct PragmaDatabaseSize {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -118,7 +122,7 @@ struct TestType {
 
 struct TestAllTypesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
-	static vector<TestType> GetTestTypes();
+	static vector<TestType> GetTestTypes(bool large_enum = false);
 };
 
 struct TestVectorTypesFun {

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -207,6 +207,12 @@ typedef void (*table_function_serialize_t)(FieldWriter &writer, const FunctionDa
 typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                                  TableFunction &function);
 
+typedef void (*table_function_format_serialize_t)(FormatSerializer &serializer,
+                                                  const optional_ptr<FunctionData> bind_data,
+                                                  const TableFunction &function);
+typedef unique_ptr<FunctionData> (*table_function_format_deserialize_t)(FormatDeserializer &deserializer,
+                                                                        TableFunction &function);
+
 class TableFunction : public SimpleNamedParameterFunction {
 public:
 	DUCKDB_API
@@ -265,6 +271,8 @@ public:
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;
+	table_function_format_serialize_t format_serialize;
+	table_function_format_deserialize_t format_deserialize;
 	bool verify_serialization = true;
 
 	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added

package/src/duckdb/src/include/duckdb/function/table_macro_function.hpp

@@ -36,6 +36,9 @@ public:
 
 	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<MacroFunction> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(FieldWriter &writer) const override;
 };

package/src/duckdb/src/include/duckdb/function/udf_function.hpp

@@ -318,8 +318,9 @@ private:
 		case LogicalTypeId::DATE:
 			return std::is_same<T, date_t>();
 		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIME_TZ:
 			return std::is_same<T, dtime_t>();
+		case LogicalTypeId::TIME_TZ:
+			return std::is_same<T, dtime_tz_t>();
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_NS:

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

@@ -60,7 +60,7 @@ public:
 	bool IsInitialDatabase() const;
 	void SetInitialDatabase();
 
-	static string ExtractDatabaseName(const string &dbpath);
+	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);
 
 private:
 	DatabaseInstance &db;

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

@@ -13,7 +13,7 @@
 #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 "duckdb/common/case_insensitive_map.hpp"
 
 #include <cstring>
 #include <cassert>
@@ -31,8 +31,9 @@ struct DatabaseData {
 };
 
 struct PreparedStatementWrapper {
+	//! Map of name -> values
+	case_insensitive_map_t<Value> values;
 	unique_ptr<PreparedStatement> statement;
-	vector<Value> values;
 };
 
 struct ExtractStatementsWrapper {
@@ -48,7 +49,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/chunk_scan_state/query_result.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "duckdb/main/chunk_scan_state.hpp"
+#include "duckdb/common/preserved_error.hpp"
+
+namespace duckdb {
+
+class QueryResult;
+
+class QueryResultChunkScanState : public ChunkScanState {
+public:
+	QueryResultChunkScanState(QueryResult &result);
+	~QueryResultChunkScanState();
+
+public:
+	bool LoadNextChunk(PreservedError &error) override;
+	bool HasError() const override;
+	PreservedError &GetError() override;
+	const vector<LogicalType> &Types() const override;
+	const vector<string> &Names() const override;
+
+private:
+	bool InternalLoad(PreservedError &error);
+
+private:
+	QueryResult &result;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,43 @@
+#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