duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/function/table/read_csv.cpp

@@ -41,22 +41,6 @@ ReadCSVData::ReadCSVData() {
 
 void ReadCSVData::FinalizeRead(ClientContext &context) {
 	BaseCSVData::Finalize();
-	if (!options.rejects_recovery_columns.empty()) {
-		for (auto &recovery_col : options.rejects_recovery_columns) {
-			bool found = false;
-			for (idx_t col_idx = 0; col_idx < return_names.size(); col_idx++) {
-				if (StringUtil::CIEquals(return_names[col_idx], recovery_col)) {
-					options.rejects_recovery_column_ids.push_back(col_idx);
-					found = true;
-					break;
-				}
-			}
-			if (!found) {
-				throw BinderException("Unsupported parameter for REJECTS_RECOVERY_COLUMNS: column \"%s\" not found",
-				                      recovery_col);
-			}
-		}
-	}
 }
 
 static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctionBindInput &input,
@@ -67,26 +51,32 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	result->files = MultiFileReader::GetFileList(context, input.inputs[0], "CSV");
 
 	options.FromNamedParameters(input.named_parameters, context, return_types, names);
-
+	if (options.rejects_table_name.IsSetByUser() && !options.store_rejects.GetValue() &&
+	    options.store_rejects.IsSetByUser()) {
+		throw BinderException("REJECTS_TABLE option is only supported when store_rejects is not manually set to false");
+	}
+	if (options.rejects_scan_name.IsSetByUser() && !options.store_rejects.GetValue() &&
+	    options.store_rejects.IsSetByUser()) {
+		throw BinderException("REJECTS_SCAN option is only supported when store_rejects is not manually set to false");
+	}
+	if (options.rejects_scan_name.IsSetByUser() || options.rejects_table_name.IsSetByUser()) {
+		// Ensure we set store_rejects to true automagically
+		options.store_rejects.Set(true, false);
+	}
 	// Validate rejects_table options
-	if (!options.rejects_table_name.empty()) {
-		if (!options.ignore_errors) {
-			throw BinderException("REJECTS_TABLE option is only supported when IGNORE_ERRORS is set to true");
+	if (options.store_rejects.GetValue()) {
+		if (!options.ignore_errors.GetValue() && options.ignore_errors.IsSetByUser()) {
+			throw BinderException(
+			    "STORE_REJECTS option is only supported when IGNORE_ERRORS is not manually set to false");
 		}
+		// Ensure we set ignore errors to true automagically
+		options.ignore_errors.Set(true, false);
 		if (options.file_options.union_by_name) {
 			throw BinderException("REJECTS_TABLE option is not supported when UNION_BY_NAME is set to true");
 		}
 	}
-
-	if (options.rejects_limit != 0) {
-		if (options.rejects_table_name.empty()) {
-			throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name");
-		}
-	}
-
-	if (!options.rejects_recovery_columns.empty() && options.rejects_table_name.empty()) {
-		throw BinderException(
-		    "REJECTS_RECOVERY_COLUMNS option is only supported when REJECTS_TABLE is set to a table name");
+	if (options.rejects_limit != 0 && !options.store_rejects.GetValue()) {
+		throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name");
 	}
 
 	options.file_options.AutoDetectHivePartitioning(result->files, context);
@@ -142,8 +132,28 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	}
 	result->return_types = return_types;
 	result->return_names = names;
-
-	result->FinalizeRead(context);
+	if (!options.force_not_null_names.empty()) {
+		// Lets first check all column names match
+		duckdb::unordered_set<string> column_names;
+		for (auto &name : names) {
+			column_names.insert(name);
+		}
+		for (auto &force_name : options.force_not_null_names) {
+			if (column_names.find(force_name) == column_names.end()) {
+				throw BinderException("\"force_not_null\" expected to find %s, but it was not found in the table",
+				                      force_name);
+			}
+		}
+		D_ASSERT(options.force_not_null.empty());
+		for (idx_t i = 0; i < names.size(); i++) {
+			if (options.force_not_null_names.find(names[i]) != options.force_not_null_names.end()) {
+				options.force_not_null.push_back(true);
+			} else {
+				options.force_not_null.push_back(false);
+			}
+		}
+	}
+	result->Finalize();
 	return std::move(result);
 }
 
@@ -167,9 +177,10 @@ static unique_ptr<GlobalTableFunctionState> ReadCSVInitGlobal(ClientContext &con
 	auto &bind_data = input.bind_data->Cast<ReadCSVData>();
 
 	// Create the temporary rejects table
-	auto rejects_table = bind_data.options.rejects_table_name;
-	if (!rejects_table.empty()) {
-		CSVRejectsTable::GetOrCreate(context, rejects_table)->InitializeTable(context, bind_data);
+	if (bind_data.options.store_rejects.GetValue()) {
+		CSVRejectsTable::GetOrCreate(context, bind_data.options.rejects_scan_name.GetValue(),
+		                             bind_data.options.rejects_table_name.GetValue())
+		    ->InitializeTable(context, bind_data);
 	}
 	if (bind_data.files.empty()) {
 		// This can happen when a filename based filter pushdown has eliminated all possible files for this scan.
@@ -185,7 +196,7 @@ unique_ptr<LocalTableFunctionState> ReadCSVInitLocal(ExecutionContext &context,
 		return nullptr;
 	}
 	auto &global_state = global_state_p->Cast<CSVGlobalState>();
-	auto csv_scanner = global_state.Next();
+	auto csv_scanner = global_state.Next(nullptr);
 	if (!csv_scanner) {
 		global_state.DecrementThread();
 	}
@@ -211,7 +222,7 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p,
 			break;
 		}
 		if (csv_local_state.csv_reader->FinishedIterator()) {
-			csv_local_state.csv_reader = csv_global_state.Next();
+			csv_local_state.csv_reader = csv_global_state.Next(csv_local_state.csv_reader.get());
 			if (!csv_local_state.csv_reader) {
 				csv_global_state.DecrementThread();
 				break;
@@ -234,7 +245,7 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi
 	table_function.named_parameters["quote"] = LogicalType::VARCHAR;
 	table_function.named_parameters["new_line"] = LogicalType::VARCHAR;
 	table_function.named_parameters["escape"] = LogicalType::VARCHAR;
-	table_function.named_parameters["nullstr"] = LogicalType::VARCHAR;
+	table_function.named_parameters["nullstr"] = LogicalType::ANY;
 	table_function.named_parameters["columns"] = LogicalType::ANY;
 	table_function.named_parameters["auto_type_candidates"] = LogicalType::ANY;
 	table_function.named_parameters["header"] = LogicalType::BOOLEAN;
@@ -249,9 +260,11 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi
 	table_function.named_parameters["max_line_size"] = LogicalType::VARCHAR;
 	table_function.named_parameters["maximum_line_size"] = LogicalType::VARCHAR;
 	table_function.named_parameters["ignore_errors"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["store_rejects"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["rejects_table"] = LogicalType::VARCHAR;
+	table_function.named_parameters["rejects_scan"] = LogicalType::VARCHAR;
 	table_function.named_parameters["rejects_limit"] = LogicalType::BIGINT;
-	table_function.named_parameters["rejects_recovery_columns"] = LogicalType::LIST(LogicalType::VARCHAR);
+	table_function.named_parameters["force_not_null"] = LogicalType::LIST(LogicalType::VARCHAR);
 	table_function.named_parameters["buffer_size"] = LogicalType::UBIGINT;
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;

package/src/duckdb/src/function/table/sniff_csv.cpp

@@ -83,17 +83,6 @@ static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFuncti
 	return std::move(result);
 }
 
-string NewLineIdentifierToString(NewLineIdentifier identifier) {
-	switch (identifier) {
-	case NewLineIdentifier::SINGLE:
-		return "\\n";
-	case NewLineIdentifier::CARRY_ON:
-		return "\\r\\n";
-	default:
-		return "";
-	}
-}
-
 string FormatOptions(char opt) {
 	if (opt == '\'') {
 		return "''";
@@ -121,6 +110,12 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	sniffer_options.file_path = data.path;
 
 	auto buffer_manager = make_shared<CSVBufferManager>(context, sniffer_options, sniffer_options.file_path, 0);
+	if (sniffer_options.name_list.empty()) {
+		sniffer_options.name_list = data.names_csv;
+	}
+	if (sniffer_options.sql_type_list.empty()) {
+		sniffer_options.sql_type_list = data.return_types_csv;
+	}
 	CSVSniffer sniffer(sniffer_options, buffer_manager, CSVStateMachineCache::Get(context));
 	auto sniffer_result = sniffer.SniffCSV(true);
 	string str_opt;
@@ -138,8 +133,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	str_opt = sniffer_options.dialect_options.state_machine_options.escape.GetValue();
 	output.SetValue(2, 0, str_opt);
 	// 4. NewLine Delimiter
-	auto new_line_identifier =
-	    NewLineIdentifierToString(sniffer_options.dialect_options.state_machine_options.new_line.GetValue());
+	auto new_line_identifier = sniffer_options.NewLineIdentifierToString();
 	output.SetValue(3, 0, new_line_identifier);
 	// 5. Skip Rows
 	output.SetValue(4, 0, Value::UINTEGER(NumericCast<uint32_t>(sniffer_options.dialect_options.skip_rows.GetValue())));

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -153,7 +153,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				break;
 			case ConstraintType::UNIQUE: {
 				auto &unique = constraint->Cast<UniqueConstraint>();
-				constraint_type = unique.is_primary_key ? "PRIMARY KEY" : "UNIQUE";
+				constraint_type = unique.IsPrimaryKey() ? "PRIMARY KEY" : "UNIQUE";
 				break;
 			}
 			case ConstraintType::NOT_NULL:

package/src/duckdb/src/function/table/system/duckdb_databases.cpp

@@ -32,6 +32,9 @@ static unique_ptr<FunctionData> DuckDBDatabasesBind(ClientContext &context, Tabl
 	names.emplace_back("type");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("readonly");
+	return_types.emplace_back(LogicalType::BOOLEAN);
+
 	return nullptr;
 }
 
@@ -64,8 +67,9 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 		output.SetValue(col++, count, attached.GetName());
 		// database_oid, BIGINT
 		output.SetValue(col++, count, Value::BIGINT(attached.oid));
-		// path, VARCHAR
 		bool is_internal = attached.IsSystem() || attached.IsTemporary();
+		bool is_readonly = attached.IsReadOnly();
+		// path, VARCHAR
 		Value db_path;
 		if (!is_internal) {
 			bool in_memory = attached.GetCatalog().InMemory();
@@ -80,6 +84,8 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 		output.SetValue(col++, count, Value::BOOLEAN(is_internal));
 		// type, VARCHAR
 		output.SetValue(col++, count, Value(attached.GetCatalog().GetCatalogType()));
+		// readonly, BOOLEAN
+		output.SetValue(col++, count, Value::BOOLEAN(is_readonly));
 
 		count++;
 	}

package/src/duckdb/src/function/table/system/duckdb_extensions.cpp

@@ -17,6 +17,7 @@ struct ExtensionInformation {
 	string file_path;
 	string description;
 	vector<Value> aliases;
+	string extension_version;
 };
 
 struct DuckDBExtensionsData : public GlobalTableFunctionState {
@@ -47,6 +48,9 @@ static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, Tab
 	names.emplace_back("aliases");
 	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
 
+	names.emplace_back("extension_version");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	return nullptr;
 }
 
@@ -98,16 +102,20 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 	});
 #endif
 	// now check the list of currently loaded extensions
-	auto &loaded_extensions = db.LoadedExtensions();
-	for (auto &ext_name : loaded_extensions) {
+	auto &loaded_extensions = db.LoadedExtensionsData();
+	for (auto &e : loaded_extensions) {
+		auto &ext_name = e.first;
+		auto &ext_info = e.second;
 		auto entry = installed_extensions.find(ext_name);
 		if (entry == installed_extensions.end()) {
 			ExtensionInformation info;
 			info.name = ext_name;
 			info.loaded = true;
+			info.extension_version = ext_info.extension_version;
 			installed_extensions[ext_name] = std::move(info);
 		} else {
 			entry->second.loaded = true;
+			entry->second.extension_version = ext_info.extension_version;
 		}
 	}
 
@@ -143,6 +151,8 @@ void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p
 		output.SetValue(4, count, Value(entry.description));
 		// aliases     LogicalType::LIST(LogicalType::VARCHAR)
 		output.SetValue(5, count, Value::LIST(LogicalType::VARCHAR, entry.aliases));
+		// extension version     LogicalType::LIST(LogicalType::VARCHAR)
+		output.SetValue(6, count, Value(entry.extension_version));
 
 		data.offset++;
 		count++;

package/src/duckdb/src/function/table/system/duckdb_sequences.cpp

@@ -122,8 +122,7 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 		// cycle, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(seq_data.cycle));
 		// last_value, BIGINT
-		output.SetValue(col++, count,
-		                seq_data.usage_count == 0 ? Value() : Value::BOOLEAN(NumericCast<int8_t>(seq_data.last_value)));
+		output.SetValue(col++, count, seq_data.usage_count == 0 ? Value() : Value::BIGINT(seq_data.last_value));
 		// sql, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(seq.ToSQL()));
 

package/src/duckdb/src/function/table/system/duckdb_tables.cpp

@@ -87,7 +87,7 @@ static bool TableHasPrimaryKey(TableCatalogEntry &table) {
 	for (auto &constraint : table.GetConstraints()) {
 		if (constraint->type == ConstraintType::UNIQUE) {
 			auto &unique = constraint->Cast<UniqueConstraint>();
-			if (unique.is_primary_key) {
+			if (unique.IsPrimaryKey()) {
 				return true;
 			}
 		}
@@ -146,7 +146,7 @@ void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 		output.SetValue(col++, count, Value::BOOLEAN(TableHasPrimaryKey(table)));
 		// estimated_size, LogicalType::BIGINT
 		Value card_val =
-		    storage_info.cardinality == DConstants::INVALID_INDEX ? Value() : Value::BIGINT(storage_info.cardinality);
+		    !storage_info.cardinality.IsValid() ? Value() : Value::BIGINT(storage_info.cardinality.GetIndex());
 		output.SetValue(col++, count, card_val);
 		// column_count, LogicalType::BIGINT
 		output.SetValue(col++, count, Value::BIGINT(table.GetColumns().LogicalColumnCount()));

package/src/duckdb/src/function/table/system/pragma_metadata_info.cpp

@@ -34,8 +34,15 @@ static unique_ptr<FunctionData> PragmaMetadataInfoBind(ClientContext &context, T
 	names.emplace_back("free_list");
 	return_types.emplace_back(LogicalType::LIST(LogicalType::BIGINT));
 
-	string db_name =
-	    input.inputs.empty() ? DatabaseManager::GetDefaultDatabase(context) : StringValue::Get(input.inputs[0]);
+	string db_name;
+	if (input.inputs.empty()) {
+		db_name = DatabaseManager::GetDefaultDatabase(context);
+	} else {
+		if (input.inputs[0].IsNull()) {
+			throw BinderException("Database argument for pragma_metadata_info cannot be NULL");
+		}
+		db_name = StringValue::Get(input.inputs[0]);
+	}
 	auto &catalog = Catalog::GetCatalog(context, db_name);
 	auto result = make_uniq<PragmaMetadataFunctionData>();
 	result->metadata_info = catalog.GetMetadataInfo(context);

package/src/duckdb/src/function/table/system/pragma_table_info.cpp

@@ -195,12 +195,16 @@ static ColumnConstraintInfo CheckConstraints(TableCatalogEntry &table, const Col
 		}
 		case ConstraintType::UNIQUE: {
 			auto &unique = constraint->Cast<UniqueConstraint>();
-			bool &constraint_info = unique.is_primary_key ? result.pk : result.unique;
-			if (unique.index == column.Logical()) {
-				constraint_info = true;
-			}
-			if (std::find(unique.columns.begin(), unique.columns.end(), column.GetName()) != unique.columns.end()) {
-				constraint_info = true;
+			bool &constraint_info = unique.IsPrimaryKey() ? result.pk : result.unique;
+			if (unique.HasIndex()) {
+				if (unique.GetIndex() == column.Logical()) {
+					constraint_info = true;
+				}
+			} else {
+				auto &columns = unique.GetColumnNames();
+				if (std::find(columns.begin(), columns.end(), column.GetName()) != columns.end()) {
+					constraint_info = true;
+				}
 			}
 			break;
 		}

package/src/duckdb/src/function/table/table_scan.cpp

@@ -193,7 +193,7 @@ BindInfo TableScanGetBindInfo(const optional_ptr<FunctionData> bind_data_p) {
 	return BindInfo(bind_data.table);
 }
 
-void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
+void TableScanDependency(LogicalDependencyList &entries, const FunctionData *bind_data_p) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	entries.AddDependency(bind_data.table);
 }
@@ -306,9 +306,6 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		return;
 	}
 
-	// Lazily initialize any unknown indexes that might have been loaded by an extension
-	storage.info->InitializeIndexes(context);
-
 	// behold
 	storage.info->indexes.Scan([&](Index &index) {
 		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "1"
+#define DUCKDB_PATCH_VERSION "2"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 10
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 0
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v0.10.1"
+#define DUCKDB_VERSION "v0.10.2"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "4a89d97db8"
+#define DUCKDB_SOURCE_ID "1601d94f94"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -16,6 +16,7 @@
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/error_data.hpp"
 #include "duckdb/common/exception/catalog_exception.hpp"
 #include "duckdb/common/enums/catalog_lookup_behavior.hpp"
 #include <functional>
@@ -90,6 +91,7 @@ public:
 	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
 
 	DUCKDB_API AttachedDatabase &GetAttached();
+	DUCKDB_API const AttachedDatabase &GetAttached() const;
 	DUCKDB_API DatabaseInstance &GetDatabase();
 
 	virtual bool IsDuckCatalog() {
@@ -106,7 +108,7 @@ public:
 	DUCKDB_API idx_t ModifyCatalog();
 
 	//! Returns the catalog name - based on how the catalog was attached
-	DUCKDB_API const string &GetName();
+	DUCKDB_API const string &GetName() const;
 	DUCKDB_API idx_t GetOid();
 	DUCKDB_API virtual string GetCatalogType() = 0;
 
@@ -210,6 +212,7 @@ public:
 	                                                             QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
 	DUCKDB_API virtual void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) = 0;
+
 	//! Gets the "schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound
 	DUCKDB_API optional_ptr<CatalogEntry> GetEntry(ClientContext &context, CatalogType type, const string &schema,
 	                                               const string &name, OnEntryNotFound if_not_found,
@@ -324,6 +327,7 @@ protected:
 	//! Reference to the database
 	AttachedDatabase &db;
 
+public:
 private:
 	//! Lookup an entry in the schema, returning a lookup with the entry and schema if they exist
 	CatalogEntryLookup TryLookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
@@ -364,7 +368,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_index_entry.hpp

@@ -29,7 +29,7 @@ public:
 	//! Create a DuckIndexEntry
 	DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info);
 
-	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 
 	//! The indexed table information
 	shared_ptr<IndexDataTableInfo> info;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_schema_entry.hpp

@@ -41,7 +41,7 @@ public:
 	optional_ptr<CatalogEntry> AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
 	                                    OnCreateConflict on_conflict);
 	optional_ptr<CatalogEntry> AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                                            OnCreateConflict on_conflict, DependencyList dependencies);
+	                                            OnCreateConflict on_conflict, LogicalDependencyList dependencies);
 
 	optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) override;
 	optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) override;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp

@@ -58,7 +58,7 @@ public:
 	SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info);
 
 public:
-	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 	unique_ptr<CreateInfo> GetInfo() const override;
 
 	SequenceData GetData() const;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -77,7 +77,9 @@ public:
 	virtual string ToSQL() const;
 
 	virtual Catalog &ParentCatalog();
+	virtual const Catalog &ParentCatalog() const;
 	virtual SchemaCatalogEntry &ParentSchema();
+	virtual const SchemaCatalogEntry &ParentSchema() const;
 
 	virtual void Verify(Catalog &catalog);
 
@@ -100,7 +102,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -117,6 +119,9 @@ public:
 	Catalog &ParentCatalog() override {
 		return catalog;
 	}
+	const Catalog &ParentCatalog() const override {
+		return catalog;
+	}
 
 	void Verify(Catalog &catalog) override;
 };

package/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp

@@ -26,7 +26,7 @@ namespace duckdb {
 struct AlterInfo;
 
 class ClientContext;
-class DependencyList;
+class LogicalDependencyList;
 
 class DuckCatalog;
 class TableCatalogEntry;
@@ -65,9 +65,9 @@ public:
 	//! Create an entry in the catalog set. Returns whether or not it was
 	//! successful.
 	DUCKDB_API bool CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-	                            const DependencyList &dependencies);
+	                            const LogicalDependencyList &dependencies);
 	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                            const DependencyList &dependencies);
+	                            const LogicalDependencyList &dependencies);
 
 	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo &alter_info);
 

package/src/duckdb/src/include/duckdb/catalog/default/default_functions.hpp

@@ -27,15 +27,15 @@ public:
 
 	SchemaCatalogEntry &schema;
 
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(DefaultMacro &default_macro);
-	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro);
+	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(const DefaultMacro &default_macro);
+	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(const DefaultMacro &default_macro);
 
 public:
 	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
 	vector<string> GetDefaultEntries() override;
 
 private:
-	static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro,
+	static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(const DefaultMacro &default_macro,
 	                                                                unique_ptr<MacroFunction> function);
 };
 

