duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -2,26 +2,23 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database.hpp"
 #include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/database_path_and_type.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/main/database_path_and_type.hpp"
 
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
-// Source
+// Helper
 //===--------------------------------------------------------------------===//
-SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk,
-                                         OperatorSourceInput &input) const {
-	// parse the options
-	auto &config = DBConfig::GetConfig(context.client);
-	AccessMode access_mode = config.options.access_mode;
-	string type;
-	string unrecognized_option;
+
+void ParseOptions(const unique_ptr<AttachInfo> &info, AccessMode &access_mode, string &db_type,
+                  string &unrecognized_option) {
+
 	for (auto &entry : info->options) {
+
 		if (entry.first == "readonly" || entry.first == "read_only") {
 			auto read_only = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
 			if (read_only) {
@@ -29,59 +26,80 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 			} else {
 				access_mode = AccessMode::READ_WRITE;
 			}
-		} else if (entry.first == "readwrite" || entry.first == "read_write") {
+			continue;
+		}
+
+		if (entry.first == "readwrite" || entry.first == "read_write") {
 			auto read_only = !BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
 			if (read_only) {
 				access_mode = AccessMode::READ_ONLY;
 			} else {
 				access_mode = AccessMode::READ_WRITE;
 			}
-		} else if (entry.first == "type") {
-			type = StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR));
-		} else if (unrecognized_option.empty()) {
-			unrecognized_option = entry.first;
+			continue;
 		}
-	}
-	auto &db = DatabaseInstance::GetDatabase(context.client);
-	if (type.empty()) {
-		// try to extract type from path
-		auto path_and_type = DBPathAndType::Parse(info->path, config);
-		type = path_and_type.type;
-		info->path = path_and_type.path;
-	}
 
-	if (type.empty() && !unrecognized_option.empty()) {
-		throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
-	}
+		if (entry.first == "type") {
+			// extract the database type
+			db_type = StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR));
+			continue;
+		}
 
-	// if we are loading a database type from an extension - check if that extension is loaded
-	if (!type.empty()) {
-		if (!Catalog::TryAutoLoad(context.client, type)) {
-			// FIXME: Here it might be preferrable to use an AutoLoadOrThrow kind of function
-			// so that either there will be success or a message to throw, and load will be
-			// attempted only once respecting the autoloading options
-			ExtensionHelper::LoadExternalExtension(context.client, type);
+		// we allow unrecognized options
+		if (unrecognized_option.empty()) {
+			unrecognized_option = entry.first;
 		}
 	}
+}
 
-	// attach the database
-	auto &name = info->name;
-	const auto &path = info->path;
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
+SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
+	// parse the options
+	auto &config = DBConfig::GetConfig(context.client);
+	AccessMode access_mode = config.options.access_mode;
+	string db_type;
+	string unrecognized_option;
+	ParseOptions(info, access_mode, db_type, unrecognized_option);
 
+	// get the name and path of the database
+	auto &name = info->name;
+	auto &path = info->path;
+	if (db_type.empty()) {
+		DBPathAndType::ExtractExtensionPrefix(path, db_type);
+	}
 	if (name.empty()) {
 		auto &fs = FileSystem::GetFileSystem(context.client);
 		name = AttachedDatabase::ExtractDatabaseName(path, fs);
 	}
+
+	// check ATTACH IF NOT EXISTS
 	auto &db_manager = DatabaseManager::Get(context.client);
