duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

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

@@ -45,6 +45,22 @@ struct FunctionData {
 	DUCKDB_API virtual unique_ptr<FunctionData> Copy() const = 0;
 	DUCKDB_API virtual bool Equals(const FunctionData &other) const = 0;
 	DUCKDB_API static bool Equals(const FunctionData *left, const FunctionData *right);
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
+	// FIXME: this function should be removed in the future
+	template <class TARGET>
+	TARGET &CastNoConst() const {
+		return (TARGET &)*this;
+	}
 };
 
 struct TableFunctionData : public FunctionData {
@@ -75,6 +91,8 @@ public:
 
 	//! The name of the function
 	string name;
+	//! Additional Information to specify function from it's name
+	string extra_info;
 
 public:
 	//! Returns the formatted string name(arg1, arg2, ...)
@@ -107,7 +125,7 @@ public:
 	LogicalType varargs;
 
 public:
-	DUCKDB_API virtual string ToString();
+	DUCKDB_API virtual string ToString() const;
 
 	DUCKDB_API bool HasVarArgs() const;
 };
@@ -122,8 +140,8 @@ public:
 	named_parameter_type_map_t named_parameters;
 
 public:
-	DUCKDB_API string ToString() override;
-	DUCKDB_API bool HasNamedParameters();
+	DUCKDB_API string ToString() const override;
+	DUCKDB_API bool HasNamedParameters() const;
 };
 
 class BaseScalarFunction : public SimpleFunction {
@@ -145,7 +163,7 @@ public:
 public:
 	DUCKDB_API hash_t Hash() const;
 
-	DUCKDB_API string ToString() override;
+	DUCKDB_API string ToString() const override;
 };
 
 } // namespace duckdb

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

@@ -59,13 +59,10 @@ public:
 	DUCKDB_API unique_ptr<BoundAggregateExpression>
 	BindAggregateFunction(AggregateFunction bound_function, vector<unique_ptr<Expression>> children,
 	                      unique_ptr<Expression> filter = nullptr,
-	                      AggregateType aggr_type = AggregateType::NON_DISTINCT,
-	                      unique_ptr<BoundOrderModifier> order_bys = nullptr);
+	                      AggregateType aggr_type = AggregateType::NON_DISTINCT);
 
-	DUCKDB_API unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
-	                                                        vector<unique_ptr<Expression>> &children,
-	                                                        unique_ptr<FunctionData> bind_info,
-	                                                        unique_ptr<BoundOrderModifier> order_bys);
+	DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
+	                                           const vector<unique_ptr<Expression>> &groups);
 
 private:
 	//! Cast a set of expressions to the arguments of this function

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

@@ -34,16 +34,33 @@ public:
 	virtual ~MacroFunction() {
 	}
 
-	void CopyProperties(MacroFunction &other);
+	void CopyProperties(MacroFunction &other) const;
 
-	virtual unique_ptr<MacroFunction> Copy() = 0;
+	virtual unique_ptr<MacroFunction> Copy() const = 0;
 
 	static string ValidateArguments(MacroFunction &macro_function, const string &name,
 	                                FunctionExpression &function_expr,
 	                                vector<unique_ptr<ParsedExpression>> &positionals,
 	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 
-	virtual string ToSQL(const string &schema, const string &name);
+	virtual string ToSQL(const string &schema, const string &name) const;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast macro to type - macro type mismatch");
+		}
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

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

@@ -40,7 +40,7 @@ public:
 	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_query_t query);
 	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_function_t function);
 
-	DUCKDB_API string ToString() override;
+	DUCKDB_API string ToString() const override;
 
 public:
 	PragmaType type;

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

