duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

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

@@ -1,13 +1,11 @@
 #include "parquet_statistics.hpp"
 #include "parquet_decimal_utils.hpp"
 #include "parquet_timestamp.hpp"
-
 #include "duckdb.hpp"
 #ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+#include "duckdb/common/types/time.hpp"
 #endif
 
 namespace duckdb {
@@ -15,30 +13,32 @@ namespace duckdb {
 using duckdb_parquet::format::ConvertedType;
 using duckdb_parquet::format::Type;
 
-static unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
-                                                     const duckdb_parquet::format::SchemaElement &schema_ele,
-                                                     const duckdb_parquet::format::Statistics &parquet_stats) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+static duckdb::unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
+                                                             const duckdb_parquet::format::SchemaElement &schema_ele,
+                                                             const duckdb_parquet::format::Statistics &parquet_stats) {
+	auto stats = NumericStats::CreateUnknown(type);
 
 	// for reasons unknown to science, Parquet defines *both* `min` and `min_value` as well as `max` and
 	// `max_value`. All are optional. such elegance.
+	Value min;
+	Value max;
 	if (parquet_stats.__isset.min) {
-		stats->min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.min_value) {
-		stats->min =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
 	} else {
-		stats->min = Value(type);
+		min = Value(type);
 	}
 	if (parquet_stats.__isset.max) {
-		stats->max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.max_value) {
-		stats->max =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
 	} else {
-		stats->max = Value(type);
+		max = Value(type);
 	}
-	return std::move(stats);
+	NumericStats::SetMin(stats, min);
+	NumericStats::SetMax(stats, max);
+	return stats.ToUnique();
 }
 
 Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
@@ -154,11 +154,31 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 		return Value::DATE(date_t(Load<int32_t>((data_ptr_t)stats.c_str())));
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ: {
-		if (stats.size() != sizeof(int64_t)) {
+		int64_t val;
+		if (stats.size() == sizeof(int32_t)) {
+			val = Load<int32_t>((data_ptr_t)stats.c_str());
+		} else if (stats.size() == sizeof(int64_t)) {
+			val = Load<int64_t>((data_ptr_t)stats.c_str());
+		} else {
 			throw InternalException("Incorrect stats size for type TIME");
 		}
-		auto time = dtime_t(Load<int64_t>((data_ptr_t)stats.c_str()));
-		return Value::TIME(time);
+		if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIME) {
+			// logical type
+			if (schema_ele.logicalType.TIME.unit.__isset.MILLIS) {
+				return Value::TIME(Time::FromTimeMs(val));
+			} else if (schema_ele.logicalType.TIME.unit.__isset.NANOS) {
+				return Value::TIME(Time::FromTimeNs(val));
+			} else if (schema_ele.logicalType.TIME.unit.__isset.MICROS) {
+				return Value::TIME(dtime_t(val));
+			} else {
+				throw InternalException("Time logicalType is set but unit is not defined");
+			}
+		}
+		if (schema_ele.converted_type == duckdb_parquet::format::ConvertedType::TIME_MILLIS) {
+			return Value::TIME(Time::FromTimeMs(val));
+		} else {
+			return Value::TIME(dtime_t(val));
+		}
 	}
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ: {
@@ -205,7 +225,7 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 		return nullptr;
 	}
 	auto &parquet_stats = column_chunk.meta_data.statistics;
-	unique_ptr<BaseStatistics> row_group_stats;
+	duckdb::unique_ptr<BaseStatistics> row_group_stats;
 
 	switch (type.id()) {
 	case LogicalTypeId::UTINYINT:
@@ -228,24 +248,24 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 		row_group_stats = CreateNumericStats(type, s_ele, parquet_stats);
 		break;
 	case LogicalTypeId::VARCHAR: {
-		auto string_stats = make_unique<StringStatistics>(type, StatisticsType::LOCAL_STATS);
+		auto string_stats = StringStats::CreateEmpty(type);
 		if (parquet_stats.__isset.min) {
-			string_stats->Update(parquet_stats.min);
+			StringStats::Update(string_stats, parquet_stats.min);
 		} else if (parquet_stats.__isset.min_value) {
-			string_stats->Update(parquet_stats.min_value);
+			StringStats::Update(string_stats, parquet_stats.min_value);
 		} else {
 			return nullptr;
 		}
 		if (parquet_stats.__isset.max) {
-			string_stats->Update(parquet_stats.max);
+			StringStats::Update(string_stats, parquet_stats.max);
 		} else if (parquet_stats.__isset.max_value) {
-			string_stats->Update(parquet_stats.max_value);
+			StringStats::Update(string_stats, parquet_stats.max_value);
 		} else {
 			return nullptr;
 		}
-		string_stats->has_unicode = true; // we dont know better
-		string_stats->max_string_length = NumericLimits<uint32_t>::Maximum();
-		row_group_stats = std::move(string_stats);
+		StringStats::SetContainsUnicode(string_stats);
+		StringStats::ResetMaxStringLength(string_stats);
+		row_group_stats = string_stats.ToUnique();
 		break;
 	}
 	default:
@@ -254,21 +274,14 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 	} // end of type switch
 
 	// null count is generic