package/src/duckdb/src/include/duckdb/catalog/dependency.hpp

@@ -10,17 +10,18 @@
 
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 class CatalogEntry;
 
 struct DependencyFlags {
-private:
 public:
 	DependencyFlags() : value(0) {
 	}
 	DependencyFlags(const DependencyFlags &other) : value(other.value) {
 	}
+	virtual ~DependencyFlags() = default;
 	DependencyFlags &operator=(const DependencyFlags &other) {
 		value = other.value;
 		return *this;
@@ -133,10 +134,31 @@ public:
 	}
 };
 
+struct CatalogEntryInfo {
+public:
+	CatalogType type;
+	string schema;
+	string name;
+
+public:
+	bool operator==(const CatalogEntryInfo &other) const {
+		if (other.type != type) {
+			return false;
+		}
+		if (!StringUtil::CIEquals(other.schema, schema)) {
+			return false;
+		}
+		if (!StringUtil::CIEquals(other.name, name)) {
+			return false;
+		}
+		return true;
+	}
+};
+
 struct Dependency {
-	Dependency(CatalogEntry &entry, DependencyDependentFlags flags = DependencyDependentFlags().SetBlocking())
-	    : // NOLINT: Allow implicit conversion from `CatalogEntry`
-	      entry(entry), flags(flags) {
+	Dependency(CatalogEntry &entry, // NOLINT: Allow implicit conversion from `CatalogEntry`
+	           DependencyDependentFlags flags = DependencyDependentFlags().SetBlocking())
+	    : entry(entry), flags(std::move(flags)) {
 	}
 
 	//! The catalog entry this depends on