duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp

@@ -19,8 +19,10 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SEQUENCE;
 
 public:
-	explicit PhysicalCreateSequence(unique_ptr<CreateSequenceInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT}, estimated_cardinality),
+	explicit PhysicalCreateSequence(PhysicalPlan &physical_plan, unique_ptr<CreateSequenceInfo> info,
+	                                idx_t estimated_cardinality)
+	    : PhysicalOperator(physical_plan, PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT},
+	                       estimated_cardinality),
 	      info(std::move(info)) {
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_table.hpp

@@ -19,8 +19,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TABLE;
 
 public:
-	PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
-	                    idx_t estimated_cardinality);
+	PhysicalCreateTable(PhysicalPlan &physical_plan, LogicalOperator &op, SchemaCatalogEntry &schema,
+	                    unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality);
 
 	//! Schema to insert to
 	SchemaCatalogEntry &schema;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -19,7 +19,7 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_TYPE;
 
 public:
-	explicit PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality);
+	PhysicalCreateType(PhysicalPlan &physical_plan, unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality);
 
 	unique_ptr<CreateTypeInfo> info;
 

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp

@@ -19,8 +19,10 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_VIEW;
 
 public:
-	explicit PhysicalCreateView(unique_ptr<CreateViewInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT}, estimated_cardinality),
+	explicit PhysicalCreateView(PhysicalPlan &physical_plan, unique_ptr<CreateViewInfo> info,
+	                            idx_t estimated_cardinality)
+	    : PhysicalOperator(physical_plan, PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT},
+	                       estimated_cardinality),
 	      info(std::move(info)) {
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_detach.hpp

@@ -18,8 +18,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DETACH;
 
 public:
-	explicit PhysicalDetach(unique_ptr<DetachInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DETACH, {LogicalType::BOOLEAN}, estimated_cardinality),
+	PhysicalDetach(PhysicalPlan &physical_plan, unique_ptr<DetachInfo> info, idx_t estimated_cardinality)
+	    : PhysicalOperator(physical_plan, PhysicalOperatorType::DETACH, {LogicalType::BOOLEAN}, estimated_cardinality),
 	      info(std::move(info)) {
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp

@@ -19,8 +19,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DROP;
 
 public:
-	explicit PhysicalDrop(unique_ptr<DropInfo> info, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),
+	explicit PhysicalDrop(PhysicalPlan &physical_plan, unique_ptr<DropInfo> info, idx_t estimated_cardinality)
+	    : PhysicalOperator(physical_plan, PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),
 	      info(std::move(info)) {
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp

@@ -20,8 +20,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CTE;
 
 public:
-	PhysicalCTE(string ctename, idx_t table_index, vector<LogicalType> types, PhysicalOperator &top,
-	            PhysicalOperator &bottom, idx_t estimated_cardinality);
+	PhysicalCTE(PhysicalPlan &physical_plan, string ctename, idx_t table_index, vector<LogicalType> types,
+	            PhysicalOperator &top, PhysicalOperator &bottom, idx_t estimated_cardinality);
 	~PhysicalCTE() override;
 
 	vector<const_reference<PhysicalOperator>> cte_scans;

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp

@@ -21,8 +21,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RECURSIVE_CTE;
 
 public:
-	PhysicalRecursiveCTE(string ctename, idx_t table_index, vector<LogicalType> types, bool union_all,
-	                     PhysicalOperator &top, PhysicalOperator &bottom, idx_t estimated_cardinality);
+	PhysicalRecursiveCTE(PhysicalPlan &physical_plan, string ctename, idx_t table_index, vector<LogicalType> types,
+	                     bool union_all, PhysicalOperator &top, PhysicalOperator &bottom, idx_t estimated_cardinality);
 	~PhysicalRecursiveCTE() override;
 
 	string ctename;

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp

@@ -17,8 +17,8 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNION;
 
 public:
-	PhysicalUnion(vector<LogicalType> types, PhysicalOperator &top, PhysicalOperator &bottom,
-	              idx_t estimated_cardinality, bool allow_out_of_order);
+	PhysicalUnion(PhysicalPlan &physical_plan, vector<LogicalType> types, PhysicalOperator &top,
+	              PhysicalOperator &bottom, idx_t estimated_cardinality, bool allow_out_of_order);
 
 	bool allow_out_of_order;
 

package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp

@@ -9,60 +9,60 @@
 #pragma once
 
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/arena_linked_list.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/enums/explain_format.hpp"
 #include "duckdb/common/enums/operator_result_type.hpp"
+#include "duckdb/common/enums/order_preservation_type.hpp"
 #include "duckdb/common/enums/physical_operator_type.hpp"
-#include "duckdb/common/enums/explain_format.hpp"
+#include "duckdb/common/optional_idx.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/execution/execution_context.hpp"
+#include "duckdb/execution/partition_info.hpp"
+#include "duckdb/execution/physical_operator_states.hpp"
 #include "duckdb/execution/progress_data.hpp"
 #include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/common/optional_idx.hpp"
-#include "duckdb/execution/physical_operator_states.hpp"
-#include "duckdb/common/enums/order_preservation_type.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/execution/partition_info.hpp"
 
 namespace duckdb {
+
 class Event;
 class Executor;
 class PhysicalOperator;
 class Pipeline;
 class PipelineBuildState;
 class MetaPipeline;
+class PhysicalPlan;
 
-//! PhysicalOperator is the base class of the physical operators present in the
-//! execution plan
+//! PhysicalOperator is the base class of the physical operators present in the execution plan.
 class PhysicalOperator {
 public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
 
 public:
-	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
-	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
-	}
-
+	PhysicalOperator(PhysicalPlan &physical_plan, PhysicalOperatorType type, vector<LogicalType> types,
+	                 idx_t estimated_cardinality);
 	virtual ~PhysicalOperator() {
 	}
 
-	// Delete copy constructors.
+	//! Deleted copy constructors.
 	PhysicalOperator(const PhysicalOperator &other) = delete;
 	PhysicalOperator &operator=(const PhysicalOperator &) = delete;
 
-	//! The physical operator type
+	//! The child operators.
+	ArenaLinkedList<reference<PhysicalOperator>> children;
+	//! The physical operator type.
 	PhysicalOperatorType type;
-	//! The set of children of the operator
-	vector<reference<PhysicalOperator>> children;
-	//! The types returned by this physical operator
+	//! The return types.
 	vector<LogicalType> types;
-	//! The estimated cardinality of this physical operator
+	//! The estimated cardinality.
 	idx_t estimated_cardinality;
 
-	//! The global sink state of this operator
+	//! The global sink state.
 	unique_ptr<GlobalSinkState> sink_state;
-	//! The global state of this operator
+	//! The global operator state.
 	unique_ptr<GlobalOperatorState> op_state;
-	//! Lock for (re)setting any of the operator states
+	//! Lock for (re)setting any of the operator states.
 	mutex lock;
 
 public:
@@ -258,7 +258,8 @@ public:
 class CachingPhysicalOperator : public PhysicalOperator {
 public:
 	static constexpr const idx_t CACHE_THRESHOLD = 64;
-	CachingPhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality);
+	CachingPhysicalOperator(PhysicalPlan &physical_plan, PhysicalOperatorType type, vector<LogicalType> types,
+	                        idx_t estimated_cardinality);
 
 	bool caching_supported;
 

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -37,8 +37,7 @@ public:
 	template <class T, class... ARGS>
 	PhysicalOperator &Make(ARGS &&... args) {
 		static_assert(std::is_base_of<PhysicalOperator, T>::value, "T must be a physical operator");
-		auto mem = arena.AllocateAligned(sizeof(T));
-		auto ptr = new (mem) T(std::forward<ARGS>(args)...);
+		auto ptr = arena.Make<T>(*this, std::forward<ARGS>(args)...);
 		ops.push_back(*ptr);
 		return *ptr;
 	}
@@ -50,6 +49,10 @@ public:
 	void SetRoot(PhysicalOperator &op) {
 		root = op;
 	}
+	//! Get a reference to the arena.
+	ArenaAllocator &ArenaRef() {
+		return arena;
+	}
 
 private:
 	//! The arena allocator storing the physical operator memory.
@@ -90,6 +93,7 @@ public:
 	//! The order preservation type of the given operator decided by recursively looking at its children
 	static OrderPreservationType OrderPreservationRecursive(PhysicalOperator &op);
 
+	//! Make a physical operator in the physical plan.
 	template <class T, class... ARGS>
 	PhysicalOperator &Make(ARGS &&... args) {
 		return physical_plan->Make<T>(std::forward<ARGS>(args)...);
@@ -119,6 +123,7 @@ protected:
 	PhysicalOperator &CreatePlan(LogicalFilter &op);
 	PhysicalOperator &CreatePlan(LogicalGet &op);
 	PhysicalOperator &CreatePlan(LogicalLimit &op);
+	PhysicalOperator &CreatePlan(LogicalMergeInto &op);
 	PhysicalOperator &CreatePlan(LogicalOrder &op);
 	PhysicalOperator &CreatePlan(LogicalTopN &op);
 	PhysicalOperator &CreatePlan(LogicalPositionalJoin &op);

package/src/duckdb/src/include/duckdb/execution/radix_partitioned_hashtable.hpp

@@ -20,7 +20,8 @@ struct AggregatePartition;
 
 class RadixPartitionedHashTable {
 public:
-	RadixPartitionedHashTable(GroupingSet &grouping_set, const GroupedAggregateData &op);
+	RadixPartitionedHashTable(GroupingSet &grouping_set, const GroupedAggregateData &op,
+	                          TupleDataValidityType group_validity);
 	unique_ptr<GroupedAggregateHashTable> CreateHT(ClientContext &context, const idx_t capacity,
 	                                               const idx_t radix_bits) const;
 
@@ -32,6 +33,8 @@ public:
 	vector<LogicalType> group_types;
 	//! The GROUPING values that belong to this hash table
 	vector<Value> grouping_values;
+	//! Whether there are no NULLs in the groups
+	const TupleDataValidityType group_validity;
 
 public:
 	//! Sink Interface

package/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp

@@ -88,7 +88,6 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<BaseReservoirSampling> Deserialize(Deserializer &deserializer);
 
-	static double GetMinWeightFromTuplesSeen(idx_t rows_seen_total);
 	// static unordered_map<idx_t, double> tuples_to_min_weight_map;
 	// Blocking sample is a virtual class. It should be allowed to see the weights and
 	// of tuples in the sample. The blocking sample can then easily maintain statisitcal properties

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

@@ -28,7 +28,7 @@ struct CountStarFun {
 struct CountFun {
 	static constexpr const char *Name = "count";
 	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the number of non-null values in arg.";
+	static constexpr const char *Description = "Returns the number of non-NULL values in arg.";
 	static constexpr const char *Example = "count(A)";
 	static constexpr const char *Categories = "";
 
@@ -38,7 +38,7 @@ struct CountFun {
 struct FirstFun {
 	static constexpr const char *Name = "first";
 	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the first value (null or non-null) from arg. This function is affected by ordering.";
+	static constexpr const char *Description = "Returns the first value (NULL or non-NULL) from arg. This function is affected by ordering.";
 	static constexpr const char *Example = "first(A)";
 	static constexpr const char *Categories = "";
 
@@ -64,7 +64,7 @@ struct LastFun {
 struct AnyValueFun {
 	static constexpr const char *Name = "any_value";
 	static constexpr const char *Parameters = "arg";
-	static constexpr const char *Description = "Returns the first non-null value from arg. This function is affected by ordering.";
+	static constexpr const char *Description = "Returns the first non-NULL value from arg. This function is affected by ordering.";
 	static constexpr const char *Example = "";
 	static constexpr const char *Categories = "";
 

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

@@ -17,6 +17,7 @@
 namespace duckdb {
 
 class BufferManager;
+class InterruptState;
 
 //! A half-open range of frame boundary values _relative to the current row_
 //! This is why they are signed values.
@@ -35,19 +36,20 @@ using FrameStats = array<FrameDelta, 2>;
 //! but the row count will still be valid
 class ColumnDataCollection;
 struct WindowPartitionInput {
-	WindowPartitionInput(ClientContext &context, const ColumnDataCollection *inputs, idx_t count,
-	                     vector<column_t> &column_ids, vector<bool> &all_valid, const ValidityMask &filter_mask,
-	                     const FrameStats &stats)
+	WindowPartitionInput(ExecutionContext &context, const ColumnDataCollection *inputs, const idx_t count,
+	                     const vector<column_t> &column_ids, const vector<bool> &all_valid,
+	                     const ValidityMask &filter_mask, const FrameStats &stats, InterruptState &interrupt_state)
 	    : context(context), inputs(inputs), count(count), column_ids(column_ids), all_valid(all_valid),
-	      filter_mask(filter_mask), stats(stats) {
+	      filter_mask(filter_mask), stats(stats), interrupt_state(interrupt_state) {
 	}
-	ClientContext &context;
+	ExecutionContext &context;
 	const ColumnDataCollection *inputs;
-	idx_t count;
-	vector<column_t> column_ids;
-	vector<bool> all_valid;
+	const idx_t count;
+	const vector<column_t> column_ids;
+	const vector<bool> &all_valid;
 	const ValidityMask &filter_mask;
 	const FrameStats stats;
+	InterruptState &interrupt_state;
 };
 
 //! The type used for sizing hashed aggregate function states
@@ -166,15 +168,31 @@ public:
 	                        FunctionNullHandling::DEFAULT_NULL_HANDLING, simple_update, bind, destructor, statistics,
 	                        window, serialize, deserialize) {
 	}
+
+	// Window constructor
+	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
+	                  aggregate_initialize_t initialize, aggregate_wininit_t window_init, aggregate_window_t window,
+	                  bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
+	                  aggregate_statistics_t statistics = nullptr, aggregate_serialize_t serialize = nullptr,
+	                  aggregate_deserialize_t deserialize = nullptr)
+	    : BaseScalarFunction(name, arguments, return_type, FunctionStability::CONSISTENT,
+	                         LogicalType(LogicalTypeId::INVALID)),
+	      state_size(state_size), initialize(initialize), update(nullptr), combine(nullptr), finalize(nullptr),
+	      simple_update(nullptr), window(window), window_init(window_init), bind(bind), destructor(destructor),
+	      statistics(statistics), serialize(serialize), deserialize(deserialize),
+	      order_dependent(AggregateOrderDependent::ORDER_DEPENDENT),
+	      distinct_dependent(AggregateDistinctDependent::DISTINCT_DEPENDENT) {
+	}
+
 	//! The hashed aggregate state sizing function
 	aggregate_size_t state_size;
 	//! The hashed aggregate state initialization function
 	aggregate_initialize_t initialize;
-	//! The hashed aggregate update state function
+	//! The hashed aggregate update state function (may be null, if window is set)
 	aggregate_update_t update;
-	//! The hashed aggregate combine states function
+	//! The hashed aggregate combine states function (may be null, if window is set)
 	aggregate_combine_t combine;
-	//! The hashed aggregate finalization function
+	//! The hashed aggregate finalization function (may be null, if window is set)
 	aggregate_finalize_t finalize;
 	//! The simple aggregate update function (may be null)
 	aggregate_simple_update_t simple_update;
@@ -208,6 +226,13 @@ public:
 		return !(*this == rhs);
 	}
 
+	bool CanAggregate() const {
+		return update || combine || finalize;
+	}
+	bool CanWindow() const {
+		return window;
+	}
+
 public:
 	template <class STATE, class RESULT_TYPE, class OP>
 	static AggregateFunction NullaryAggregate(LogicalType return_type) {

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

@@ -53,6 +53,7 @@ private:
 	void RegisterTableFunctions();
 	void RegisterArrowFunctions();
 	void RegisterSnifferFunction();
+	void RegisterCopyFunctions();
 
 	void RegisterExtensionOverloads();
 

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

@@ -113,6 +113,34 @@ public:
 	unique_ptr<FunctionLocalState> value_state;
 };
 
+struct StructToMapBoundCastData : public BoundCastData {
+	StructToMapBoundCastData(BoundCastInfo key_cast, vector<BoundCastInfo> value_casts)
+	    : key_cast(std::move(key_cast)), value_casts(std::move(value_casts)) {
+	}
+
+	BoundCastInfo key_cast;
+	vector<BoundCastInfo> value_casts;
+
+	static unique_ptr<BoundCastData> BindStructToMapCast(BindCastInput &input, const LogicalType &source,
+	                                                     const LogicalType &target);
+	static unique_ptr<FunctionLocalState> InitStructToMapCastLocalState(CastLocalStateParameters &parameters);
+
+public:
+	unique_ptr<BoundCastData> Copy() const override {
+		vector<BoundCastInfo> copy_value_casts;
+		for (auto &value_cast : value_casts) {
+			copy_value_casts.push_back(value_cast.Copy());
+		}
+		return make_uniq<StructToMapBoundCastData>(key_cast.Copy(), std::move(copy_value_casts));
+	}
+};
+
+struct StructToMapCastLocalState : public FunctionLocalState {
+public:
+	unique_ptr<FunctionLocalState> key_state;
+	vector<unique_ptr<FunctionLocalState>> value_states;
+};
+
 struct UnionBoundCastData : public BoundCastData {
 	UnionBoundCastData(union_tag_t member_idx, string name, LogicalType type, int64_t cost,
 	                   BoundCastInfo member_cast_info)

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

@@ -52,7 +52,12 @@ public:
 	                                         GetCastFunctionInput &input);
 	//! Returns the implicit cast cost of casting from source -> target
 	//! -1 means an implicit cast is not possible
-	DUCKDB_API int64_t ImplicitCastCost(const LogicalType &source, const LogicalType &target);
+	DUCKDB_API int64_t ImplicitCastCost(optional_ptr<ClientContext> context, const LogicalType &source,
+	                                    const LogicalType &target);
+	DUCKDB_API static int64_t ImplicitCastCost(ClientContext &context, const LogicalType &source,
+	                                           const LogicalType &target);
+	DUCKDB_API static int64_t ImplicitCastCost(DatabaseInstance &db, const LogicalType &source,
+	                                           const LogicalType &target);
 	//! Register a new cast function from source to target
 	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
 	                                     int64_t implicit_cast_cost = -1);

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

@@ -155,6 +155,7 @@ private:
 	static BoundCastInfo StringCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo StructCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo TimeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo TimeNsCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo TimeTzCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo TimestampCastSwitch(BindCastInput &input, const LogicalType &source,
 	                                         const LogicalType &target);
@@ -167,10 +168,13 @@ private:
 	static BoundCastInfo TimestampSecCastSwitch(BindCastInput &input, const LogicalType &source,
 	                                            const LogicalType &target);
 	static BoundCastInfo UnionCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo VariantCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
-	static BoundCastInfo VarintCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo BignumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
 	                                         const LogicalType &target);
+	static BoundCastInfo ImplicitToVariantCast(BindCastInput &input, const LogicalType &source,
+	                                           const LogicalType &target);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/cast/variant/array_to_variant.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "duckdb/function/cast/variant/to_variant_fwd.hpp"
+
+namespace duckdb {
+namespace variant {
+
+template <bool WRITE_DATA, bool IGNORE_NULLS>
+bool ConvertArrayToVariant(ToVariantSourceData &source, ToVariantGlobalResultData &result, idx_t count,
+                           optional_ptr<const SelectionVector> selvec,
+                           optional_ptr<const SelectionVector> value_index_selvec, const bool is_root) {
+	auto blob_offset_data = OffsetData::GetBlob(result.offsets);
+	auto values_offset_data = OffsetData::GetValues(result.offsets);
+	auto children_offset_data = OffsetData::GetChildren(result.offsets);
+
+	auto &source_format = source.source_format;
+	auto &source_validity = source_format.validity;
+
+	auto array_type_size = ArrayType::GetSize(source.vec.GetType());
+	auto list_size = count * array_type_size;
+
+	auto &variant = result.variant;
+
+	ContainerSelectionVectors sel(list_size);
+	for (idx_t i = 0; i < count; i++) {
+		const auto index = source[i];
+		const auto result_index = selvec ? selvec->get_index(i) : i;
+
+		auto &blob_offset = blob_offset_data[result_index];
+		auto &children_list_entry = variant.children_data[result_index];
+
+		list_entry_t source_entry;
+		source_entry.offset = index * array_type_size;
+		source_entry.length = array_type_size;
+
+		if (source_validity.RowIsValid(index)) {
+			WriteVariantMetadata<WRITE_DATA>(result, result_index, values_offset_data, blob_offset, value_index_selvec,
+			                                 i, VariantLogicalType::ARRAY);
+			WriteContainerData<WRITE_DATA>(result.variant, result_index, blob_offset, source_entry.length,
+			                               children_offset_data[result_index]);
+			WriteArrayChildren<WRITE_DATA>(result.variant, children_list_entry.offset,
+			                               children_offset_data[result_index], source_entry, result_index, sel);
+		} else if (!IGNORE_NULLS) {
+			HandleVariantNull<WRITE_DATA>(result, result_index, values_offset_data, blob_offset, value_index_selvec, i,
+			                              is_root);
+		}
+	}
+
+	//! Now write the child vector of the list
+	auto &entry = ArrayVector::GetEntry(source.vec);
+	if (sel.count != list_size) {
+		Vector sliced_entry(entry.GetType(), nullptr);
+		sliced_entry.Dictionary(entry, list_size, sel.non_null_selection, sel.count);
+		ToVariantSourceData child_source_data(sliced_entry, sel.count);
+		return ConvertToVariant<WRITE_DATA, false>(child_source_data, result, sel.count, &sel.new_selection,
+		                                           &sel.children_selection, false);
+	} else {
+		//! All rows are valid, no need to slice the child
+		ToVariantSourceData child_source_data(entry, list_size, sel.non_null_selection);
+		return ConvertToVariant<WRITE_DATA, false>(child_source_data, result, sel.count, &sel.new_selection,
+		                                           &sel.children_selection, false);
+	}
+}
+
+} // namespace variant
+} // namespace duckdb