duckdb 0.7.2-dev321.0 → 0.7.2-dev3294.0

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -19,7 +19,7 @@ struct ExportAggregateBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<ExportAggregateBindData>(aggr, state_size);
+		return make_uniq<ExportAggregateBindData>(aggr, state_size);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -28,8 +28,8 @@ struct ExportAggregateBindData : public FunctionData {
 	}
 
 	static ExportAggregateBindData &GetFrom(ExpressionState &state) {
-		auto &func_expr = (BoundFunctionExpression &)state.expr;
-		return (ExportAggregateBindData &)*func_expr.bind_info;
+		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+		return func_expr.bind_info->Cast<ExportAggregateBindData>();
 	}
 };
 
@@ -50,7 +50,7 @@ struct CombineState : public FunctionLocalState {
 static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                        FunctionData *bind_data_p) {
 	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
-	return make_unique<CombineState>(bind_data.state_size);
+	return make_uniq<CombineState>(bind_data.state_size);
 }
 
 struct FinalizeState : public FunctionLocalState {
@@ -68,7 +68,7 @@ struct FinalizeState : public FunctionLocalState {
 static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                         FunctionData *bind_data_p) {
 	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
-	return make_unique<FinalizeState>(bind_data.state_size);
+	return make_uniq<FinalizeState>(bind_data.state_size);
 }
 
 static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
@@ -91,7 +91,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 		if (state_data.validity.RowIsValid(state_idx)) {
 			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
-			memcpy((void *)target_ptr, state_entry->GetDataUnsafe(), bind_data.state_size);
+			memcpy((void *)target_ptr, state_entry->GetData(), bind_data.state_size);
 		} else {
 			// create a dummy state because finalize does not understand NULLs in its input
 			// we put the NULL back in explicitly below
@@ -145,13 +145,11 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			continue;
 		}
 		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state0.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state0.GetData(), bind_data.state_size);
 			continue;
 		}
 		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] =
-			    StringVector::AddStringOrBlob(result, (const char *)state1.GetDataUnsafe(), bind_data.state_size);
+			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state1.GetData(), bind_data.state_size);
 			continue;
 		}
 
@@ -161,8 +159,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			                  state0.GetSize(), state1.GetSize());
 		}
 
-		memcpy(local_state.state_buffer0.get(), state0.GetDataUnsafe(), bind_data.state_size);
-		memcpy(local_state.state_buffer1.get(), state1.GetDataUnsafe(), bind_data.state_size);
+		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
+		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
 
 		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
@@ -199,29 +197,29 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	auto state_type = AggregateStateType::GetStateType(arg_return_type);
 
 	// now we can look up the function in the catalog again and bind it
-	auto func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, DEFAULT_SCHEMA,
-	                                                        state_type.function_name);
-	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
+	auto &func = Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY,
+	                                                         DEFAULT_SCHEMA, state_type.function_name);
+	if (func.type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
 		throw InternalException("Could not find aggregate %s", state_type.function_name);
 	}
-	auto aggr = (AggregateFunctionCatalogEntry *)func;
+	auto &aggr = func.Cast<AggregateFunctionCatalogEntry>();
 
 	string error;
 
 	FunctionBinder function_binder(context);
 	idx_t best_function =
-	    function_binder.BindFunction(aggr->name, aggr->functions, state_type.bound_argument_types, error);
+	    function_binder.BindFunction(aggr.name, aggr.functions, state_type.bound_argument_types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
 		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name, error);
 	}
-	auto bound_aggr = aggr->functions.GetFunctionByOffset(best_function);
+	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function);
 	if (bound_aggr.bind) {
 		// FIXME: this is really hacky
 		// but the aggregate state export needs a rework around how it handles more complex aggregates anyway
 		vector<unique_ptr<Expression>> args;
 		args.reserve(state_type.bound_argument_types.size());
 		for (auto &arg_type : state_type.bound_argument_types) {
-			args.push_back(make_unique<BoundConstantExpression>(Value(arg_type)));
+			args.push_back(make_uniq<BoundConstantExpression>(Value(arg_type)));
 		}
 		auto bind_info = bound_aggr.bind(context, bound_aggr, args);
 		if (bind_info) {
@@ -240,7 +238,7 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 		bound_function.return_type = arg_return_type;
 	}
 
-	return make_unique<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size());
+	return make_uniq<ExportAggregateBindData>(bound_aggr, bound_aggr.state_size());
 }
 
 static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
