duckdb 1.3.2 → 1.3.3-dev4.0

package/src/duckdb/extension/parquet/reader/variant_column_reader.cpp

@@ -0,0 +1,161 @@
+#include "reader/variant_column_reader.hpp"
+#include "reader/variant/variant_binary_decoder.hpp"
+#include "reader/variant/variant_shredded_conversion.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Variant Column Reader
+//===--------------------------------------------------------------------===//
+VariantColumnReader::VariantColumnReader(ClientContext &context, ParquetReader &reader,
+                                         const ParquetColumnSchema &schema,
+                                         vector<unique_ptr<ColumnReader>> child_readers_p)
+    : ColumnReader(reader, schema), context(context), child_readers(std::move(child_readers_p)) {
+	D_ASSERT(Type().InternalType() == PhysicalType::VARCHAR);
+
+	if (child_readers[0]->Schema().name == "metadata" && child_readers[1]->Schema().name == "value") {
+		metadata_reader_idx = 0;
+		value_reader_idx = 1;
+	} else if (child_readers[1]->Schema().name == "metadata" && child_readers[0]->Schema().name == "value") {
+		metadata_reader_idx = 1;
+		value_reader_idx = 0;
+	} else {
+		throw InternalException("The Variant column must have 'metadata' and 'value' as the first two columns");
+	}
+}
+
+ColumnReader &VariantColumnReader::GetChildReader(idx_t child_idx) {
+	if (!child_readers[child_idx]) {
+		throw InternalException("VariantColumnReader::GetChildReader(%d) - but this child reader is not set",
+		                        child_idx);
+	}
+	return *child_readers[child_idx].get();
+}
+
+void VariantColumnReader::InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns,
+                                         TProtocol &protocol_p) {
+	for (auto &child : child_readers) {
+		if (!child) {
+			continue;
+		}
+		child->InitializeRead(row_group_idx_p, columns, protocol_p);
+	}
+}
+
+static LogicalType GetIntermediateGroupType(optional_ptr<ColumnReader> typed_value) {
+	child_list_t<LogicalType> children;
+	children.emplace_back("value", LogicalType::BLOB);
+	if (typed_value) {
+		children.emplace_back("typed_value", typed_value->Type());
+	}
+	return LogicalType::STRUCT(std::move(children));
+}
+
+idx_t VariantColumnReader::Read(uint64_t num_values, data_ptr_t define_out, data_ptr_t repeat_out, Vector &result) {
+	if (pending_skips > 0) {
+		throw InternalException("VariantColumnReader cannot have pending skips");
+	}
+	optional_ptr<ColumnReader> typed_value_reader = child_readers.size() == 3 ? child_readers[2].get() : nullptr;
+
+	// If the child reader values are all valid, "define_out" may not be initialized at all
+	// So, we just initialize them to all be valid beforehand
+	std::fill_n(define_out, num_values, MaxDefine());
+
+	optional_idx read_count;
+
+	Vector metadata_intermediate(LogicalType::BLOB, num_values);
+	Vector intermediate_group(GetIntermediateGroupType(typed_value_reader), num_values);
+	auto &group_entries = StructVector::GetEntries(intermediate_group);
+	auto &value_intermediate = *group_entries[0];
+
+	auto metadata_values =
+	    child_readers[metadata_reader_idx]->Read(num_values, define_out, repeat_out, metadata_intermediate);
+	auto value_values = child_readers[value_reader_idx]->Read(num_values, define_out, repeat_out, value_intermediate);
+
+	D_ASSERT(child_readers[metadata_reader_idx]->Schema().name == "metadata");
+	D_ASSERT(child_readers[value_reader_idx]->Schema().name == "value");
+
+	if (metadata_values != value_values) {
+		throw InvalidInputException(
+		    "The Variant column did not contain the same amount of values for 'metadata' and 'value'");
+	}
+
+	auto result_data = FlatVector::GetData<string_t>(result);
+	auto &result_validity = FlatVector::Validity(result);
+
+	vector<VariantValue> conversion_result;
+	if (typed_value_reader) {
+		auto typed_values = typed_value_reader->Read(num_values, define_out, repeat_out, *group_entries[1]);
+		if (typed_values != value_values) {
+			throw InvalidInputException(
+			    "The shredded Variant column did not contain the same amount of values for 'typed_value' and 'value'");
+		}
+	}
+	conversion_result =
+	    VariantShreddedConversion::Convert(metadata_intermediate, intermediate_group, 0, num_values, num_values);
+
+	for (idx_t i = 0; i < conversion_result.size(); i++) {
+		auto &variant = conversion_result[i];
+		if (variant.IsNull()) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		//! Write the result to a string
+		VariantDecodeResult decode_result;
+		decode_result.doc = yyjson_mut_doc_new(nullptr);
+		auto json_val = variant.ToJSON(context, decode_result.doc);
+
+		size_t len;
+		decode_result.data =
+		    yyjson_mut_val_write_opts(json_val, YYJSON_WRITE_ALLOW_INF_AND_NAN, nullptr, &len, nullptr);
+		if (!decode_result.data) {
+			throw InvalidInputException("Could not serialize the JSON to string, yyjson failed");
+		}
+		result_data[i] = StringVector::AddString(result, decode_result.data, static_cast<idx_t>(len));
+	}
+
+	read_count = value_values;
+	return read_count.GetIndex();
+}
+
+void VariantColumnReader::Skip(idx_t num_values) {
+	for (auto &child : child_readers) {
+		if (!child) {
+			continue;
+		}
+		child->Skip(num_values);
+	}
+}
+
+void VariantColumnReader::RegisterPrefetch(ThriftFileTransport &transport, bool allow_merge) {
+	for (auto &child : child_readers) {
+		if (!child) {
+			continue;
+		}
+		child->RegisterPrefetch(transport, allow_merge);
+	}
+}
+
+uint64_t VariantColumnReader::TotalCompressedSize() {
+	uint64_t size = 0;
+	for (auto &child : child_readers) {
+		if (!child) {
+			continue;
+		}
+		size += child->TotalCompressedSize();
+	}
+	return size;
+}
+
+idx_t VariantColumnReader::GroupRowsAvailable() {
+	for (auto &child : child_readers) {
+		if (!child) {
+			continue;
+		}
+		return child->GroupRowsAvailable();
+	}
+	throw InternalException("No projected columns in struct?");
+}
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/writer/array_column_writer.cpp