@@ -39,6 +39,10 @@ struct TypeOfFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ErrorFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct ConstantOrNull {
 	static ScalarFunction GetFunction(const LogicalType &return_type);
 	static unique_ptr<FunctionData> Bind(Value value);

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

@@ -0,0 +1,138 @@
+#pragma once
+
+namespace duckdb {
+
+template <class CHILD_TYPE, class RETURN_TYPE, class OP, class LIST_ACCESSOR>
+static void TemplatedContainsOrPosition(DataChunk &args, Vector &result, bool is_nested = false) {
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
+	Vector &list = LIST_ACCESSOR::GetList(args.data[0]);
+	Vector &value_vector = args.data[1];
+
+	// Create a result vector of type RETURN_TYPE
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<RETURN_TYPE>(result);
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	auto list_size = LIST_ACCESSOR::GetListSize(list);
+	auto &child_vector = LIST_ACCESSOR::GetEntry(list);
+
+	UnifiedVectorFormat child_data;
+	child_vector.ToUnifiedFormat(list_size, child_data);
+
+	UnifiedVectorFormat list_data;
+	list.ToUnifiedFormat(count, list_data);
+	auto list_entries = (list_entry_t *)list_data.data;
+
+	UnifiedVectorFormat value_data;
+	value_vector.ToUnifiedFormat(count, value_data);
+
+	// not required for a comparison of nested types
+	auto child_value = (CHILD_TYPE *)child_data.data;
+	auto values = (CHILD_TYPE *)value_data.data;
+
+	for (idx_t i = 0; i < count; i++) {
+		auto list_index = list_data.sel->get_index(i);
+		auto value_index = value_data.sel->get_index(i);
+
+		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		const auto &list_entry = list_entries[list_index];
+
+		result_entries[i] = OP::Initialize();
+		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
+
+			auto child_value_idx = child_data.sel->get_index(list_entry.offset + child_idx);
+			if (!child_data.validity.RowIsValid(child_value_idx)) {
+				continue;
+			}
+
+			if (!is_nested) {
+				if (Equals::Operation(child_value[child_value_idx], values[value_index])) {
+					result_entries[i] = OP::UpdateResultEntries(child_idx);
+					break; // Found value in list, no need to look further
+				}
+			} else {
+				// FIXME: using Value is less efficient than modifying the vector comparison code
+				// to more efficiently compare nested types
+
+				// Note: When using GetValue we don't first apply the selection vector
+				// because it is already done inside GetValue
+				auto lvalue = child_vector.GetValue(list_entry.offset + child_idx);
+				auto rvalue = value_vector.GetValue(i);
+				if (Value::NotDistinctFrom(lvalue, rvalue)) {
+					result_entries[i] = OP::UpdateResultEntries(child_idx);
+					break; // Found value in list, no need to look further
+				}
+			}
+		}
+	}
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+template <class T, class OP, class LIST_ACCESSOR>
+void ListContainsOrPosition(DataChunk &args, Vector &result) {
+	const auto physical_type = args.data[1].GetType().InternalType();
+	switch (physical_type) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::INT16:
+		TemplatedContainsOrPosition<int16_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::INT32:
+		TemplatedContainsOrPosition<int32_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::INT64:
+		TemplatedContainsOrPosition<int64_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::INT128:
+		TemplatedContainsOrPosition<hugeint_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::UINT8:
+		TemplatedContainsOrPosition<uint8_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::UINT16:
+		TemplatedContainsOrPosition<uint16_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::UINT32:
+		TemplatedContainsOrPosition<uint32_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::UINT64:
+		TemplatedContainsOrPosition<uint64_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::FLOAT:
+		TemplatedContainsOrPosition<float, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::DOUBLE:
+		TemplatedContainsOrPosition<double, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::VARCHAR:
+		TemplatedContainsOrPosition<string_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::INTERVAL:
+		TemplatedContainsOrPosition<interval_t, T, OP, LIST_ACCESSOR>(args, result);
+		break;
+	case PhysicalType::STRUCT:
+	case PhysicalType::LIST:
+		TemplatedContainsOrPosition<int8_t, T, OP, LIST_ACCESSOR>(args, result, true);
+		break;
+	default:
+		throw NotImplementedException("This function has not been implemented for physical type %s",
+		                              TypeIdToString(physical_type));
+	}
+}
+
+} // namespace duckdb

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

@@ -30,6 +30,10 @@ struct FloorFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct TruncFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct RoundFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -122,4 +126,12 @@ struct IsFiniteFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct GreatestCommonDivisorFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct LeastCommonMultipleFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

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

@@ -14,12 +14,59 @@
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/function/scalar/list/contains_or_position.hpp"
 
 namespace duckdb {
 
 enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
 enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP };
 