@@ -262,7 +260,7 @@ ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expr
 }
 
 unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
-	return make_unique<ExportAggregateFunctionBindData>(aggregate->Copy());
+	return make_uniq<ExportAggregateFunctionBindData>(aggregate->Copy());
 }
 
 bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
@@ -310,7 +308,7 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 		D_ASSERT(arg_type.id() != LogicalTypeId::INVALID);
 	}
 #endif
-	auto export_bind_data = make_unique<ExportAggregateFunctionBindData>(child_aggregate->Copy());
+	auto export_bind_data = make_uniq<ExportAggregateFunctionBindData>(child_aggregate->Copy());
 	aggregate_state_t state_type(child_aggregate->function.name, child_aggregate->function.return_type,
 	                             child_aggregate->function.arguments);
 	auto return_type = LogicalType::AGGREGATE_STATE(std::move(state_type));
@@ -325,9 +323,9 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	export_function.serialize = ExportStateAggregateSerialize;
 	export_function.deserialize = ExportStateAggregateDeserialize;
 
-	return make_unique<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
-	                                             std::move(child_aggregate->filter), std::move(export_bind_data),
-	                                             child_aggregate->aggr_type);
+	return make_uniq<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
+	                                           std::move(child_aggregate->filter), std::move(export_bind_data),
+	                                           child_aggregate->aggr_type);
 }
 
 ScalarFunction ExportAggregateFunction::GetFinalize() {
@@ -349,4 +347,9 @@ ScalarFunction ExportAggregateFunction::GetCombine() {
 	return result;
 }
 
+void ExportAggregateFunction::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ExportAggregateFunction::GetCombine());
+	set.AddFunction(ExportAggregateFunction::GetFinalize());
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -21,8 +21,8 @@ ScalarMacroFunction::ScalarMacroFunction(unique_ptr<ParsedExpression> expression
 ScalarMacroFunction::ScalarMacroFunction(void) : MacroFunction(MacroType::SCALAR_MACRO) {
 }
 
-unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
-	auto result = make_unique<ScalarMacroFunction>();
+unique_ptr<MacroFunction> ScalarMacroFunction::Copy() const {
+	auto result = make_uniq<ScalarMacroFunction>();
 	result->expression = expression->Copy();
 	CopyProperties(*result);
 
@@ -31,7 +31,7 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 
 void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
 	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = (ColumnRefExpression &)*expr;
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
 		auto &col_names = col_ref.column_names;
 		if (col_names.size() == 2 && col_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
 			col_names.erase(col_names.begin());
@@ -42,7 +42,7 @@ void RemoveQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
 	}
 }
 
-string ScalarMacroFunction::ToSQL(const string &schema, const string &name) {
+string ScalarMacroFunction::ToSQL(const string &schema, const string &name) const {
 	// In case of nested macro's we need to fix it a bit
 	auto expression_copy = expression->Copy();
 	RemoveQualificationRecursive(expression_copy);

package/src/duckdb/src/function/table/arrow.cpp

@@ -17,8 +17,9 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
     ArrowSchema &schema, std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx) {
 	auto format = string(schema.format);
 	if (arrow_convert_data.find(col_idx) == arrow_convert_data.end()) {
-		arrow_convert_data[col_idx] = make_unique<ArrowConvertData>();
+		arrow_convert_data[col_idx] = make_uniq<ArrowConvertData>();
 	}
+	auto &convert_data = *arrow_convert_data[col_idx];
 	if (format == "n") {
 		return LogicalType::SQLNULL;
 	} else if (format == "b") {
@@ -52,10 +53,10 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		}
 		return LogicalType::DECIMAL(width, scale);
 	} else if (format == "u") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		return LogicalType::VARCHAR;
 	} else if (format == "U") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
 		return LogicalType::VARCHAR;
 	} else if (format == "tsn:") {
 		return LogicalTypeId::TIMESTAMP_NS;
@@ -66,65 +67,68 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 	} else if (format == "tss:") {
 		return LogicalTypeId::TIMESTAMP_SEC;
 	} else if (format == "tdD") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
 		return LogicalType::DATE;
 	} else if (format == "tdm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
 		return LogicalType::DATE;
 	} else if (format == "tts") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
 		return LogicalType::TIME;
 	} else if (format == "ttm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
 		return LogicalType::TIME;
 	} else if (format == "ttu") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
 		return LogicalType::TIME;
 	} else if (format == "ttn") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
 		return LogicalType::TIME;
 	} else if (format == "tDs") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
 		return LogicalType::INTERVAL;
 	} else if (format == "tDm") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
 		return LogicalType::INTERVAL;
 	} else if (format == "tDu") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
 		return LogicalType::INTERVAL;
 	} else if (format == "tDn") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
 		return LogicalType::INTERVAL;
 	} else if (format == "tiD") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::DAYS);
 		return LogicalType::INTERVAL;
 	} else if (format == "tiM") {
-		arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MONTHS);
+		return LogicalType::INTERVAL;
+	} else if (format == "tin") {
+		convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MONTH_DAY_NANO);
 		return LogicalType::INTERVAL;
 	} else if (format == "+l") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
 		return LogicalType::LIST(child_type);
 	} else if (format == "+L") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
 		return LogicalType::LIST(child_type);
 	} else if (format[0] == '+' && format[1] == 'w') {
 		std::string parameters = format.substr(format.find(':') + 1);
 		idx_t fixed_size = std::stoi(parameters);
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
 		auto child_type = GetArrowLogicalType(*schema.children[0], arrow_convert_data, col_idx);
-		return LogicalType::LIST(std::move(child_type));
+		return LogicalType::LIST(child_type);
 	} else if (format == "+s") {
 		child_list_t<LogicalType> child_types;
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			auto child_type = GetArrowLogicalType(*schema.children[type_idx], arrow_convert_data, col_idx);
 			child_types.push_back({schema.children[type_idx]->name, child_type});
 		}