-	auto existing_db = db_manager.GetDatabaseFromPath(context.client, path);
-	if (existing_db) {
-		throw BinderException("Database \"%s\" is already attached with alias \"%s\"", path, existing_db->GetName());
-	}
-	auto new_db = db.CreateAttachedDatabase(*info, type, access_mode);
-	new_db->Initialize();
+	if (info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		// constant-time lookup in the catalog for the db name
+		auto existing_db = db_manager.GetDatabase(context.client, name);
+		if (existing_db) {
 
-	db_manager.AddDatabase(context.client, std::move(new_db));
+			if ((existing_db->IsReadOnly() && access_mode == AccessMode::READ_WRITE) ||
+			    (!existing_db->IsReadOnly() && access_mode == AccessMode::READ_ONLY)) {
+
+				auto existing_mode = existing_db->IsReadOnly() ? AccessMode::READ_ONLY : AccessMode::READ_WRITE;
+				auto existing_mode_str = EnumUtil::ToString(existing_mode);
+				auto attached_mode = EnumUtil::ToString(access_mode);
+				throw BinderException("Database \"%s\" is already attached in %s mode, cannot re-attach in %s mode",
+				                      name, existing_mode_str, attached_mode);
+			}
+
+			return SourceResultType::FINISHED;
+		}
+	}
 
+	// get the database type and attach the database
+	db_manager.GetDatabaseType(context.client, db_type, *info, config, unrecognized_option);
+	auto attached_db = db_manager.AttachDatabase(context.client, *info, db_type, access_mode);
+	attached_db->Initialize();
 	return SourceResultType::FINISHED;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_art_index.cpp

@@ -1,16 +1,15 @@
 #include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
 
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/main/database_manager.hpp"
 #include "duckdb/storage/index.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/execution/index/art/art_key.hpp"
