duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -3,29 +3,36 @@
 #include "duckdb/common/types/column_data_collection.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/function/aggregate/distributive_functions.hpp"
 
 namespace duckdb {
 
 struct SortedAggregateBindData : public FunctionData {
-	SortedAggregateBindData(ClientContext &context, const AggregateFunction &function_p,
-	                        vector<unique_ptr<Expression>> &children, unique_ptr<FunctionData> bind_info_p,
-	                        const BoundOrderModifier &order_bys)
-	    : buffer_manager(BufferManager::GetBufferManager(context)), function(function_p),
-	      bind_info(std::move(bind_info_p)) {
+	SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr)
+	    : buffer_manager(BufferManager::GetBufferManager(context)), function(expr.function),
+	      bind_info(std::move(expr.bind_info)) {
+		auto &children = expr.children;
 		arg_types.reserve(children.size());
 		for (const auto &child : children) {
 			arg_types.emplace_back(child->return_type);
 		}
+		auto &order_bys = *expr.order_bys;
 		sort_types.reserve(order_bys.orders.size());
 		for (auto &order : order_bys.orders) {
 			orders.emplace_back(order.Copy());
 			sort_types.emplace_back(order.expression->return_type);
 		}
+		sorted_on_args = (children.size() == order_bys.orders.size());
+		for (size_t i = 0; sorted_on_args && i < children.size(); ++i) {
+			sorted_on_args = children[i]->Equals(order_bys.orders[i].expression.get());
+		}
 	}
 
 	SortedAggregateBindData(const SortedAggregateBindData &other)
 	    : buffer_manager(other.buffer_manager), function(other.function), arg_types(other.arg_types),
-	      sort_types(other.sort_types) {
+	      sort_types(other.sort_types), sorted_on_args(other.sorted_on_args) {
 		if (other.bind_info) {
 			bind_info = other.bind_info->Copy();
 		}
@@ -68,20 +75,29 @@ struct SortedAggregateBindData : public FunctionData {
 
 	vector<BoundOrderByNode> orders;
 	vector<LogicalType> sort_types;
+	bool sorted_on_args;
 };
 
 struct SortedAggregateState {
-	static const idx_t BUFFER_CAPACITY = STANDARD_VECTOR_SIZE;
+	//! Default buffer size, optimised for small group to avoid blowing out memory.
+	static const idx_t BUFFER_CAPACITY = 16;
 
-	SortedAggregateState() : nsel(0) {
+	SortedAggregateState() : nsel(0), offset(0) {
 	}
 
 	static inline void InitializeBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
 		if (!chunk.ColumnCount() && !types.empty()) {
-			chunk.Initialize(Allocator::DefaultAllocator(), types);
+			chunk.Initialize(Allocator::DefaultAllocator(), types, BUFFER_CAPACITY);
 		}
 	}
 
+	//! Make sure the buffer is large enough for slicing
+	static inline void ResetBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
+		chunk.Reset();
+		chunk.Destroy();
+		chunk.Initialize(Allocator::DefaultAllocator(), types);
+	}
+
 	void Flush(SortedAggregateBindData &order_bind) {
 		if (ordering) {
 			return;
@@ -90,23 +106,33 @@ struct SortedAggregateState {
 		ordering = make_unique<ColumnDataCollection>(order_bind.buffer_manager, order_bind.sort_types);
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		ordering->Append(sort_buffer);
+		ResetBuffer(sort_buffer, order_bind.sort_types);
 
-		arguments = make_unique<ColumnDataCollection>(order_bind.buffer_manager, order_bind.arg_types);
-		InitializeBuffer(arg_buffer, order_bind.arg_types);
-		arguments->Append(arg_buffer);
+		if (!order_bind.sorted_on_args) {
+			arguments = make_unique<ColumnDataCollection>(order_bind.buffer_manager, order_bind.arg_types);
+			InitializeBuffer(arg_buffer, order_bind.arg_types);
+			arguments->Append(arg_buffer);
+			ResetBuffer(arg_buffer, order_bind.arg_types);
+		}
 	}
 
 	void Update(SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
-		InitializeBuffer(arg_buffer, order_bind.arg_types);
+		if (!order_bind.sorted_on_args) {
+			InitializeBuffer(arg_buffer, order_bind.arg_types);
+		}
 
-		if (sort_chunk.size() + sort_buffer.size() > BUFFER_CAPACITY) {
+		if (sort_chunk.size() + sort_buffer.size() > STANDARD_VECTOR_SIZE) {
 			Flush(order_bind);
 		}
-		if (ordering) {
+		if (arguments) {
 			ordering->Append(sort_chunk);
 			arguments->Append(arg_chunk);
+		} else if (ordering) {
+			ordering->Append(sort_chunk);
+		} else if (order_bind.sorted_on_args) {
+			sort_buffer.Append(sort_chunk, true);
 		} else {
 			sort_buffer.Append(sort_chunk, true);
 			arg_buffer.Append(arg_chunk, true);
@@ -116,12 +142,14 @@ struct SortedAggregateState {
 	void UpdateSlice(SortedAggregateBindData &order_bind, DataChunk &sort_inputs, DataChunk &arg_inputs) {
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
-		InitializeBuffer(arg_buffer, order_bind.arg_types);
+		if (!order_bind.sorted_on_args) {
+			InitializeBuffer(arg_buffer, order_bind.arg_types);
+		}
 
-		if (nsel + sort_buffer.size() > BUFFER_CAPACITY) {
+		if (nsel + sort_buffer.size() > STANDARD_VECTOR_SIZE) {
 			Flush(order_bind);
 		}
-		if (ordering) {
+		if (arguments) {
 			sort_buffer.Reset();
 			sort_buffer.Slice(sort_inputs, sel, nsel);
 			ordering->Append(sort_buffer);
@@ -129,27 +157,38 @@ struct SortedAggregateState {
 			arg_buffer.Reset();
 			arg_buffer.Slice(arg_inputs, sel, nsel);
 			arguments->Append(arg_buffer);
+		} else if (ordering) {
+			sort_buffer.Reset();
+			sort_buffer.Slice(sort_inputs, sel, nsel);
+			ordering->Append(sort_buffer);
+		} else if (order_bind.sorted_on_args) {
+			sort_buffer.Append(sort_inputs, true, &sel, nsel);
 		} else {
 			sort_buffer.Append(sort_inputs, true, &sel, nsel);
 			arg_buffer.Append(arg_inputs, true, &sel, nsel);
 		}
 
 		nsel = 0;
+		offset = 0;
 	}
 
 	void Combine(SortedAggregateBindData &order_bind, SortedAggregateState &other) {
-		if (other.ordering) {
-			// Force CDC if the other hash it
+		if (other.arguments) {
+			// Force CDC if the other has it
 			Flush(order_bind);
 			ordering->Combine(*other.ordering);
 			arguments->Combine(*other.arguments);
+		} else if (other.ordering) {
+			// Force CDC if the other has it
+			Flush(order_bind);
+			ordering->Combine(*other.ordering);
 		} else if (other.sort_buffer.size()) {
 			Update(order_bind, other.sort_buffer, other.arg_buffer);
 		}
 	}
 
-	void Finalize(LocalSortState &local_sort) {
-		if (ordering) {
+	void Finalize(SortedAggregateBindData &order_bind, LocalSortState &local_sort) {
+		if (arguments) {
 			ColumnDataScanState sort_state;
 			ordering->InitializeScan(sort_state);
 			ColumnDataScanState arg_state;
@@ -161,6 +200,15 @@ struct SortedAggregateState {
 			}
 			ordering->Reset();
 			arguments->Reset();
+		} else if (ordering) {
+			ColumnDataScanState sort_state;
+			ordering->InitializeScan(sort_state);
+			for (sort_buffer.Reset(); ordering->Scan(sort_state, sort_buffer); sort_buffer.Reset()) {
+				local_sort.SinkChunk(sort_buffer, sort_buffer);
+			}
+			ordering->Reset();
+		} else if (order_bind.sorted_on_args) {
+			local_sort.SinkChunk(sort_buffer, sort_buffer);
 		} else {
 			local_sort.SinkChunk(sort_buffer, arg_buffer);
 		}
@@ -175,6 +223,7 @@ struct SortedAggregateState {
 	// Selection for scattering
 	SelectionVector sel;
 	idx_t nsel;
+	idx_t offset;
 };
 
 struct SortedAggregateFunction {
@@ -192,11 +241,13 @@ struct SortedAggregateFunction {
 	                          DataChunk &arg_chunk, DataChunk &sort_chunk) {
 		idx_t col = 0;
 
-		arg_chunk.InitializeEmpty(order_bind->arg_types);
-		for (auto &dst : arg_chunk.data) {
-			dst.Reference(inputs[col++]);
+		if (!order_bind->sorted_on_args) {
+			arg_chunk.InitializeEmpty(order_bind->arg_types);
+			for (auto &dst : arg_chunk.data) {
+				dst.Reference(inputs[col++]);
+			}
+			arg_chunk.SetCardinality(count);
 		}
-		arg_chunk.SetCardinality(count);
 
 		sort_chunk.InitializeEmpty(order_bind->sort_types);
 		for (auto &dst : sort_chunk.data) {
@@ -233,15 +284,27 @@ struct SortedAggregateFunction {
 		UnifiedVectorFormat svdata;
 		states.ToUnifiedFormat(count, svdata);
 
-		// Build the selection vector for each state.
+		// Size the selection vector for each state.
 		auto sdata = (SortedAggregateState **)svdata.data;
 		for (idx_t i = 0; i < count; ++i) {
 			auto sidx = svdata.sel->get_index(i);
 			auto order_state = sdata[sidx];
-			if (!order_state->sel.data()) {
-				order_state->sel.Initialize();
+			order_state->nsel++;
+		}
+
+		// Build the selection vector for each state.
+		vector<sel_t> sel_data(count);
+		idx_t start = 0;
+		for (idx_t i = 0; i < count; ++i) {
+			auto sidx = svdata.sel->get_index(i);
+			auto order_state = sdata[sidx];
+			if (!order_state->offset) {
+				//	First one
+				order_state->offset = start;
+				order_state->sel.Initialize(sel_data.data() + order_state->offset);
+				start += order_state->nsel;
 			}
-			order_state->sel.set_index(order_state->nsel++, i);
+			sel_data[order_state->offset++] = sidx;
 		}
 
 		// Append nonempty slices to the arguments
@@ -276,6 +339,8 @@ struct SortedAggregateFunction {
 		auto &orders = order_bind->orders;
 		RowLayout payload_layout;
 		payload_layout.Initialize(order_bind->arg_types);
+		DataChunk chunk;
+		chunk.Initialize(Allocator::DefaultAllocator(), order_bind->arg_types);
 
 		//	 Reusable inner state
 		vector<data_t> agg_state(order_bind->function.state_size());
@@ -302,7 +367,7 @@ struct SortedAggregateFunction {
 			auto global_sort = make_unique<GlobalSortState>(buffer_manager, orders, payload_layout);
 			LocalSortState local_sort;
 			local_sort.Initialize(*global_sort, global_sort->buffer_manager);
-			state->Finalize(local_sort);
+			state->Finalize(*order_bind, local_sort);
 			global_sort->AddLocalState(local_sort);
 
 			if (!global_sort->sorted_blocks.empty()) {
@@ -314,7 +379,6 @@ struct SortedAggregateFunction {
 					global_sort->CompleteMergeRound(false);
 				}
 
-				auto &chunk = state->arg_buffer;
 				PayloadScanner scanner(*global_sort);
 				for (;;) {
 					chunk.Reset();
@@ -352,17 +416,46 @@ struct SortedAggregateFunction {
 	}
 };
 
-unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &bound_function,
-                                                             vector<unique_ptr<Expression>> &children,
-                                                             unique_ptr<FunctionData> bind_info,
-                                                             unique_ptr<BoundOrderModifier> order_bys) {
-
-	auto sorted_bind =
-	    make_unique<SortedAggregateBindData>(context, bound_function, children, std::move(bind_info), *order_bys);
+void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
+                                         const vector<unique_ptr<Expression>> &groups) {
+	if (!expr.order_bys || expr.order_bys->orders.empty() || expr.children.empty()) {
+		// not a sorted aggregate: return
+		return;
+	}
+	if (context.config.enable_optimizer) {
+		// for each ORDER BY - check if it is actually necessary
+		// expressions that are in the groups do not need to be ORDERED BY
+		// `ORDER BY` on a group has no effect, because for each aggregate, the group is unique
+		// similarly, we only need to ORDER BY each aggregate once
+		expression_set_t seen_expressions;
+		for (auto &target : groups) {
+			seen_expressions.insert(target.get());
+		}
+		vector<BoundOrderByNode> new_order_nodes;
+		for (auto &order_node : expr.order_bys->orders) {
+			if (seen_expressions.find(order_node.expression.get()) != seen_expressions.end()) {
+				// we do not need to order by this node
+				continue;
+			}
+			seen_expressions.insert(order_node.expression.get());
+			new_order_nodes.push_back(std::move(order_node));
+		}
+		if (new_order_nodes.empty()) {
+			expr.order_bys.reset();
+			return;
+		}
+		expr.order_bys->orders = std::move(new_order_nodes);
+	}
+	auto &bound_function = expr.function;
+	auto &children = expr.children;
+	auto &order_bys = *expr.order_bys;
+	auto sorted_bind = make_unique<SortedAggregateBindData>(context, expr);
 
-	// The arguments are the children plus the sort columns.
-	for (auto &order : order_bys->orders) {
-		children.emplace_back(std::move(order.expression));
+	if (!sorted_bind->sorted_on_args) {
+		// The arguments are the children plus the sort columns.
+		for (auto &order : order_bys.orders) {
+			children.emplace_back(std::move(order.expression));
+		}
 	}
 
 	vector<LogicalType> arguments;
@@ -381,9 +474,9 @@ unique_ptr<FunctionData> FunctionBinder::BindSortedAggregate(AggregateFunction &
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
 	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
 
-	bound_function = std::move(ordered_aggregate);
-
-	return std::move(sorted_bind);
+	expr.function = std::move(ordered_aggregate);
+	expr.bind_info = std::move(sorted_bind);
+	expr.order_bys.reset();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/cast/bit_cast.cpp

@@ -9,8 +9,6 @@ BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalTyp
 	case LogicalTypeId::VARCHAR:
 		// bit to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBit>);
-	case LogicalTypeId::BLOB:
-		return DefaultCasts::ReinterpretCast;
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/blob_cast.cpp

@@ -10,7 +10,6 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 		// blob to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
 	case LogicalTypeId::AGGREGATE_STATE:
-	case LogicalTypeId::BIT:
 		return DefaultCasts::ReinterpretCast;
 	default:
 		return DefaultCasts::TryVectorNullCast;

package/src/duckdb/src/function/cast/cast_function_set.cpp

@@ -6,7 +6,7 @@
 
 namespace duckdb {
 
-BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, ClientContext *context)
+BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, optional_ptr<ClientContext> context)
     : function_set(function_set), info(info), context(context) {
 }
 

package/src/duckdb/src/function/cast/enum_casts.cpp

@@ -109,17 +109,39 @@ unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &
 	return make_unique<EnumBoundCastData>(std::move(to_varchar_cast), std::move(from_varchar_cast));
 }
 
+struct EnumCastLocalState : public FunctionLocalState {
+public:
+	unique_ptr<FunctionLocalState> to_varchar_local;
+	unique_ptr<FunctionLocalState> from_varchar_local;
+};
+
+static unique_ptr<FunctionLocalState> InitEnumCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto result = make_unique<EnumCastLocalState>();
+
+	if (cast_data.from_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.from_varchar_cast.init_local_state(from_varchar_params);
+	}
+	if (cast_data.to_varchar_cast.init_local_state) {
+		CastLocalStateParameters from_varchar_params(parameters, cast_data.to_varchar_cast.cast_data);
+		result->from_varchar_local = cast_data.to_varchar_cast.init_local_state(from_varchar_params);
+	}
+	return std::move(result);
+}
+
 static bool EnumToAnyCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (EnumBoundCastData &)*parameters.cast_data;
+	auto &lstate = (EnumCastLocalState &)*parameters.local_state;
 
 	Vector varchar_cast(LogicalType::VARCHAR, count);
 
 	// cast to varchar
-	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data.get());
+	CastParameters to_varchar_params(parameters, cast_data.to_varchar_cast.cast_data, lstate.to_varchar_local);
 	cast_data.to_varchar_cast.function(source, varchar_cast, count, to_varchar_params);
 
 	// cast from varchar to the target
-	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data.get());
+	CastParameters from_varchar_params(parameters, cast_data.from_varchar_cast.cast_data, lstate.from_varchar_local);
 	cast_data.from_varchar_cast.function(varchar_cast, result, count, from_varchar_params);
 	return true;
 }
@@ -152,7 +174,7 @@ BoundCastInfo DefaultCasts::EnumCastSwitch(BindCastInput &input, const LogicalTy
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
 	default: {
-		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target));
+		return BoundCastInfo(EnumToAnyCast, BindEnumCast(input, source, target), InitEnumCastLocalState);
 	}
 	}
 }

package/src/duckdb/src/function/cast/list_casts.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -12,6 +13,15 @@ unique_ptr<BoundCastData> ListBoundCastData::BindListToListCast(BindCastInput &i
 	return make_unique<ListBoundCastData>(std::move(child_cast));
 }
 
+unique_ptr<FunctionLocalState> ListBoundCastData::InitListLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
+	if (!cast_data.child_cast_info.init_local_state) {
+		return nullptr;
+	}
+	CastLocalStateParameters child_parameters(parameters, cast_data.child_cast_info.cast_data);
+	return cast_data.child_cast_info.init_local_state(child_parameters);
+}
+
 bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
 
@@ -40,7 +50,7 @@ bool ListCast::ListToListCast(Vector &source, Vector &result, idx_t count, CastP
 	ListVector::Reserve(result, source_size);
 	auto &append_vector = ListVector::GetEntry(result);
 
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data.get());
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	if (!cast_data.child_cast_info.function(source_cc, append_vector, source_size, child_parameters)) {
 		return false;
 	}
@@ -116,10 +126,13 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP
 BoundCastInfo DefaultCasts::ListCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::LIST:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR:
-		return BoundCastInfo(ListToVarcharCast, ListBoundCastData::BindListToListCast(
-		                                            input, source, LogicalType::LIST(LogicalType::VARCHAR)));
+		return BoundCastInfo(
+		    ListToVarcharCast,
+		    ListBoundCastData::BindListToListCast(input, source, LogicalType::LIST(LogicalType::VARCHAR)),
+		    ListBoundCastData::InitListLocalState);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/map_cast.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -78,10 +79,12 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa
 BoundCastInfo DefaultCasts::MapCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::MAP:
-		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target));
+		return BoundCastInfo(ListCast::ListToListCast, ListBoundCastData::BindListToListCast(input, source, target),
+		                     ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::VARCHAR: {
 		auto varchar_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type));
+		return BoundCastInfo(MapToVarcharCast, ListBoundCastData::BindListToListCast(input, source, varchar_type),
+		                     ListBoundCastData::InitListLocalState);
 	}
 	default:
 		return TryVectorNullCast;

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -115,7 +116,9 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 	}
 }
 
+//===--------------------------------------------------------------------===//
 // string -> list casting
+//===--------------------------------------------------------------------===//
 bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                     ValidityMask &result_mask, idx_t count, CastParameters &parameters,
                                                     const SelectionVector *sel) {
@@ -163,7 +166,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, Valid
 
 	auto &result_child = ListVector::GetEntry(result);
 	auto &cast_data = (ListBoundCastData &)*parameters.cast_data;
-	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data.get());
+	CastParameters child_parameters(parameters, cast_data.child_cast_info.cast_data, parameters.local_state);
 	return cast_data.child_cast_info.function(varchar_vector, result_child, total_list_size, child_parameters) &&
 	       all_converted;
 }
@@ -177,11 +180,12 @@ static LogicalType InitVarcharStructType(const LogicalType &target) {
 	return LogicalType::STRUCT(child_types);
 }
 
+//===--------------------------------------------------------------------===//
 // string -> struct casting
+//===--------------------------------------------------------------------===//
 bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                       ValidityMask &result_mask, idx_t count,
                                                       CastParameters &parameters, const SelectionVector *sel) {
-
 	auto varchar_struct_type = InitVarcharStructType(result.GetType());
 	Vector varchar_vector(varchar_struct_type, count);
 	auto &child_vectors = StructVector::GetEntries(varchar_vector);
@@ -216,21 +220,39 @@ bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, Val
 	}
 
 	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	auto &lstate = (StructCastLocalState &)*parameters.local_state;
 	D_ASSERT(cast_data.child_cast_info.size() == result_children.size());
 
 	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
-		auto &varchar_vector = *child_vectors[child_idx];
+		auto &child_varchar_vector = *child_vectors[child_idx];
 		auto &result_child_vector = *result_children[child_idx];
 		auto &child_cast_info = cast_data.child_cast_info[child_idx];
-		CastParameters child_parameters(parameters, child_cast_info.cast_data.get());
-		if (!child_cast_info.function(varchar_vector, result_child_vector, count, child_parameters)) {
+		CastParameters child_parameters(parameters, child_cast_info.cast_data, lstate.local_states[child_idx]);
+		if (!child_cast_info.function(child_varchar_vector, result_child_vector, count, child_parameters)) {
 			all_converted = false;
 		}
 	}
 	return all_converted;
 }
 
+//===--------------------------------------------------------------------===//
 // string -> map casting
+//===--------------------------------------------------------------------===//
+unique_ptr<FunctionLocalState> InitMapCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
+	auto result = make_unique<MapCastLocalState>();
+
+	if (cast_data.key_cast.init_local_state) {
+		CastLocalStateParameters child_params(parameters, cast_data.key_cast.cast_data);
+		result->key_state = cast_data.key_cast.init_local_state(child_params);
+	}
+	if (cast_data.value_cast.init_local_state) {
+		CastLocalStateParameters child_params(parameters, cast_data.value_cast.cast_data);
+		result->value_state = cast_data.value_cast.init_local_state(child_params);
+	}
+	return std::move(result);
+}
+
 bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
                                                    ValidityMask &result_mask, idx_t count, CastParameters &parameters,
                                                    const SelectionVector *sel) {
@@ -282,12 +304,13 @@ bool VectorStringToMap::StringToNestedTypeCastLoop(string_t *source_data, Validi
 	auto &result_key_child = MapVector::GetKeys(result);
 	auto &result_val_child = MapVector::GetValues(result);
 	auto &cast_data = (MapBoundCastData &)*parameters.cast_data;
+	auto &lstate = (MapCastLocalState &)*parameters.local_state;
 
-	CastParameters key_params(parameters, cast_data.key_cast.cast_data.get());
+	CastParameters key_params(parameters, cast_data.key_cast.cast_data, lstate.key_state);
 	if (!cast_data.key_cast.function(varchar_key_vector, result_key_child, total_elements, key_params)) {
 		all_converted = false;
 	}
-	CastParameters val_params(parameters, cast_data.value_cast.cast_data.get());
+	CastParameters val_params(parameters, cast_data.value_cast.cast_data, lstate.value_state);
 	if (!cast_data.value_cast.function(varchar_val_vector, result_val_child, total_elements, val_params)) {
 		all_converted = false;
 	}
@@ -373,14 +396,17 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 		// the second argument allows for a secondary casting function to be passed in the CastParameters
 		return BoundCastInfo(
 		    &StringToNestedTypeCast<VectorStringToList>,
-		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target));
+		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target),
+		    ListBoundCastData::InitListLocalState);
 	case LogicalTypeId::STRUCT:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
-		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target));
+		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target),
+		                     StructBoundCastData::InitStructCastLocalState);
 	case LogicalTypeId::MAP:
 		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToMap>,
 		                     MapBoundCastData::BindMapToMapCast(
-		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target));
+		                         input, LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR), target),
+		                     InitMapCastLocalState);
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}