@@ -9,7 +9,8 @@ void ArrayColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *p
 	child_writer->Analyze(*state.child_state, &state_p, array_child, array_size * count);
 }
 
-void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
+void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count,
+                                bool vector_can_span_multiple_pages) {
 	auto &state = state_p.Cast<ListColumnWriterState>();
 
 	auto array_size = ArrayType::GetSize(vector.GetType());
@@ -66,7 +67,9 @@ void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *p
 	state.parent_index += vcount;
 
 	auto &array_child = ArrayVector::GetEntry(vector);
-	child_writer->Prepare(*state.child_state, &state_p, array_child, count * array_size);
+	// The elements of a single array should not span multiple Parquet pages
+	// So, we force the entire vector to fit on a single page by setting "vector_can_span_multiple_pages=false"
+	child_writer->Prepare(*state.child_state, &state_p, array_child, count * array_size, false);
 }
 
 void ArrayColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {

package/src/duckdb/extension/parquet/writer/enum_column_writer.cpp

@@ -98,7 +98,7 @@ void EnumColumnWriter::FlushDictionary(PrimitiveColumnWriterState &state, Column
 	auto enum_count = EnumType::GetSize(Type());
 	auto string_values = FlatVector::GetData<string_t>(enum_values);
 	// first write the contents of the dictionary page to a temporary buffer
-	auto temp_writer = make_uniq<MemoryStream>(Allocator::Get(writer.GetContext()));
+	auto temp_writer = make_uniq<MemoryStream>(BufferAllocator::Get(writer.GetContext()));
 	for (idx_t r = 0; r < enum_count; r++) {
 		D_ASSERT(!FlatVector::IsNull(enum_values, r));
 		// update the statistics

package/src/duckdb/extension/parquet/writer/list_column_writer.cpp

@@ -23,7 +23,7 @@ void ListColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
 	child_writer->FinalizeAnalyze(*state.child_state);
 }
 
-idx_t GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count) {
+static idx_t GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t count) {
 	// returns a consecutive child list that fully flattens and repeats all required elements
 	auto &validity = FlatVector::Validity(list);
 	auto list_entries = FlatVector::GetData<list_entry_t>(list);
@@ -57,7 +57,8 @@ idx_t GetConsecutiveChildList(Vector &list, Vector &result, idx_t offset, idx_t
 	return total_length;
 }
 
-void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
+void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count,
+                               bool vector_can_span_multiple_pages) {
 	auto &state = state_p.Cast<ListColumnWriterState>();
 
 	auto list_data = FlatVector::GetData<list_entry_t>(vector);
@@ -111,7 +112,9 @@ void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *pa
 	auto &list_child = ListVector::GetEntry(vector);
 	Vector child_list(list_child);
 	auto child_length = GetConsecutiveChildList(vector, child_list, 0, count);
-	child_writer->Prepare(*state.child_state, &state_p, child_list, child_length);
+	// The elements of a single list should not span multiple Parquet pages
+	// So, we force the entire vector to fit on a single page by setting "vector_can_span_multiple_pages=false"
+	child_writer->Prepare(*state.child_state, &state_p, child_list, child_length, false);
 }
 
 void ListColumnWriter::BeginWrite(ColumnWriterState &state_p) {

package/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp

@@ -36,8 +36,8 @@ unique_ptr<ColumnWriterPageState> PrimitiveColumnWriter::InitializePageState(Pri
 void PrimitiveColumnWriter::FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state) {
 }
 
-void PrimitiveColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector,
-                                    idx_t count) {
+void PrimitiveColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count,
+                                    bool vector_can_span_multiple_pages) {
 	auto &state = state_p.Cast<PrimitiveColumnWriterState>();
 	auto &col_chunk = state.row_group.columns[state.col_idx];
 
@@ -70,6 +70,10 @@ void PrimitiveColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterStat
 			if (validity.RowIsValid(vector_index)) {
 				page_info.estimated_page_size += GetRowSize(vector, vector_index, state);
 				if (page_info.estimated_page_size >= MAX_UNCOMPRESSED_PAGE_SIZE) {
+					if (!vector_can_span_multiple_pages && i != 0) {
+						// Vector is not allowed to span multiple pages, and we already started writing it
+						continue;
+					}
 					PageInformation new_info;
 					new_info.offset = page_info.offset + page_info.row_count;
 					state.page_info.push_back(new_info);
@@ -113,7 +117,7 @@ void PrimitiveColumnWriter::BeginWrite(ColumnWriterState &state_p) {
 		hdr.data_page_header.repetition_level_encoding = Encoding::RLE;
 
 		write_info.temp_writer = make_uniq<MemoryStream>(
-		    Allocator::Get(writer.GetContext()),
+		    BufferAllocator::Get(writer.GetContext()),
 		    MaxValue<idx_t>(NextPowerOfTwo(page_info.estimated_page_size), MemoryStream::DEFAULT_INITIAL_CAPACITY));
 		write_info.write_count = page_info.empty_count;
 		write_info.max_write_count = page_info.row_count;
@@ -129,8 +133,9 @@ void PrimitiveColumnWriter::BeginWrite(ColumnWriterState &state_p) {
 	NextPage(state);
 }
 
-void PrimitiveColumnWriter::WriteLevels(WriteStream &temp_writer, const unsafe_vector<uint16_t> &levels,
-                                        idx_t max_value, idx_t offset, idx_t count, optional_idx null_count) {
+void PrimitiveColumnWriter::WriteLevels(Allocator &allocator, WriteStream &temp_writer,
+                                        const unsafe_vector<uint16_t> &levels, idx_t max_value, idx_t offset,
+                                        idx_t count, optional_idx null_count) {
 	if (levels.empty() || count == 0) {
 		return;
 	}
@@ -140,7 +145,7 @@ void PrimitiveColumnWriter::WriteLevels(WriteStream &temp_writer, const unsafe_v
 	RleBpEncoder rle_encoder(bit_width);
 
 	// have to write to an intermediate stream first because we need to know the size
-	MemoryStream intermediate_stream(Allocator::DefaultAllocator());
+	MemoryStream intermediate_stream(allocator);
 
 	rle_encoder.BeginWrite();
 	if (null_count.IsValid() && null_count.GetIndex() == 0) {
@@ -175,10 +180,11 @@ void PrimitiveColumnWriter::NextPage(PrimitiveColumnWriterState &state) {
 	auto &temp_writer = *write_info.temp_writer;
 
 	// write the repetition levels
-	WriteLevels(temp_writer, state.repetition_levels, MaxRepeat(), page_info.offset, page_info.row_count);
+	auto &allocator = BufferAllocator::Get(writer.GetContext());
+	WriteLevels(allocator, temp_writer, state.repetition_levels, MaxRepeat(), page_info.offset, page_info.row_count);
 
 	// write the definition levels
-	WriteLevels(temp_writer, state.definition_levels, MaxDefine(), page_info.offset, page_info.row_count,
+	WriteLevels(allocator, temp_writer, state.definition_levels, MaxDefine(), page_info.offset, page_info.row_count,
 	            state.null_count + state.parent_null_count);
 }
 
@@ -296,6 +302,16 @@ void PrimitiveColumnWriter::SetParquetStatistics(PrimitiveColumnWriterState &sta
 		column_chunk.meta_data.statistics.__isset.distinct_count = true;
 		column_chunk.meta_data.__isset.statistics = true;
 	}
+
+	if (state.stats_state->HasGeoStats()) {
+		column_chunk.meta_data.__isset.geospatial_statistics = true;
+		state.stats_state->WriteGeoStats(column_chunk.meta_data.geospatial_statistics);
+
+		// Add the geospatial statistics to the extra GeoParquet metadata
+		writer.GetGeoParquetData().AddGeoParquetStats(column_schema.name, column_schema.type,
+		                                              *state.stats_state->GetGeoStats());
+	}
+
 	for (const auto &write_info : state.write_info) {
 		// only care about data page encodings, data_page_header.encoding is meaningless for dict
 		if (write_info.page_header.type != PageType::DATA_PAGE &&

package/src/duckdb/extension/parquet/writer/struct_column_writer.cpp

@@ -55,7 +55,8 @@ void StructColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
 	}
 }
 
-void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
+void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count,
+                                 bool vector_can_span_multiple_pages) {
 	auto &state = state_p.Cast<StructColumnWriterState>();
 
 	auto &validity = FlatVector::Validity(vector);
@@ -69,7 +70,8 @@ void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *
 	HandleDefineLevels(state_p, parent, validity, count, PARQUET_DEFINE_VALID, MaxDefine() - 1);
 	auto &child_vectors = StructVector::GetEntries(vector);
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
-		child_writers[child_idx]->Prepare(*state.child_states[child_idx], &state_p, *child_vectors[child_idx], count);
+		child_writers[child_idx]->Prepare(*state.child_states[child_idx], &state_p, *child_vectors[child_idx], count,
+		                                  vector_can_span_multiple_pages);
 	}
 }
 

package/src/duckdb/extension/parquet/zstd_file_system.cpp

@@ -13,7 +13,7 @@ struct ZstdStreamWrapper : public StreamWrapper {
 	bool writing = false;
 
 public:
-	void Initialize(CompressedFile &file, bool write) override;
+	void Initialize(QueryContext context, CompressedFile &file, bool write) override;
 	bool Read(StreamData &stream_data) override;
 	void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer, int64_t nr_bytes) override;
 
@@ -32,7 +32,7 @@ ZstdStreamWrapper::~ZstdStreamWrapper() {
 	}
 }
 
-void ZstdStreamWrapper::Initialize(CompressedFile &file, bool write) {
+void ZstdStreamWrapper::Initialize(QueryContext context, CompressedFile &file, bool write) {
 	Close();
 	this->file = &file;
 	this->writing = write;
@@ -156,9 +156,9 @@ void ZstdStreamWrapper::Close() {
 
 class ZStdFile : public CompressedFile {
 public:
-	ZStdFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
+	ZStdFile(QueryContext context, unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
 	    : CompressedFile(zstd_fs, std::move(child_handle_p), path) {
-		Initialize(write);
+		Initialize(context, write);
 	}
 
 	FileCompressionType GetFileCompressionType() override {
@@ -168,9 +168,10 @@ public:
 	ZStdFileSystem zstd_fs;
 };
 
-unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
+unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(QueryContext context, unique_ptr<FileHandle> handle,
+                                                          bool write) {
 	auto path = handle->path;
-	return make_uniq<ZStdFile>(std::move(handle), path, write);
+	return make_uniq<ZStdFile>(context, std::move(handle), path, write);
 }
 
 unique_ptr<StreamWrapper> ZStdFileSystem::CreateStream() {

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

@@ -39,6 +39,7 @@
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/catalog/similar_catalog_entry.hpp"
 #include "duckdb/storage/database_size.hpp"
+#include "duckdb/main/settings.hpp"
 #include <algorithm>
 
 namespace duckdb {
@@ -534,19 +535,20 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n
 	return false;
 }
 
-void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name) {
+String Catalog::AutoloadExtensionByConfigName(ClientContext &context, const String &configuration_name) {
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 	auto &dbconfig = DBConfig::GetConfig(context);
 	if (dbconfig.options.autoload_known_extensions) {
-		auto extension_name = ExtensionHelper::FindExtensionInEntries(configuration_name, EXTENSION_SETTINGS);
+		auto extension_name =
+		    ExtensionHelper::FindExtensionInEntries(configuration_name.ToStdString(), EXTENSION_SETTINGS);
 		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
 			ExtensionHelper::AutoLoadExtension(context, extension_name);
-			return;
+			return extension_name;
 		}
 	}
 #endif
 
-	throw Catalog::UnrecognizedConfigurationError(context, configuration_name);
+	throw Catalog::UnrecognizedConfigurationError(context, configuration_name.ToStdString());
 }
 
 static bool IsAutoloadableFunction(CatalogType type) {
@@ -649,19 +651,17 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
                                                       const reference_set_t<SchemaCatalogEntry> &schemas) {
 	auto &context = retriever.GetContext();
 	auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas);
-
-	auto &config = DBConfig::GetConfig(context);
-	auto max_schema_count = config.GetSetting<CatalogErrorMaxSchemasSetting>(context);
+	auto max_schema_count = DBConfig::GetSetting<CatalogErrorMaxSchemasSetting>(context);
 
 	reference_set_t<SchemaCatalogEntry> unseen_schemas;
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context, max_schema_count);
 
-	for (auto database : databases) {
+	for (const auto &database : databases) {
 		if (unseen_schemas.size() >= max_schema_count) {
 			break;
 		}
-		auto &catalog = database.get().GetCatalog();
+		auto &catalog = database->GetCatalog();
 		auto current_schemas = catalog.GetSchemas(context);
 		for (auto &current_schema : current_schemas) {
 			if (unseen_schemas.size() >= max_schema_count) {
@@ -838,17 +838,37 @@ CatalogEntryLookup Catalog::LookupEntry(CatalogEntryRetriever &retriever, const
 	return res;
 }
 
+static void ThrowDefaultTableAmbiguityException(CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table,
+                                                const string &name) {
+	auto entry_type = CatalogTypeToString(base_lookup.entry->type);
+	string fully_qualified_name_hint;
+	if (base_lookup.schema) {
+		fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
+		                                               base_lookup.schema->name, base_lookup.entry->name);
+	}
+	string fully_qualified_catalog_name_hint = StringUtil::Format(
+	    ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
+	throw CatalogException(
+	    "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
+	    "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
+	    "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
+	    "Default Table%s.",
+	    name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
+}
+
 CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, const vector<CatalogLookup> &lookups,
-                                           const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found) {
+                                           const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found,
+                                           bool allow_default_table_lookup) {
 	auto &context = retriever.GetContext();
 	reference_set_t<SchemaCatalogEntry> schemas;
 	bool all_errors = true;
 	ErrorData error_data;
+	CatalogEntryLookup result;
 	for (auto &lookup : lookups) {
 		auto transaction = lookup.catalog.GetCatalogTransaction(context);
-		auto result = lookup.catalog.TryLookupEntryInternal(transaction, lookup.schema, lookup.lookup_info);
+		result = lookup.catalog.TryLookupEntryInternal(transaction, lookup.schema, lookup.lookup_info);
 		if (result.Found()) {
-			return result;
+			break;
 		}
 		if (result.schema) {
 			schemas.insert(*result.schema);
@@ -859,6 +879,29 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 			error_data = std::move(result.error);
 		}
 	}
+
+	// Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
+	// lookup
+	if (lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY && allow_default_table_lookup) {
+		if (!result.Found()) {
+			result = TryLookupDefaultTable(retriever, lookup_info, false);
+			if (result.error.HasError()) {
+				error_data = std::move(result.error);
+			}
+		} else {
+			// allow_ignore_at_clause set to true to ensure `FROM <table_name> AT <version>` is considered
+			// ambiguous with a default table lookup in a catalog that does not support time travel
+			auto ambiguity_lookup = TryLookupDefaultTable(retriever, lookup_info, true);
+			if (ambiguity_lookup.Found()) {
+				ThrowDefaultTableAmbiguityException(result, ambiguity_lookup, lookup_info.GetEntryName());
+			}
+		}
+	}
+
+	if (result.Found()) {
+		return result;
+	}
+
 	if (all_errors && error_data.HasError()) {
 		error_data.Throw();
 	}
@@ -878,41 +921,29 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 	}
 }
 
-CatalogEntryLookup Catalog::TryLookupDefaultTable(CatalogEntryRetriever &retriever, const string &catalog,
-                                                  const string &schema, const EntryLookupInfo &lookup_info,
-                                                  OnEntryNotFound if_not_found) {
-	// Default tables of catalogs can only be accessed by the catalog name directly
-	if (!schema.empty() || !catalog.empty()) {
-		return {nullptr, nullptr, ErrorData()};
-	}
-
-	vector<CatalogLookup> catalog_by_name_lookups;
+CatalogEntryLookup Catalog::TryLookupDefaultTable(CatalogEntryRetriever &retriever, const EntryLookupInfo &lookup_info,
+                                                  bool allow_ignore_at_clause) {
 	auto catalog_by_name = GetCatalogEntry(retriever, lookup_info.GetEntryName());
+
 	if (catalog_by_name && catalog_by_name->HasDefaultTable()) {
-		catalog_by_name_lookups.emplace_back(*catalog_by_name, CatalogType::TABLE_ENTRY,
-		                                     catalog_by_name->GetDefaultTableSchema(),
-		                                     catalog_by_name->GetDefaultTable());
-	}
+		auto transaction = catalog_by_name->GetCatalogTransaction(retriever.GetContext());
+		QueryErrorContext context;
 
-	return TryLookupEntry(retriever, catalog_by_name_lookups, lookup_info, if_not_found);
-}
+		string table_schema = catalog_by_name->GetDefaultTableSchema();
+		string table_name = catalog_by_name->GetDefaultTable();
 
-static void ThrowDefaultTableAmbiguityException(CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table,
-                                                const string &name) {
-	auto entry_type = CatalogTypeToString(base_lookup.entry->type);
-	string fully_qualified_name_hint;
-	if (base_lookup.schema) {
-		fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
-		                                               base_lookup.schema->name, base_lookup.entry->name);
+		optional_ptr<BoundAtClause> at_clause;
+		if (!catalog_by_name->SupportsTimeTravel() && allow_ignore_at_clause) {
+			at_clause = nullptr;
+		} else {
+			at_clause = lookup_info.GetAtClause();
+		}
+
+		EntryLookupInfo info = EntryLookupInfo(CatalogType::TABLE_ENTRY, table_name, at_clause, context);
+		return catalog_by_name->TryLookupEntryInternal(transaction, table_schema, info);
 	}
-	string fully_qualified_catalog_name_hint = StringUtil::Format(
-	    ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
-	throw CatalogException(
-	    "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
-	    "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
-	    "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
-	    "Default Table%s.",
-	    name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
+
+	return {nullptr, nullptr, ErrorData()};
 }
 
 CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, const string &catalog,
@@ -945,25 +976,9 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 		lookups.emplace_back(std::move(lookup));
 	}
 
-	// Do the main lookup
-	auto lookup_result = TryLookupEntry(retriever, lookups, lookup_info, if_not_found);
-
-	// Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
-	// lookup
-	if (lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY) {
-		auto lookup_result_default_table =
-		    TryLookupDefaultTable(retriever, catalog, schema, lookup_info, OnEntryNotFound::RETURN_NULL);
-
-		if (lookup_result_default_table.Found() && lookup_result.Found()) {
-			ThrowDefaultTableAmbiguityException(lookup_result, lookup_result_default_table, lookup_info.GetEntryName());
-		}
-
-		if (lookup_result_default_table.Found()) {
-			return lookup_result_default_table;
-		}
-	}
+	bool allow_default_table_lookup = catalog.empty() && schema.empty();
 
-	return lookup_result;
+	return TryLookupEntry(retriever, lookups, lookup_info, if_not_found, allow_default_table_lookup);
 }
 
 CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType catalog_type, const string &catalog_name,
@@ -1119,8 +1134,8 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &cont
 
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context);
-	for (auto database : databases) {
-		auto &catalog = database.get().GetCatalog();
+	for (auto &database : databases) {
+		auto &catalog = database->GetCatalog();
 		auto new_schemas = catalog.GetSchemas(context);
 		result.insert(result.end(), new_schemas.begin(), new_schemas.end());
 	}
@@ -1140,6 +1155,16 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &cont
 	return result;
 }
 
+vector<reference<CatalogEntry>> Catalog::GetAllEntries(ClientContext &context, CatalogType catalog_type) {
+	vector<reference<CatalogEntry>> result;
+	auto schemas = GetAllSchemas(context);
+	for (const auto &schema_ref : schemas) {
+		auto &schema = schema_ref.get();
+		schema.Scan(context, catalog_type, [&](CatalogEntry &entry) { result.push_back(entry); });
+	}
+	return result;
+}
+
 void Catalog::Alter(CatalogTransaction transaction, AlterInfo &info) {
 	if (transaction.HasContext()) {
 		CatalogEntryRetriever retriever(transaction.GetContext());
@@ -1210,4 +1235,9 @@ void Catalog::FinalizeLoad(optional_ptr<ClientContext> context) {
 void Catalog::OnDetach(ClientContext &context) {
 }
 
+bool Catalog::HasConflictingAttachOptions(const string &path, const AttachOptions &options) {
+	auto const db_type = options.db_type.empty() ? "duckdb" : options.db_type;
+	return GetDBPath() != path || GetCatalogType() != db_type;
+}
+
 } // namespace duckdb