-		return LogicalType::STRUCT(std::move(child_types));
+		return LogicalType::STRUCT(child_types);
 
 	} else if (format == "+m") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 
 		auto &arrow_struct_type = *schema.children[0];
 		D_ASSERT(arrow_struct_type.n_children == 2);
@@ -132,26 +136,26 @@ LogicalType ArrowTableFunction::GetArrowLogicalType(
 		auto value_type = GetArrowLogicalType(*arrow_struct_type.children[1], arrow_convert_data, col_idx);
 		return LogicalType::MAP(key_type, value_type);
 	} else if (format == "z") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::NORMAL, 0);
 		return LogicalType::BLOB;
 	} else if (format == "Z") {
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::SUPER_SIZE, 0);
 		return LogicalType::BLOB;
 	} else if (format[0] == 'w') {
 		std::string parameters = format.substr(format.find(':') + 1);
 		idx_t fixed_size = std::stoi(parameters);
-		arrow_convert_data[col_idx]->variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
+		convert_data.variable_sz_type.emplace_back(ArrowVariableSizeType::FIXED_SIZE, fixed_size);
 		return LogicalType::BLOB;
 	} else if (format[0] == 't' && format[1] == 's') {
 		// Timestamp with Timezone
 		if (format[2] == 'n') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
+			convert_data.date_time_precision.emplace_back(ArrowDateTimeType::NANOSECONDS);
 		} else if (format[2] == 'u') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
+			convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MICROSECONDS);
 		} else if (format[2] == 'm') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
+			convert_data.date_time_precision.emplace_back(ArrowDateTimeType::MILLISECONDS);
 		} else if (format[2] == 's') {
-			arrow_convert_data[col_idx]->date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
+			convert_data.date_time_precision.emplace_back(ArrowDateTimeType::SECONDS);
 		} else {
 			throw NotImplementedException(" Timestamptz precision of not accepted");
 		}
@@ -192,7 +196,7 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();
 	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer();
 
-	auto res = make_unique<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
+	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
 
 	auto &data = *res;
 	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