-	if (row_group_stats) {
-		if (column_chunk.meta_data.type == duckdb_parquet::format::Type::FLOAT ||
-		    column_chunk.meta_data.type == duckdb_parquet::format::Type::DOUBLE) {
-			// floats/doubles can have infinity, which can become NULL
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		} else if (parquet_stats.__isset.null_count) {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(parquet_stats.null_count != 0);
-		} else {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		}
-	} else {
+	if (!row_group_stats) {
 		// if stats are missing from any row group we know squat
 		return nullptr;
 	}
-
+	row_group_stats->Set(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES);
+	if (parquet_stats.__isset.null_count && parquet_stats.null_count == 0) {
+		row_group_stats->Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	}
 	return row_group_stats;
 }
 

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

@@ -12,24 +12,26 @@ namespace duckdb {
 // surely they are joking
 static constexpr int64_t JULIAN_TO_UNIX_EPOCH_DAYS = 2440588LL;
 static constexpr int64_t MILLISECONDS_PER_DAY = 86400000LL;
-static constexpr int64_t NANOSECONDS_PER_DAY = MILLISECONDS_PER_DAY * 1000LL * 1000LL;
+static constexpr int64_t MICROSECONDS_PER_DAY = MILLISECONDS_PER_DAY * 1000LL;
+static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
 
-int64_t ImpalaTimestampToNanoseconds(const Int96 &impala_timestamp) {
+static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
 	int64_t days_since_epoch = impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
 	auto nanoseconds = Load<int64_t>((data_ptr_t)impala_timestamp.value);
-	return days_since_epoch * NANOSECONDS_PER_DAY + nanoseconds;
+	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
+	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
 }
 
 timestamp_t ImpalaTimestampToTimestamp(const Int96 &raw_ts) {
-	auto impala_ns = ImpalaTimestampToNanoseconds(raw_ts);
-	return Timestamp::FromEpochNanoSeconds(impala_ns);
+	auto impala_us = ImpalaTimestampToMicroseconds(raw_ts);
+	return Timestamp::FromEpochMicroSeconds(impala_us);
 }
 
 Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 	int32_t hour, min, sec, msec;
 	Time::Convert(Timestamp::GetTime(ts), hour, min, sec, msec);
 	uint64_t ms_since_midnight = hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
-	auto days_since_epoch = Date::Epoch(Timestamp::GetDate(ts)) / (24 * 60 * 60);
+	auto days_since_epoch = Date::Epoch(Timestamp::GetDate(ts)) / int64_t(24 * 60 * 60);
 	// first two uint32 in Int96 are nanoseconds since midnights
 	// last uint32 is number of days since year 4713 BC ("Julian date")
 	Int96 impala_ts;
@@ -52,8 +54,16 @@ date_t ParquetIntToDate(const int32_t &raw_date) {
 	return date_t(raw_date);
 }
 
+dtime_t ParquetIntToTimeMs(const int32_t &raw_time) {
+	return Time::FromTimeMs(raw_time);
+}
+
 dtime_t ParquetIntToTime(const int64_t &raw_time) {
 	return dtime_t(raw_time);
 }
 
+dtime_t ParquetIntToTimeNs(const int64_t &raw_time) {
+	return Time::FromTimeNs(raw_time);
+}
+
 } // namespace duckdb

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