+struct ListArgFunctor {
+	static Vector &GetList(Vector &list) {
+		return list;
+	}
+	static idx_t GetListSize(Vector &list) {
+		return ListVector::GetListSize(list);
+	}
+	static Vector &GetEntry(Vector &list) {
+		return ListVector::GetEntry(list);
+	}
+};
+
+struct MapKeyArgFunctor {
+	// MAP is a LIST(STRUCT(K,V))
+	// meaning the MAP itself is a List, but the child vector that we're interested in (the keys)
+	// are a level deeper than the initial child vector
+
+	static Vector &GetList(Vector &map) {
+		return map;
+	}
+	static idx_t GetListSize(Vector &map) {
+		return ListVector::GetListSize(map);
+	}
+	static Vector &GetEntry(Vector &map) {
+		return MapVector::GetKeys(map);
+	}
+};
+
+struct ContainsFunctor {
+	static inline bool Initialize() {
+		return false;
+	}
+	static inline bool UpdateResultEntries(idx_t child_idx) {
+		return true;
+	}
+};
+
+struct PositionFunctor {
+	static inline int32_t Initialize() {
+		return 0;
+	}
+	static inline int32_t UpdateResultEntries(idx_t child_idx) {
+		return child_idx + 1;
+	}
+};
+
 struct VariableReturnBindData : public FunctionData {
 	LogicalType stype;
 
@@ -27,7 +74,7 @@ struct VariableReturnBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<VariableReturnBindData>(stype);
+		return make_uniq<VariableReturnBindData>(stype);
 	}
 	bool Equals(const FunctionData &other_p) const override {
 		auto &other = (const VariableReturnBindData &)other_p;
@@ -36,14 +83,14 @@ struct VariableReturnBindData : public FunctionData {
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
 		D_ASSERT(bind_data_p);
-		auto &info = (VariableReturnBindData &)*bind_data_p;
+		auto &info = bind_data_p->Cast<VariableReturnBindData>();
 		writer.WriteSerializable(info.stype);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		return make_unique<VariableReturnBindData>(std::move(stype));
+		return make_uniq<VariableReturnBindData>(std::move(stype));
 	}
 };
 

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

@@ -11,9 +11,36 @@
 #include "duckdb/function/function_set.hpp"
 #include "re2/re2.h"
 #include "duckdb/function/built_in_functions.hpp"
+#include "re2/stringpiece.h"
 
 namespace duckdb {
 
+namespace regexp_util {
+
+bool TryParseConstantPattern(ClientContext &context, Expression &expr, string &constant_string);
+void ParseRegexOptions(const string &options, duckdb_re2::RE2::Options &result, bool *global_replace = nullptr);
+void ParseRegexOptions(ClientContext &context, Expression &expr, RE2::Options &target, bool *global_replace = nullptr);
+
+inline duckdb_re2::StringPiece CreateStringPiece(const string_t &input) {
+	return duckdb_re2::StringPiece(input.GetData(), input.GetSize());
+}
+
+inline string_t Extract(const string_t &input, Vector &result, const RE2 &re, const duckdb_re2::StringPiece &rewrite) {
+	string extracted;
+	RE2::Extract(input.GetString(), re, rewrite, &extracted);
+	return StringVector::AddString(result, extracted.c_str(), extracted.size());
+}
+
+} // namespace regexp_util
+
+struct RegexpExtractAll {
+	static void Execute(DataChunk &args, ExpressionState &state, Vector &result);
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments);
+	static unique_ptr<FunctionLocalState> InitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+	                                                     FunctionData *bind_data);
+};
+
 struct RegexpBaseBindData : public FunctionData {
 	RegexpBaseBindData();
 	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
@@ -61,14 +88,67 @@ struct RegexpExtractBindData : public RegexpBaseBindData {
 	bool Equals(const FunctionData &other_p) const override;
 };
 
+struct RegexStringPieceArgs {
+	RegexStringPieceArgs() : size(0), capacity(0), group_buffer(nullptr) {
+	}
+	void Init(idx_t size) {
+		this->size = size;
+		// Allocate for one extra, for the all-encompassing match group
+		this->capacity = size + 1;
+		group_buffer = AllocateArray<duckdb_re2::StringPiece>(capacity);
+	}
+	void SetSize(idx_t size) {
+		this->size = size;
+		if (size + 1 > capacity) {
+			Clear();
+			Init(size);
+		}
+	}
+
+	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) {
+		std::swap(this->size, other.size);
+		std::swap(this->capacity, other.capacity);
+		std::swap(this->group_buffer, other.group_buffer);
+		return *this;
+	}
+
+	~RegexStringPieceArgs() {
+		Clear();
+	}
+
+private:
+	void Clear() {
+		DeleteArray<duckdb_re2::StringPiece>(group_buffer, capacity);
+		group_buffer = nullptr;
+
+		size = 0;
+		capacity = 0;
+	}
+
+public:
+	idx_t size;
+	//! The currently allocated capacity for the groups
+	idx_t capacity;
+	//! Used by ExtractAll to pre-allocate the storage for the groups
+	duckdb_re2::StringPiece *group_buffer;
+};
+
 struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpBaseBindData &info)