-#include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/leaf.hpp"
+#include "duckdb/common/exception/transaction_exception.hpp"
 
 namespace duckdb {
 
@@ -21,6 +20,7 @@ PhysicalCreateARTIndex::PhysicalCreateARTIndex(LogicalOperator &op, TableCatalog
     : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
       table(table_p.Cast<DuckTableEntry>()), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)),
       sorted(sorted) {
+
 	// convert virtual column ids to storage column ids
 	for (auto &column_id : column_ids) {
 		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
@@ -53,8 +53,8 @@ unique_ptr<GlobalSinkState> PhysicalCreateARTIndex::GetGlobalSinkState(ClientCon
 
 	// create the global index
 	auto &storage = table.GetStorage();
-	state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-	                                     info->constraint_type, storage.db);
+	state->global_index = make_uniq<ART>(info->index_name, info->constraint_type, storage_ids,
+	                                     TableIOManager::Get(storage), unbound_expressions, storage.db);
 
 	return (std::move(state));
 }
@@ -65,8 +65,8 @@ unique_ptr<LocalSinkState> PhysicalCreateARTIndex::GetLocalSinkState(ExecutionCo
 	// create the local index
 
 	auto &storage = table.GetStorage();
-	state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-	                                    info->constraint_type, storage.db);
+	state->local_index = make_uniq<ART>(info->index_name, info->constraint_type, storage_ids,
+	                                    TableIOManager::Get(storage), unbound_expressions, storage.db);
 
 	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
 	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
@@ -104,8 +104,9 @@ SinkResultType PhysicalCreateARTIndex::SinkSorted(Vector &row_identifiers, Opera
 	auto &l_index = l_state.local_index;
 
 	// create an ART from the chunk
-	auto art = make_uniq<ART>(l_index->column_ids, l_index->table_io_manager, l_index->unbound_expressions,
-	                          l_index->constraint_type, storage.db, l_index->Cast<ART>().allocators);
+	auto art =
+	    make_uniq<ART>(info->index_name, l_index->index_constraint_type, l_index->column_ids, l_index->table_io_manager,
+	                   l_index->unbound_expressions, storage.db, l_index->Cast<ART>().allocators);
 	if (!art->ConstructFromSorted(l_state.key_chunk.size(), l_state.keys, row_identifiers)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
@@ -167,6 +168,7 @@ SinkFinalizeType PhysicalCreateARTIndex::Finalize(Pipeline &pipeline, Event &eve
 	}
 
 	auto &schema = table.schema;
+	info->column_ids = storage_ids;
 	auto index_entry = schema.CreateIndex(context, *info, table).get();
 	if (!index_entry) {
 		D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
@@ -174,9 +176,9 @@ SinkFinalizeType PhysicalCreateARTIndex::Finalize(Pipeline &pipeline, Event &eve
 		return SinkFinalizeType::READY;
 	}
 	auto &index = index_entry->Cast<DuckIndexEntry>();
+	index.initial_index_size = state.global_index->GetInMemorySize();
 
-	index.index = state.global_index.get();
-	index.info = storage.info;
+	index.info = make_shared<IndexDataTableInfo>(storage.info, index.name);
 	for (auto &parsed_expr : info->parsed_expressions) {
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/execution/operator/schema/physical_create_schema.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/exception/binder_exception.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/main/settings.hpp"
 
@@ -38,6 +39,15 @@ SourceResultType PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chu
 		}
 		break;
 	}
+	case CatalogType::SECRET_ENTRY: {
+		// Note: the schema param is used to optionally pass the storage to drop from
+		D_ASSERT(info->extra_drop_info);
+		auto &extra_info = info->extra_drop_info->Cast<ExtraDropSecretInfo>();
+		SecretManager::Get(context.client)
+		    .DropSecretByName(context.client, info->name, info->if_not_found, extra_info.persist_mode,
+		                      extra_info.secret_storage);
+		break;
+	}
 	default: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 		catalog.DropEntry(context.client, *info);

package/src/duckdb/src/execution/operator/set/physical_cte.cpp

@@ -3,12 +3,9 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/executor.hpp"
 #include "duckdb/parallel/event.hpp"
 #include "duckdb/parallel/meta_pipeline.hpp"
 #include "duckdb/parallel/pipeline.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
-#include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
 
@@ -26,96 +23,59 @@ PhysicalCTE::~PhysicalCTE() {
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
-class CTEState : public GlobalSinkState {
+class CTEGlobalState : public GlobalSinkState {
 public:
-	explicit CTEState(ClientContext &context, const PhysicalCTE &op)
-	    : intermediate_table(context, op.children[1]->GetTypes()) {
+	explicit CTEGlobalState(ClientContext &context, const PhysicalCTE &op) : working_table_ref(op.working_table.get()) {
 	}
-	ColumnDataCollection intermediate_table;
-	ColumnDataScanState scan_state;
-	bool initialized = false;
-	bool finished_scan = false;
-};
+	optional_ptr<ColumnDataCollection> working_table_ref;
 
-unique_ptr<GlobalSinkState> PhysicalCTE::GetGlobalSinkState(ClientContext &context) const {
-	working_table->Reset();
-	return make_uniq<CTEState>(context, *this);
-}
+	mutex lhs_lock;
 
-SinkResultType PhysicalCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
-	auto &gstate = input.global_state.Cast<CTEState>();
-	if (!gstate.finished_scan) {
-		working_table->Append(chunk);
-	} else {
-		gstate.intermediate_table.Append(chunk);
+	void MergeIT(ColumnDataCollection &input) {
+		lock_guard<mutex> guard(lhs_lock);
+		working_table_ref->Combine(input);
 	}
-	return SinkResultType::NEED_MORE_INPUT;
-}
+};
 
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
-SourceResultType PhysicalCTE::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
-	auto &gstate = sink_state->Cast<CTEState>();
-	if (!gstate.initialized) {
-		gstate.intermediate_table.InitializeScan(gstate.scan_state);
-		gstate.finished_scan = false;
-		gstate.initialized = true;
+class CTELocalState : public LocalSinkState {
+public:
+	explicit CTELocalState(ClientContext &context, const PhysicalCTE &op)
+	    : lhs_data(context, op.working_table->Types()) {
+		lhs_data.InitializeAppend(append_state);
 	}
-	if (!gstate.finished_scan) {
-		gstate.finished_scan = true;
-		ExecuteRecursivePipelines(context);
+
+	unique_ptr<LocalSinkState> distinct_state;
+	ColumnDataCollection lhs_data;
+	ColumnDataAppendState append_state;
+
+	void Append(DataChunk &input) {
+		lhs_data.Append(input);
 	}
+};
 
-	gstate.intermediate_table.Scan(gstate.scan_state, chunk);
+unique_ptr<GlobalSinkState> PhysicalCTE::GetGlobalSinkState(ClientContext &context) const {
+	working_table->Reset();
+	return make_uniq<CTEGlobalState>(context, *this);
+}
 
-	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
+unique_ptr<LocalSinkState> PhysicalCTE::GetLocalSinkState(ExecutionContext &context) const {
+	auto state = make_uniq<CTELocalState>(context.client, *this);
+	return std::move(state);
 }
 
-void PhysicalCTE::ExecuteRecursivePipelines(ExecutionContext &context) const {
-	if (!recursive_meta_pipeline) {
-		throw InternalException("Missing meta pipeline for recursive CTE");
-	}
+SinkResultType PhysicalCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	auto &lstate = input.local_state.Cast<CTELocalState>();
+	lstate.lhs_data.Append(lstate.append_state, chunk);
 
-	// get and reset pipelines
-	vector<shared_ptr<Pipeline>> pipelines;
-	recursive_meta_pipeline->GetPipelines(pipelines, true);
-	for (auto &pipeline : pipelines) {
-		auto sink = pipeline->GetSink();
-		if (sink.get() != this) {
-			sink->sink_state.reset();
-		}
-		for (auto &op_ref : pipeline->GetOperators()) {
-			auto &op = op_ref.get();
-			op.op_state.reset();
-		}
-		pipeline->ClearSource();
-	}
+	return SinkResultType::NEED_MORE_INPUT;
+}
 
-	// get the MetaPipelines in the recursive_meta_pipeline and reschedule them
-	vector<shared_ptr<MetaPipeline>> meta_pipelines;
-	recursive_meta_pipeline->GetMetaPipelines(meta_pipelines, true, false);
-	auto &executor = recursive_meta_pipeline->GetExecutor();
-	vector<shared_ptr<Event>> events;
-	executor.ReschedulePipelines(meta_pipelines, events);
-
-	while (true) {
-		executor.WorkOnTasks();
-		if (executor.HasError()) {
-			executor.ThrowException();
-		}
-		bool finished = true;
-		for (auto &event : events) {
-			if (!event->IsFinished()) {
-				finished = false;
-				break;
-			}
-		}
-		if (finished) {
-			// all pipelines finished: done!
-			break;
-		}
-	}
+SinkCombineResultType PhysicalCTE::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+	auto &lstate = input.local_state.Cast<CTELocalState>();
+	auto &gstate = input.global_state.Cast<CTEGlobalState>();
+	gstate.MergeIT(lstate.lhs_data);
+
+	return SinkCombineResultType::FINISHED;
 }
 
 //===--------------------------------------------------------------------===//
@@ -125,27 +85,21 @@ void PhysicalCTE::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline)
 	D_ASSERT(children.size() == 2);
 	op_state.reset();
 	sink_state.reset();
-	recursive_meta_pipeline.reset();
 
 	auto &state = meta_pipeline.GetState();
-	state.SetPipelineSource(current, *this);
-
-	auto &executor = meta_pipeline.GetExecutor();
-	executor.AddMaterializedCTE(*this);
 
 	auto &child_meta_pipeline = meta_pipeline.CreateChildMetaPipeline(current, *this);
 	child_meta_pipeline.Build(*children[0]);
 
-	// the RHS is the recursive pipeline
-	recursive_meta_pipeline = make_shared<MetaPipeline>(executor, state, this);
-	if (meta_pipeline.HasRecursiveCTE()) {
-		recursive_meta_pipeline->SetRecursiveCTE();
+	for (auto &cte_scan : cte_scans) {
+		state.cte_dependencies.insert(make_pair(cte_scan, reference<Pipeline>(*child_meta_pipeline.GetBasePipeline())));
 	}
-	recursive_meta_pipeline->Build(*children[1]);
+
+	children[1]->BuildPipelines(current, meta_pipeline);
 }
 
 vector<const_reference<PhysicalOperator>> PhysicalCTE::GetSources() const {
-	return {*this};
+	return children[1]->GetSources();
 }
 
 string PhysicalCTE::ParamsToString() const {

package/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp

@@ -38,6 +38,7 @@ public:
 	unique_ptr<GroupedAggregateHashTable> ht;
 
 	bool intermediate_empty = true;
+	mutex intermediate_table_lock;
 	ColumnDataCollection intermediate_table;
 	ColumnDataScanState scan_state;
 	bool initialized = false;
@@ -63,6 +64,8 @@ idx_t PhysicalRecursiveCTE::ProbeHT(DataChunk &chunk, RecursiveCTEState &state)
 
 SinkResultType PhysicalRecursiveCTE::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 	auto &gstate = input.global_state.Cast<RecursiveCTEState>();
+
+	lock_guard<mutex> guard(gstate.intermediate_table_lock);
 	if (!union_all) {
 		idx_t match_count = ProbeHT(chunk, gstate);
 		if (match_count > 0) {

package/src/duckdb/src/execution/operator/set/physical_union.cpp

@@ -7,8 +7,9 @@
 namespace duckdb {
 
 PhysicalUnion::PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
-                             unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::UNION, std::move(types), estimated_cardinality) {
+                             unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality, bool allow_out_of_order)
+    : PhysicalOperator(PhysicalOperatorType::UNION, std::move(types), estimated_cardinality),
+      allow_out_of_order(allow_out_of_order) {
 	children.push_back(std::move(top));
 	children.push_back(std::move(bottom));
 }
@@ -24,6 +25,9 @@ void PhysicalUnion::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipelin
 	// or if the sink preserves order, but does not support batch indices to do so
 	auto sink = meta_pipeline.GetSink();
 	bool order_matters = false;
+	if (!allow_out_of_order) {
+		order_matters = true;
+	}
 	if (current.IsOrderDependent()) {
 		order_matters = true;
 	}
@@ -37,7 +41,7 @@ void PhysicalUnion::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipelin
 	}
 
 	// create a union pipeline that is identical to 'current'
-	auto union_pipeline = meta_pipeline.CreateUnionPipeline(current, order_matters);
+	auto &union_pipeline = meta_pipeline.CreateUnionPipeline(current, order_matters);
 
 	// continue with the current pipeline
 	children[0]->BuildPipelines(current, meta_pipeline);
@@ -48,7 +52,7 @@ void PhysicalUnion::BuildPipelines(Pipeline &current, MetaPipeline &meta_pipelin
 	}
 
 	// build the union pipeline
-	children[1]->BuildPipelines(*union_pipeline, meta_pipeline);
+	children[1]->BuildPipelines(union_pipeline, meta_pipeline);
 
 	// Assign proper batch index to the union pipeline
 	// This needs to happen after the pipelines have been built because unions can be nested

package/src/duckdb/src/execution/physical_operator.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 
 namespace duckdb {
 
@@ -121,7 +122,7 @@ unique_ptr<GlobalSinkState> PhysicalOperator::GetGlobalSinkState(ClientContext &
 idx_t PhysicalOperator::GetMaxThreadMemory(ClientContext &context) {
 	// Memory usage per thread should scale with max mem / num threads
 	// We take 1/4th of this, to be conservative
-	idx_t max_memory = BufferManager::GetBufferManager(context).GetMaxMemory();
+	idx_t max_memory = BufferManager::GetBufferManager(context).GetQueryMaxMemory();
 	idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
 	return (max_memory / num_threads) / 4;
 }
@@ -219,6 +220,7 @@ bool CachingPhysicalOperator::CanCacheType(const LogicalType &type) {
 	switch (type.id()) {
 	case LogicalTypeId::LIST:
 	case LogicalTypeId::MAP:
+	case LogicalTypeId::ARRAY:
 		return false;
 	case LogicalTypeId::STRUCT: {
 		auto &entries = StructType::GetChildTypes(type);