@@ -203,7 +207,7 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 		}
 		if (schema.dictionary) {
 			res->arrow_convert_data[col_idx] =
-			    make_unique<ArrowConvertData>(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
+			    make_uniq<ArrowConvertData>(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
 			return_types.emplace_back(GetArrowLogicalType(*schema.dictionary, res->arrow_convert_data, col_idx));
 		} else {
 			return_types.emplace_back(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
@@ -266,9 +270,9 @@ bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, cons
 unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
                                                                              TableFunctionInitInput &input) {
 	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
-	auto result = make_unique<ArrowScanGlobalState>();
-	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters);
-	result->max_threads = ArrowScanMaxThreads(context, input.bind_data);
+	auto result = make_uniq<ArrowScanGlobalState>();
+	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters.get());
+	result->max_threads = ArrowScanMaxThreads(context, input.bind_data.get());
 	if (input.CanRemoveFilterColumns()) {
 		result->projection_ids = input.projection_ids;
 		for (const auto &col_idx : input.column_ids) {
@@ -282,35 +286,41 @@ unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(Cli
 	return std::move(result);
 }
 
-unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
-                                                                           TableFunctionInitInput &input,
-                                                                           GlobalTableFunctionState *global_state_p) {
-	auto &global_state = (ArrowScanGlobalState &)*global_state_p;
-	auto current_chunk = make_unique<ArrowArrayWrapper>();
-	auto result = make_unique<ArrowScanLocalState>(std::move(current_chunk));
+unique_ptr<LocalTableFunctionState>
+ArrowTableFunction::ArrowScanInitLocalInternal(ClientContext &context, TableFunctionInitInput &input,
+                                               GlobalTableFunctionState *global_state_p) {
+	auto &global_state = global_state_p->Cast<ArrowScanGlobalState>();
+	auto current_chunk = make_uniq<ArrowArrayWrapper>();
+	auto result = make_uniq<ArrowScanLocalState>(std::move(current_chunk));
 	result->column_ids = input.column_ids;
-	result->filters = input.filters;
+	result->filters = input.filters.get();
 	if (input.CanRemoveFilterColumns()) {
-		auto &asgs = (ArrowScanGlobalState &)*global_state_p;
-		result->all_columns.Initialize(context.client, asgs.scanned_types);
+		auto &asgs = global_state_p->Cast<ArrowScanGlobalState>();
+		result->all_columns.Initialize(context, asgs.scanned_types);
 	}
-	if (!ArrowScanParallelStateNext(context.client, input.bind_data, *result, global_state)) {
+	if (!ArrowScanParallelStateNext(context, input.bind_data.get(), *result, global_state)) {
 		return nullptr;
 	}
 	return std::move(result);
 }
 
+unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ExecutionContext &context,
+                                                                           TableFunctionInitInput &input,
+                                                                           GlobalTableFunctionState *global_state_p) {
+	return ArrowScanInitLocalInternal(context.client, input, global_state_p);
+}
+
 void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	if (!data_p.local_state) {
 		return;
 	}
 	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
-	auto &state = (ArrowScanLocalState &)*data_p.local_state;
-	auto &global_state = (ArrowScanGlobalState &)*data_p.global_state;
+	auto &state = data_p.local_state->Cast<ArrowScanLocalState>();
+	auto &global_state = data_p.global_state->Cast<ArrowScanGlobalState>();
 
 	//! Out of tuples in this chunk
 	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		if (!ArrowScanParallelStateNext(context, data_p.bind_data, state, global_state)) {
+		if (!ArrowScanParallelStateNext(context, data_p.bind_data.get(), state, global_state)) {
 			return;
 		}
 	}
@@ -331,13 +341,13 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 }
 
 unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContext &context, const FunctionData *data) {
-	return make_unique<NodeStatistics>();
+	return make_uniq<NodeStatistics>();
 }
 
 idx_t ArrowTableFunction::ArrowGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
                                              LocalTableFunctionState *local_state,
                                              GlobalTableFunctionState *global_state) {
-	auto &state = (ArrowScanLocalState &)*local_state;
+	auto &state = local_state->Cast<ArrowScanLocalState>();
 	return state.batch_index;
 }