+	explicit RegexLocalState(RegexpBaseBindData &info, bool extract_all = false)
 	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
 	                       info.options) {
+		if (extract_all) {
+			auto group_count_p = constant_pattern.NumberOfCapturingGroups();
+			if (group_count_p != -1) {
+				group_buffer.Init(group_count_p);
+			}
+		}
 		D_ASSERT(info.constant_pattern);
 	}
 
 	RE2 constant_pattern;
+	//! Used by regexp_extract_all to pre-allocate the args
+	RegexStringPieceArgs group_buffer;
 };
 
 unique_ptr<FunctionLocalState> RegexInitLocalState(ExpressionState &state, const BoundFunctionExpression &expr,

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

@@ -127,6 +127,10 @@ public:
 
 		date_t ToDate();
 		timestamp_t ToTimestamp();
+
+		bool TryToDate(date_t &result);
+		bool TryToTimestamp(timestamp_t &result);
+
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
 	};
 

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

@@ -58,7 +58,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR Length(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		TR length = 0;
 		for (idx_t i = 0; i < input_length; i++) {
@@ -69,7 +69,7 @@ struct LengthFun {
 
 	template <class TA, class TR>
 	static inline TR GraphemeCount(TA input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = input.GetData();
 		auto input_length = input.GetSize();
 		for (idx_t i = 0; i < input_length; i++) {
 			if (input_data[i] & 0x80) {
@@ -205,6 +205,10 @@ struct LevenshteinFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DamerauLevenshteinFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct JaccardFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -213,4 +217,8 @@ struct JaroWinklerFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct HexFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 } // namespace duckdb

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

@@ -20,6 +20,17 @@ namespace duckdb {
 
 struct FunctionLocalState {
 	DUCKDB_API virtual ~FunctionLocalState();
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 class Binder;
@@ -29,13 +40,13 @@ class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
 	FunctionStatisticsInput(BoundFunctionExpression &expr_p, FunctionData *bind_data_p,
-	                        vector<unique_ptr<BaseStatistics>> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
+	                        vector<BaseStatistics> &child_stats_p, unique_ptr<Expression> *expr_ptr_p)
 	    : expr(expr_p), bind_data(bind_data_p), child_stats(child_stats_p), expr_ptr(expr_ptr_p) {
 	}
 
 	BoundFunctionExpression &expr;
 	FunctionData *bind_data;
-	vector<unique_ptr<BaseStatistics>> &child_stats;
+	vector<BaseStatistics> &child_stats;
 	unique_ptr<Expression> *expr_ptr;
 };
 

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

@@ -19,6 +19,9 @@
 namespace duckdb {
 
 class ScalarMacroFunction : public MacroFunction {
+public:
+	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
+
 public:
 	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 
@@ -27,9 +30,9 @@ public:
 	unique_ptr<ParsedExpression> expression;
 
 public:
-	unique_ptr<MacroFunction> Copy() override;
+	unique_ptr<MacroFunction> Copy() const override;
 
-	string ToSQL(const string &schema, const string &name) override;
+	string ToSQL(const string &schema, const string &name) const override;
 };
 
 } // namespace duckdb

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

@@ -32,7 +32,18 @@ enum class ArrowDateTimeType : uint8_t {
 	NANOSECONDS = 2,
 	SECONDS = 3,
 	DAYS = 4,
-	MONTHS = 5
+	MONTHS = 5,
+	MONTH_DAY_NANO = 6
+};
+
+struct ArrowInterval {
+	int32_t months;
+	int32_t days;
+	int64_t nanoseconds;
+
+	inline bool operator==(const ArrowInterval &rhs) const {
+		return this->days == rhs.days && this->months == rhs.months && this->nanoseconds == rhs.nanoseconds;
+	}
 };
 
 struct ArrowConvertData {
@@ -78,7 +89,7 @@ struct ArrowScanFunctionData : public PyTableFunctionData {
 };
 
 struct ArrowScanLocalState : public LocalTableFunctionState {
-	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(std::move(current_chunk)) {
+	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(current_chunk.release()) {
 	}
 
 	unique_ptr<ArrowArrayStreamWrapper> stream;