duckdb 0.7.2-dev614.0 → 0.7.2-dev717.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev614.0",
+  "version": "0.7.2-dev717.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/include/json_functions.hpp

@@ -54,6 +54,7 @@ public:
 
 struct JSONFunctionLocalState : public FunctionLocalState {
 public:
+	explicit JSONFunctionLocalState(Allocator &allocator);
 	explicit JSONFunctionLocalState(ClientContext &context);
 	static unique_ptr<FunctionLocalState> Init(ExpressionState &state, const BoundFunctionExpression &expr,
 	                                           FunctionData *bind_data);

package/src/duckdb/extension/json/json_functions.cpp

@@ -103,7 +103,10 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 	return make_unique<JSONReadManyFunctionData>(std::move(paths), std::move(lens));
 }
 
-JSONFunctionLocalState::JSONFunctionLocalState(ClientContext &context) : json_allocator(BufferAllocator::Get(context)) {
+JSONFunctionLocalState::JSONFunctionLocalState(Allocator &allocator) : json_allocator(allocator) {
+}
+JSONFunctionLocalState::JSONFunctionLocalState(ClientContext &context)
+    : JSONFunctionLocalState(BufferAllocator::Get(context)) {
 }
 
 unique_ptr<FunctionLocalState> JSONFunctionLocalState::Init(ExpressionState &state, const BoundFunctionExpression &expr,
@@ -184,8 +187,12 @@ unique_ptr<TableRef> JSONFunctions::ReadJSONReplacement(ClientContext &context,
 	return std::move(table_function);
 }
 
-static unique_ptr<FunctionLocalState> InitJSONCastLocalState(ClientContext &context) {
-	return make_unique<JSONFunctionLocalState>(context);
+static unique_ptr<FunctionLocalState> InitJSONCastLocalState(CastLocalStateParameters &parameters) {
+	if (parameters.context) {
+		return make_unique<JSONFunctionLocalState>(*parameters.context);
+	} else {
+		return make_unique<JSONFunctionLocalState>(Allocator::DefaultAllocator());
+	}
 }
 
 static bool CastVarcharToJSON(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -208,9 +215,9 @@ static bool CastVarcharToJSON(Vector &source, Vector &result, idx_t count, CastP
 			    mask.SetInvalid(idx);
 			    success = false;
 		    }
-
 		    return input;
 	    });
+	result.Reinterpret(source);
 	return success;
 }
 

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -193,14 +193,14 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 }
 
 DataTable &TableCatalogEntry::GetStorage() {
-	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 DataTable *TableCatalogEntry::GetStoragePtr() {
-	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
-	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
 } // namespace duckdb

package/src/duckdb/src/catalog/dependency_list.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 
@@ -10,4 +11,15 @@ void DependencyList::AddDependency(CatalogEntry *entry) {
 	set.insert(entry);
 }
 
+void DependencyList::VerifyDependencies(Catalog *catalog, const string &name) {
+	for (auto &dep : set) {
+		if (dep->catalog != catalog) {
+			throw DependencyException(
+			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
+			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
+			    name, dep->name, dep->catalog->GetName(), catalog->GetName());
+		}
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/string_util.cpp

@@ -191,11 +191,14 @@ vector<string> StringUtil::Split(const string &input, const string &split) {
 
 		// Push the substring [last, next) on to splits
 		string substr = input.substr(last, next - last);
-		if (substr.empty() == false) {
+		if (!substr.empty()) {
 			splits.push_back(substr);
 		}
 		last = next + split_len;
 	}
+	if (splits.empty()) {
+		splits.push_back(input);
+	}
 	return splits;
 }
 

package/src/duckdb/src/common/types/column_data_collection_segment.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 
 namespace duckdb {
 
@@ -202,12 +203,16 @@ idx_t ColumnDataCollectionSegment::ReadVector(ChunkManagementState &state, Vecto
 				throw InternalException("Column Data Collection: mismatch in struct child sizes");
 			}
 		}
-	} else if (internal_type == PhysicalType::VARCHAR &&
-	           allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
-		for (auto &swizzle_segment : vdata.swizzle_data) {
-			auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
-			allocator->UnswizzlePointers(state, result, swizzle_segment.offset, swizzle_segment.count,
-			                             string_heap_segment.block_id, string_heap_segment.offset);
+	} else if (internal_type == PhysicalType::VARCHAR) {
+		if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
+			for (auto &swizzle_segment : vdata.swizzle_data) {
+				auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
+				allocator->UnswizzlePointers(state, result, swizzle_segment.offset, swizzle_segment.count,
+				                             string_heap_segment.block_id, string_heap_segment.offset);
+			}
+		}
+		if (state.properties == ColumnDataScanProperties::DISALLOW_ZERO_COPY) {
+			VectorOperations::Copy(result, result, vdata.count, 0, 0);
 		}
 	}
 	return vcount;

package/src/duckdb/src/common/vector_operations/vector_cast.cpp

@@ -11,7 +11,8 @@ bool VectorOperations::TryCast(CastFunctionSet &set, GetCastFunctionInput &input
 	auto cast_function = set.GetCastFunction(source.GetType(), result.GetType(), input);
 	unique_ptr<FunctionLocalState> local_state;
 	if (cast_function.init_local_state) {
-		local_state = cast_function.init_local_state(*input.context);
+		CastLocalStateParameters lparameters(input.context, cast_function.cast_data);
+		local_state = cast_function.init_local_state(lparameters);
 	}
 	CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get());
 	return cast_function.function(source, result, count, parameters);

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -155,25 +155,30 @@ void GroupedAggregateHashTable::VerifyInternal() {
 	D_ASSERT(count == entries);
 }
 
-idx_t GroupedAggregateHashTable::MaxCapacity() {
-	idx_t max_pages = 0;
-	idx_t max_tuples = 0;
+idx_t GroupedAggregateHashTable::GetMaxCapacity(HtEntryType entry_type, idx_t tuple_size) {
+	idx_t max_pages;
+	idx_t max_tuples;
 
 	switch (entry_type) {
 	case HtEntryType::HT_WIDTH_32:
 		max_pages = NumericLimits<uint8_t>::Maximum();
 		max_tuples = NumericLimits<uint16_t>::Maximum();
 		break;
-	default:
-		D_ASSERT(entry_type == HtEntryType::HT_WIDTH_64);
+	case HtEntryType::HT_WIDTH_64:
 		max_pages = NumericLimits<uint32_t>::Maximum();
 		max_tuples = NumericLimits<uint16_t>::Maximum();
 		break;
+	default:
+		throw InternalException("Unsupported hash table width");
 	}
 
 	return max_pages * MinValue(max_tuples, (idx_t)Storage::BLOCK_SIZE / tuple_size);
 }
 
+idx_t GroupedAggregateHashTable::MaxCapacity() {
+	return GetMaxCapacity(entry_type, tuple_size);
+}
+
 void GroupedAggregateHashTable::Verify() {
 #ifdef DEBUG
 	switch (entry_type) {

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -11,7 +11,8 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastE
 	result->AddChild(expr.child.get());
 	result->Finalize();
 	if (expr.bound_cast.init_local_state) {
-		result->local_state = expr.bound_cast.init_local_state(root.executor->GetContext());
+		CastLocalStateParameters parameters(root.executor->GetContext(), expr.bound_cast.cast_data);
+		result->local_state = expr.bound_cast.init_local_state(parameters);
 	}
 	return std::move(result);
 }

package/src/duckdb/src/execution/index/art/art.cpp

@@ -330,8 +330,7 @@ bool ART::ConstructFromSorted(idx_t count, vector<Key> &keys, Vector &row_identi
 //===--------------------------------------------------------------------===//
 // Insert / Verification / Constraint Checking
 //===--------------------------------------------------------------------===//
-
-bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
+PreservedError ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 
 	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
 	D_ASSERT(logical_types[0] == input.data[0].GetType());
@@ -375,12 +374,13 @@ bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 
 	IncreaseAndVerifyMemorySize(old_memory_size);
 	if (failed_index != DConstants::INVALID_INDEX) {
-		return false;
+		return PreservedError(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"",
+		                                          AppendRowError(input, failed_index)));
 	}
-	return true;
+	return PreservedError();
 }
 
-bool ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
+PreservedError ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
 	DataChunk expression_result;
 	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
 

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1559,6 +1559,9 @@ TaskExecutionResult WindowMergeTask::ExecuteTask(TaskExecutionMode mode) {
 	size_t sorted = 0;
 	while (sorted < hash_groups.states.size()) {
 		// First check if there is an unfinished task for this thread
+		if (executor.HasError()) {
+			return TaskExecutionResult::TASK_ERROR;
+		}
 		if (!local_state.TaskFinished()) {
 			local_state.ExecuteTask();
 			continue;

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -49,6 +49,9 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &
 	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		if (!DistinctStatistics::TypeIsSupported(input.data[col_idx].GetType())) {
+			continue;
+		}
 		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
 	}
 

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -121,6 +121,9 @@ bool TryCastFloatingValueCommaSeparated(const string_t &value_str, const Logical
 }
 
 bool BaseCSVReader::TryCastValue(const Value &value, const LogicalType &sql_type) {
+	if (value.IsNull()) {
+		return true;
+	}
 	if (options.has_format[LogicalTypeId::DATE] && sql_type.id() == LogicalTypeId::DATE) {
 		date_t result;
 		string error_message;

package/src/duckdb/src/execution/partitionable_hashtable.cpp

@@ -62,6 +62,18 @@ PartitionableHashTable::PartitionableHashTable(ClientContext &context, Allocator
 	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
 		sel_vectors[r].Initialize();
 	}
+
+	RowLayout layout;
+	layout.Initialize(group_types, AggregateObject::CreateAggregateObjects(bindings));
+	tuple_size = layout.GetRowWidth();
+}
+
+HtEntryType PartitionableHashTable::GetHTEntrySize() {
+	// we need at least STANDARD_VECTOR_SIZE entries to fit in the hash table
+	if (GroupedAggregateHashTable::GetMaxCapacity(HtEntryType::HT_WIDTH_32, tuple_size) < STANDARD_VECTOR_SIZE) {
+		return HtEntryType::HT_WIDTH_64;
+	}
+	return HtEntryType::HT_WIDTH_32;
 }
 
 idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes,
@@ -74,7 +86,7 @@ idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &group
 			list.back()->Finalize();
 		}
 		list.push_back(make_unique<GroupedAggregateHashTable>(context, allocator, group_types, payload_types, bindings,
-		                                                      HtEntryType::HT_WIDTH_32));
+		                                                      GetHTEntrySize()));
 	}
 	return list.back()->AddChunk(groups, group_hashes, payload, filter);
 }
@@ -141,7 +153,7 @@ void PartitionableHashTable::Partition() {
 	for (auto &unpartitioned_ht : unpartitioned_hts) {
 		for (idx_t r = 0; r < partition_info.n_partitions; r++) {
 			radix_partitioned_hts[r].push_back(make_unique<GroupedAggregateHashTable>(
-			    context, allocator, group_types, payload_types, bindings, HtEntryType::HT_WIDTH_32));
+			    context, allocator, group_types, payload_types, bindings, GetHTEntrySize()));
 			partition_hts[r] = radix_partitioned_hts[r].back().get();
 		}
 		unpartitioned_ht->Partition(partition_hts, partition_info.radix_mask, partition_info.RADIX_SHIFT);

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -154,6 +154,9 @@ static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **re
 
 void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
                         PhysicalOperator *left, PhysicalOperator *right) {
+	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return;
+	}
 	// check if one of the tables has an index on column
 	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
 		// check if one of the children are table scans and if they have an index in the join attribute

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 
 namespace duckdb {
 
@@ -93,7 +94,16 @@ struct BitStringAggOperation {
 
 	template <class INPUT_TYPE>
 	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
-		return max - min + 1;
+		D_ASSERT(max >= min);
+		INPUT_TYPE result;
+		if (!TrySubtractOperator::Operation(max, min, result)) {
+			return NumericLimits<idx_t>::Maximum();
+		}
+		idx_t val(result);
+		if (val == NumericLimits<idx_t>::Maximum()) {
+			return val;
+		}
+		return val + 1;
 	}
 
 	template <class INPUT_TYPE, class STATE>
@@ -162,12 +172,15 @@ void BitStringAggOperation::Execute(BitAggState<hugeint_t> *state, hugeint_t inp
 
 template <>
 idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
-	idx_t val;
-	if (Hugeint::TryCast(max - min + 1, val)) {
-		return val;
-	} else {
-		throw OutOfRangeException("Range too large for bitstring aggregation");
+	hugeint_t result;
+	if (!TrySubtractOperator::Operation(max, min, result)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	idx_t range;
+	if (!Hugeint::TryCast(result + 1, range)) {
+		return NumericLimits<idx_t>::Maximum();
 	}
+	return range;
 }
 
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
@@ -185,8 +198,10 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 
 unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
-
 	if (arguments.size() == 3) {
+		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+			throw BinderException("bitstring_agg requires a constant min and max argument");
+		}
 		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		auto max = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
 		Function::EraseArgument(function, arguments, 2);

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -79,6 +79,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 			}
 		} else {
 			state->is_set = true;
+			state->is_null = false;
 			if (value.IsInlined()) {
 				state->value = value;
 			} else {

package/src/duckdb/src/function/aggregate/holistic/approximate_quantile.cpp

@@ -70,11 +70,14 @@ struct ApproxQuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+		if (!Value::DoubleIsFinite(val)) {
+			return;
+		}
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
+		state->h->add(val);
 		state->pos++;
 	}
 

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;