@@ -229,7 +229,7 @@ ParquetWriter::ParquetWriter(FileSystem &fs, string file_name_p, FileOpener *fil
                              vector<string> names_p, CompressionCodec::type codec)
     : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec) {
 	// initialize the file writer
-	writer = make_unique<BufferedFileWriter>(
+	writer = make_uniq<BufferedFileWriter>(
 	    fs, file_name.c_str(), FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW, file_opener_p);
 	// parquet files start with the string "PAR1"
 	writer->WriteData((const_data_ptr_t) "PAR1", 4);
@@ -271,7 +271,7 @@ void ParquetWriter::Flush(ColumnDataCollection &buffer) {
 	row_group.num_rows = buffer.Count();
 	row_group.__isset.file_offset = true;
 
-	vector<unique_ptr<ColumnWriterState>> states;
+	vector<duckdb::unique_ptr<ColumnWriterState>> states;
 	// iterate over each of the columns of the chunk collection and write them
 	D_ASSERT(buffer.ColumnCount() == column_writers.size());
 	for (idx_t col_idx = 0; col_idx < buffer.ColumnCount(); col_idx++) {

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

@@ -155,7 +155,7 @@ void ZstdStreamWrapper::Close() {
 
 class ZStdFile : public CompressedFile {
 public:
-	ZStdFile(unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
+	ZStdFile(duckdb::unique_ptr<FileHandle> child_handle_p, const string &path, bool write)
 	    : CompressedFile(zstd_fs, std::move(child_handle_p), path) {
 		Initialize(write);
 	}
@@ -163,13 +163,13 @@ public:
 	ZStdFileSystem zstd_fs;
 };
 
-unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(unique_ptr<FileHandle> handle, bool write) {
+unique_ptr<FileHandle> ZStdFileSystem::OpenCompressedFile(duckdb::unique_ptr<FileHandle> handle, bool write) {
 	auto path = handle->path;
-	return make_unique<ZStdFile>(std::move(handle), path, write);
+	return make_uniq<ZStdFile>(std::move(handle), path, write);
 }
 
 unique_ptr<StreamWrapper> ZStdFileSystem::CreateStream() {
-	return make_unique<ZstdStreamWrapper>();
+	return make_uniq<ZstdStreamWrapper>();
 }
 
 idx_t ZStdFileSystem::InBufferSize() {

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

@@ -63,20 +63,28 @@ Catalog &Catalog::GetSystemCatalog(ClientContext &context) {
 	return Catalog::GetSystemCatalog(*context.db);
 }
 
-Catalog &Catalog::GetCatalog(ClientContext &context, const string &catalog_name) {
+optional_ptr<Catalog> Catalog::GetCatalogEntry(ClientContext &context, const string &catalog_name) {
 	auto &db_manager = DatabaseManager::Get(context);
 	if (catalog_name == TEMP_CATALOG) {
-		return ClientData::Get(context).temporary_objects->GetCatalog();
+		return &ClientData::Get(context).temporary_objects->GetCatalog();
 	}
 	if (catalog_name == SYSTEM_CATALOG) {
-		return GetSystemCatalog(context);
+		return &GetSystemCatalog(context);
 	}
 	auto entry = db_manager.GetDatabase(
 	    context, IsInvalidCatalog(catalog_name) ? DatabaseManager::GetDefaultDatabase(context) : catalog_name);
 	if (!entry) {
+		return nullptr;
+	}
+	return &entry->GetCatalog();
+}
+
+Catalog &Catalog::GetCatalog(ClientContext &context, const string &catalog_name) {
+	auto catalog = Catalog::GetCatalogEntry(context, catalog_name);
+	if (!catalog) {
 		throw BinderException("Catalog \"%s\" does not exist!", catalog_name);
 	}
-	return entry->GetCatalog();
+	return *catalog;
 }
 
 //===--------------------------------------------------------------------===//
@@ -103,14 +111,14 @@ CatalogEntry *Catalog::CreateTable(ClientContext &context, unique_ptr<CreateTabl
 	return CreateTable(context, bound_info.get());
 }
 
-CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                    BoundCreateTableInfo *info) {
-	return schema->CreateTable(transaction, info);
+	return schema.CreateTable(transaction, info);
 }
 
 CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) {
 	auto schema = GetSchema(transaction, info->base->schema);
-	return CreateTable(transaction, schema, info);
+	return CreateTable(transaction, *schema, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -118,15 +126,15 @@ CatalogEntry *Catalog::CreateTable(CatalogTransaction transaction, BoundCreateTa
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, CreateViewInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateView(transaction, schema, info);
+	return CreateView(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateView(ClientContext &context, CreateViewInfo *info) {
 	return CreateView(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry *schema, CreateViewInfo *info) {
-	return schema->CreateView(transaction, info);
+CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateViewInfo *info) {
+	return schema.CreateView(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -134,16 +142,16 @@ CatalogEntry *Catalog::CreateView(CatalogTransaction transaction, SchemaCatalogE
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateSequence(transaction, schema, info);
+	return CreateSequence(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateSequence(ClientContext &context, CreateSequenceInfo *info) {
 	return CreateSequence(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                       CreateSequenceInfo *info) {
-	return schema->CreateSequence(transaction, info);
+	return schema.CreateSequence(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -151,15 +159,15 @@ CatalogEntry *Catalog::CreateSequence(CatalogTransaction transaction, SchemaCata
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, CreateTypeInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateType(transaction, schema, info);
+	return CreateType(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateType(ClientContext &context, CreateTypeInfo *info) {
 	return CreateType(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry *schema, CreateTypeInfo *info) {
-	return schema->CreateType(transaction, info);
+CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTypeInfo *info) {
+	return schema.CreateType(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -167,16 +175,16 @@ CatalogEntry *Catalog::CreateType(CatalogTransaction transaction, SchemaCatalogE
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateTableFunction(transaction, schema, info);
+	return CreateTableFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info) {
 	return CreateTableFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                            CreateTableFunctionInfo *info) {
-	return schema->CreateTableFunction(transaction, info);
+	return schema.CreateTableFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -184,16 +192,16 @@ CatalogEntry *Catalog::CreateTableFunction(CatalogTransaction transaction, Schem
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateCopyFunction(transaction, schema, info);
+	return CreateCopyFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info) {
 	return CreateCopyFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                           CreateCopyFunctionInfo *info) {
-	return schema->CreateCopyFunction(transaction, info);
+	return schema.CreateCopyFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -201,16 +209,16 @@ CatalogEntry *Catalog::CreateCopyFunction(CatalogTransaction transaction, Schema
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreatePragmaFunction(transaction, schema, info);
+	return CreatePragmaFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info) {
 	return CreatePragmaFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                             CreatePragmaFunctionInfo *info) {
-	return schema->CreatePragmaFunction(transaction, info);
+	return schema.CreatePragmaFunction(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -218,16 +226,16 @@ CatalogEntry *Catalog::CreatePragmaFunction(CatalogTransaction transaction, Sche
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateFunction(transaction, schema, info);
+	return CreateFunction(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateFunction(ClientContext &context, CreateFunctionInfo *info) {
 	return CreateFunction(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                       CreateFunctionInfo *info) {
-	return schema->CreateFunction(transaction, info);
+	return schema.CreateFunction(transaction, info);
 }
 
 CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
@@ -240,16 +248,16 @@ CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *i
 //===--------------------------------------------------------------------===//
 CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) {
 	auto schema = GetSchema(transaction, info->schema);
-	return CreateCollation(transaction, schema, info);
+	return CreateCollation(transaction, *schema, info);
 }
 
 CatalogEntry *Catalog::CreateCollation(ClientContext &context, CreateCollationInfo *info) {
 	return CreateCollation(GetCatalogTransaction(context), info);
 }
 
-CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+CatalogEntry *Catalog::CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry &schema,
                                        CreateCollationInfo *info) {
-	return schema->CreateCollation(transaction, info);
+	return schema.CreateCollation(transaction, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -279,8 +287,8 @@ struct CatalogLookup {
 
 //! Return value of Catalog::LookupEntry
 struct CatalogEntryLookup {
-	SchemaCatalogEntry *schema;
-	CatalogEntry *entry;
+	optional_ptr<SchemaCatalogEntry> schema;
+	optional_ptr<CatalogEntry> entry;
 
 	DUCKDB_API bool Found() const {
 		return entry;
@@ -315,18 +323,19 @@ SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &sch
 // Lookup
 //===--------------------------------------------------------------------===//
 SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
-                                                   const unordered_set<SchemaCatalogEntry *> &schemas) {
+                                                   const reference_set_t<SchemaCatalogEntry> &schemas) {
 	SimilarCatalogEntry result;
-	for (auto schema : schemas) {
-		auto transaction = schema->catalog->GetCatalogTransaction(context);
-		auto entry = schema->GetSimilarEntry(transaction, type, entry_name);
+	for (auto schema_ref : schemas) {
+		auto &schema = schema_ref.get();
+		auto transaction = schema.catalog->GetCatalogTransaction(context);
+		auto entry = schema.GetSimilarEntry(transaction, type, entry_name);
 		if (!entry.Found()) {
 			// no similar entry found
 			continue;
 		}
 		if (!result.Found() || result.distance > entry.distance) {
 			result = entry;
-			result.schema = schema;
+			result.schema = &schema;
 		}
 	}
 	return result;
@@ -438,18 +447,18 @@ CatalogException Catalog::UnrecognizedConfigurationError(ClientContext &context,
 
 CatalogException Catalog::CreateMissingEntryException(ClientContext &context, const string &entry_name,
                                                       CatalogType type,
-                                                      const unordered_set<SchemaCatalogEntry *> &schemas,
+                                                      const reference_set_t<SchemaCatalogEntry> &schemas,
                                                       QueryErrorContext error_context) {
 	auto entry = SimilarEntryInSchemas(context, entry_name, type, schemas);
 
-	unordered_set<SchemaCatalogEntry *> unseen_schemas;
+	reference_set_t<SchemaCatalogEntry> unseen_schemas;
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context);
 	for (auto database : databases) {
 		auto &catalog = database->GetCatalog();
 		auto current_schemas = catalog.GetAllSchemas(context);
 		for (auto &current_schema : current_schemas) {
-			unseen_schemas.insert(current_schema);
+			unseen_schemas.insert(*current_schema);
 		}
 	}
 	// check if the entry exists in any extension
@@ -498,7 +507,7 @@ CatalogEntryLookup Catalog::LookupEntryInternal(CatalogTransaction transaction,
 
 CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema,
                                         const string &name, bool if_exists, QueryErrorContext error_context) {
-	unordered_set<SchemaCatalogEntry *> schemas;
+	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
 		auto catalog_name = GetName();
@@ -514,7 +523,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 				return result;
 			}
 			if (result.schema) {
-				schemas.insert(result.schema);
+				schemas.insert(*result.schema);
 			}
 		}
 	} else {
@@ -524,7 +533,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 			return result;
 		}
 		if (result.schema) {
-			schemas.insert(result.schema);
+			schemas.insert(*result.schema);
 		}
 	}
 	if (if_exists) {
@@ -535,7 +544,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 
 CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
                                         const string &name, bool if_exists, QueryErrorContext error_context) {
-	unordered_set<SchemaCatalogEntry *> schemas;
+	reference_set_t<SchemaCatalogEntry> schemas;
 	for (auto &lookup : lookups) {
 		auto transaction = lookup.catalog.GetCatalogTransaction(context);
 		auto result = lookup.catalog.LookupEntryInternal(transaction, type, lookup.schema, name);
@@ -543,7 +552,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLo
 			return result;
 		}
 		if (result.schema) {
-			schemas.insert(result.schema);
+			schemas.insert(*result.schema);
 		}
 	}
 	if (if_exists) {
@@ -567,7 +576,7 @@ CatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema, co
 
 CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name, const string &name,
                                 bool if_exists, QueryErrorContext error_context) {
-	return LookupEntry(context, type, schema_name, name, if_exists, error_context).entry;
+	return LookupEntry(context, type, schema_name, name, if_exists, error_context).entry.get();
 }
 
 CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog, const string &schema,
@@ -576,14 +585,22 @@ CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const
 	vector<CatalogLookup> lookups;
 	lookups.reserve(entries.size());
 	for (auto &entry : entries) {
-		lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
+		if (if_exists_p) {
+			auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
+			if (!catalog_entry) {
+				return nullptr;
+			}
+			lookups.emplace_back(*catalog_entry, entry.schema);
+		} else {
+			lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
+		}
 	}
 	auto result = LookupEntry(context, lookups, type, name, if_exists_p, error_context);
 	if (!result.Found()) {
 		D_ASSERT(if_exists_p);
 		return nullptr;
 	}
-	return result.entry;
+	return result.entry.get();
 }
 
 SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &catalog_name, const string &schema_name,
@@ -625,6 +642,19 @@ vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context) {
 	return schemas;
 }
 
+bool Catalog::TypeExists(ClientContext &context, const string &catalog_name, const string &schema, const string &name) {
+	CatalogEntry *entry;
+	entry = GetEntry(context, CatalogType::TYPE_ENTRY, catalog_name, schema, name, true);
+	if (!entry) {
+		// look in the system catalog
+		entry = GetEntry(context, CatalogType::TYPE_ENTRY, SYSTEM_CATALOG, schema, name, true);
+		if (!entry) {
+			return false;
+		}
+	}
+	return true;
+}
+
 vector<SchemaCatalogEntry *> Catalog::GetSchemas(ClientContext &context, const string &catalog_name) {
 	vector<Catalog *> catalogs;
 	if (IsInvalidCatalog(catalog_name)) {

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

@@ -13,14 +13,14 @@ DuckIndexEntry::~DuckIndexEntry() {
 	if (!info || !index) {
 		return;
 	}
-	info->indexes.RemoveIndex(index);
+	info->indexes.RemoveIndex(*index);
 }
 
-string DuckIndexEntry::GetSchemaName() {
+string DuckIndexEntry::GetSchemaName() const {
 	return info->schema;
 }
 
-string DuckIndexEntry::GetTableName() {
+string DuckIndexEntry::GetTableName() const {
 	return info->table;
 }