duckdb 0.7.2-dev2430.0 → 0.7.2-dev2552.0

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

@@ -3,10 +3,10 @@
 
 namespace duckdb {
 
-PragmaFunctionCatalogEntry::PragmaFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                       CreatePragmaFunctionInfo *info)
-    : StandardEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, schema, catalog, info->name),
-      functions(std::move(info->functions)) {
+PragmaFunctionCatalogEntry::PragmaFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
+                                                       CreatePragmaFunctionInfo &info)
+    : StandardEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, schema, catalog, info.name),
+      functions(std::move(info.functions)) {
 }
 
 } // namespace duckdb

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

@@ -3,28 +3,28 @@
 
 namespace duckdb {
 
-ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                       CreateScalarFunctionInfo *info)
-    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info->name), functions(info->functions) {
+ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
+                                                       CreateScalarFunctionInfo &info)
+    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info.name), functions(info.functions) {
 }
 
-unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	if (info->type != AlterType::ALTER_SCALAR_FUNCTION) {
+unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
+	if (info.type != AlterType::ALTER_SCALAR_FUNCTION) {
 		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter type");
 	}
-	auto &function_info = (AlterScalarFunctionInfo &)*info;
+	auto &function_info = info.Cast<AlterScalarFunctionInfo>();
 	if (function_info.alter_scalar_function_type != AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS) {
 		throw InternalException(
 		    "Attempting to alter ScalarFunctionCatalogEntry with unsupported alter scalar function type");
 	}
-	auto &add_overloads = (AddScalarFunctionOverloadInfo &)function_info;
+	auto &add_overloads = function_info.Cast<AddScalarFunctionOverloadInfo>();
 
 	ScalarFunctionSet new_set = functions;
 	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
 		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
 	}
 	CreateScalarFunctionInfo new_info(std::move(new_set));
-	return make_uniq<ScalarFunctionCatalogEntry>(catalog, schema, &new_info);
+	return make_uniq<ScalarFunctionCatalogEntry>(catalog, schema, new_info);
 }
 
 } // namespace duckdb

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

@@ -6,16 +6,16 @@
 
 namespace duckdb {
 
-MacroCatalogEntry::MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
+MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
     : StandardEntry(
-          (info->function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
-          schema, catalog, info->name),
-      function(std::move(info->function)) {
-	this->temporary = info->temporary;
-	this->internal = info->internal;
+          (info.function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
+          schema, catalog, info.name),
+      function(std::move(info.function)) {
+	this->temporary = info.temporary;
+	this->internal = info.internal;
 }
 
-ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
+ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
@@ -23,7 +23,7 @@ void ScalarMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	D_ASSERT(!internal);
 	auto &scalar_function = function->Cast<ScalarMacroFunction>();
 	FieldWriter writer(main_serializer);
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	writer.WriteSerializable(*scalar_function.expression);
 	// writer.WriteSerializableList(function->parameters);
@@ -58,7 +58,7 @@ unique_ptr<CreateMacroInfo> ScalarMacroCatalogEntry::Deserialize(Deserializer &m
 	return info;
 }
 
-TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info)
+TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
@@ -67,7 +67,7 @@ void TableMacroCatalogEntry::Serialize(Serializer &main_serializer) const {
 	FieldWriter writer(main_serializer);
 
 	auto &table_function = function->Cast<TableMacroFunction>();
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	writer.WriteSerializable(*table_function.query_node);
 	writer.WriteSerializableList(function->parameters);

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

@@ -11,23 +11,23 @@
 
 namespace duckdb {
 
-SchemaCatalogEntry::SchemaCatalogEntry(Catalog *catalog, string name_p, bool internal)
-    : CatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, std::move(name_p)) {
+SchemaCatalogEntry::SchemaCatalogEntry(Catalog &catalog, string name_p, bool internal)
+    : InCatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, std::move(name_p)) {
 	this->internal = internal;
 }
 
 CatalogTransaction SchemaCatalogEntry::GetCatalogTransaction(ClientContext &context) {
-	return CatalogTransaction(*catalog, context);
+	return CatalogTransaction(catalog, context);
 }
 
 SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
                                                         const string &name) {
 	SimilarCatalogEntry result;
-	Scan(transaction.GetContext(), type, [&](CatalogEntry *entry) {
-		auto ldist = StringUtil::SimilarityScore(entry->name, name);
+	Scan(transaction.GetContext(), type, [&](CatalogEntry &entry) {
+		auto ldist = StringUtil::SimilarityScore(entry.name, name);
 		if (ldist < result.distance) {
 			result.distance = ldist;
-			result.name = entry->name;
+			result.name = entry.name;
 		}
 	});
 	return result;

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

@@ -11,16 +11,16 @@
 
 namespace duckdb {
 
-SequenceCatalogEntry::SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateSequenceInfo *info)
-    : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info->name), usage_count(info->usage_count),
-      counter(info->start_value), increment(info->increment), start_value(info->start_value),
-      min_value(info->min_value), max_value(info->max_value), cycle(info->cycle) {
-	this->temporary = info->temporary;
+SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateSequenceInfo &info)
+    : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info.name), usage_count(info.usage_count),
+      counter(info.start_value), increment(info.increment), start_value(info.start_value), min_value(info.min_value),
+      max_value(info.max_value), cycle(info.cycle) {
+	this->temporary = info.temporary;
 }
 
 void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	writer.WriteField<uint64_t>(usage_count);
 	writer.WriteField<int64_t>(increment);

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

@@ -14,7 +14,7 @@
 
 namespace duckdb {
 
-TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableInfo &info)
+TableCatalogEntry::TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info)
     : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info.table), columns(std::move(info.columns)),
       constraints(std::move(info.constraints)) {
 	this->temporary = info.temporary;
@@ -55,7 +55,7 @@ void TableCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 
 	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	columns.Serialize(writer);
 	writer.WriteSerializableList(constraints);
@@ -165,8 +165,8 @@ string TableCatalogEntry::ToSQL() const {
 
 	ss << "CREATE TABLE ";
 
-	if (schema->name != DEFAULT_SCHEMA) {
-		ss << KeywordHelper::WriteOptionallyQuoted(schema->name) << ".";
+	if (schema.name != DEFAULT_SCHEMA) {
+		ss << KeywordHelper::WriteOptionallyQuoted(schema.name) << ".";
 	}
 
 	ss << KeywordHelper::WriteOptionallyQuoted(name);

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

@@ -3,30 +3,30 @@
 
 namespace duckdb {
 
-TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
-                                                     CreateTableFunctionInfo *info)
-    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info->name),
-      functions(std::move(info->functions)) {
+TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
+                                                     CreateTableFunctionInfo &info)
+    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info.name),
+      functions(std::move(info.functions)) {
 	D_ASSERT(this->functions.Size() > 0);
 }
 
-unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	if (info->type != AlterType::ALTER_TABLE_FUNCTION) {
+unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
+	if (info.type != AlterType::ALTER_TABLE_FUNCTION) {
 		throw InternalException("Attempting to alter TableFunctionCatalogEntry with unsupported alter type");
 	}
-	auto &function_info = (AlterTableFunctionInfo &)*info;
+	auto &function_info = info.Cast<AlterTableFunctionInfo>();
 	if (function_info.alter_table_function_type != AlterTableFunctionType::ADD_FUNCTION_OVERLOADS) {
 		throw InternalException(
 		    "Attempting to alter TableFunctionCatalogEntry with unsupported alter table function type");
 	}
-	auto &add_overloads = (AddTableFunctionOverloadInfo &)function_info;
+	auto &add_overloads = function_info.Cast<AddTableFunctionOverloadInfo>();
 
 	TableFunctionSet new_set = functions;
 	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
 		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
 	}
 	CreateTableFunctionInfo new_info(std::move(new_set));
-	return make_uniq<TableFunctionCatalogEntry>(catalog, schema, &new_info);
+	return make_uniq<TableFunctionCatalogEntry>(catalog, schema, new_info);
 }
 
 } // namespace duckdb

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

@@ -12,16 +12,16 @@
 
 namespace duckdb {
 
-TypeCatalogEntry::TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info)
-    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info->name), user_type(info->type) {
-	this->temporary = info->temporary;
-	this->internal = info->internal;
+TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info)
+    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type) {
+	this->temporary = info.temporary;
+	this->internal = info.internal;
 }
 
 void TypeCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	if (user_type.id() == LogicalTypeId::ENUM) {
 		// We have to serialize Enum Values

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

@@ -11,31 +11,31 @@
 
 namespace duckdb {
 
-void ViewCatalogEntry::Initialize(CreateViewInfo *info) {
-	query = std::move(info->query);
-	this->aliases = info->aliases;
-	this->types = info->types;
-	this->temporary = info->temporary;
-	this->sql = info->sql;
-	this->internal = info->internal;
+void ViewCatalogEntry::Initialize(CreateViewInfo &info) {
+	query = std::move(info.query);
+	this->aliases = info.aliases;
+	this->types = info.types;
+	this->temporary = info.temporary;
+	this->sql = info.sql;
+	this->internal = info.internal;
 }
 
-ViewCatalogEntry::ViewCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateViewInfo *info)
-    : StandardEntry(CatalogType::VIEW_ENTRY, schema, catalog, info->view_name) {
+ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateViewInfo &info)
+    : StandardEntry(CatalogType::VIEW_ENTRY, schema, catalog, info.view_name) {
 	Initialize(info);
 }
 
-unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
+unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
-	if (info->type != AlterType::ALTER_VIEW) {
+	if (info.type != AlterType::ALTER_VIEW) {
 		throw CatalogException("Can only modify view with ALTER VIEW statement");
 	}
-	auto view_info = (AlterViewInfo *)info;
-	switch (view_info->alter_view_type) {
+	auto &view_info = info.Cast<AlterViewInfo>();
+	switch (view_info.alter_view_type) {
 	case AlterViewType::RENAME_VIEW: {
-		auto rename_info = (RenameViewInfo *)view_info;
+		auto &rename_info = view_info.Cast<RenameViewInfo>();
 		auto copied_view = Copy(context);
-		copied_view->name = rename_info->new_view_name;
+		copied_view->name = rename_info.new_view_name;
 		return copied_view;
 	}
 	default:
@@ -46,7 +46,7 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 void ViewCatalogEntry::Serialize(Serializer &serializer) const {
 	D_ASSERT(!internal);
 	FieldWriter writer(serializer);
-	writer.WriteString(schema->name);
+	writer.WriteString(schema.name);
 	writer.WriteString(name);
 	writer.WriteString(sql);
 	writer.WriteSerializable(*query);
@@ -80,18 +80,18 @@ string ViewCatalogEntry::ToSQL() const {
 
 unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) const {
 	D_ASSERT(!internal);
-	auto create_info = make_uniq<CreateViewInfo>(schema, name);
-	create_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	CreateViewInfo create_info(schema, name);
+	create_info.query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 	for (idx_t i = 0; i < aliases.size(); i++) {
-		create_info->aliases.push_back(aliases[i]);
+		create_info.aliases.push_back(aliases[i]);
 	}
 	for (idx_t i = 0; i < types.size(); i++) {
-		create_info->types.push_back(types[i]);
+		create_info.types.push_back(types[i]);
 	}
-	create_info->temporary = temporary;
-	create_info->sql = sql;
+	create_info.temporary = temporary;
+	create_info.sql = sql;
 
-	return make_uniq<ViewCatalogEntry>(catalog, schema, create_info.get());
+	return make_uniq<ViewCatalogEntry>(catalog, schema, create_info);
 }
 
 } // namespace duckdb

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

@@ -4,9 +4,13 @@
 
 namespace duckdb {
 
-CatalogEntry::CatalogEntry(CatalogType type, Catalog *catalog_p, string name_p)
-    : oid(catalog_p ? catalog_p->ModifyCatalog() : 0), type(type), catalog(catalog_p), set(nullptr),
-      name(std::move(name_p)), deleted(false), temporary(false), internal(false), parent(nullptr) {
+CatalogEntry::CatalogEntry(CatalogType type, string name_p, idx_t oid)
+    : oid(oid), type(type), set(nullptr), name(std::move(name_p)), deleted(false), temporary(false), internal(false),
+      parent(nullptr) {
+}
+
+CatalogEntry::CatalogEntry(CatalogType type, Catalog &catalog, string name_p)
+    : CatalogEntry(type, std::move(name_p), catalog.ModifyCatalog()) {
 }
 
 CatalogEntry::~CatalogEntry() {
@@ -16,11 +20,11 @@ void CatalogEntry::SetAsRoot() {
 }
 
 // LCOV_EXCL_START
-unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
+unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	throw InternalException("Unsupported alter type for catalog entry!");
 }
 
-void CatalogEntry::UndoAlter(ClientContext &context, AlterInfo *info) {
+void CatalogEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 }
 
 unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
@@ -33,7 +37,24 @@ string CatalogEntry::ToSQL() const {
 // LCOV_EXCL_STOP
 
 void CatalogEntry::Verify(Catalog &catalog_p) {
-	D_ASSERT(&catalog_p == catalog);
 }
 
+Catalog &CatalogEntry::ParentCatalog() {
+	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
+}
+
+SchemaCatalogEntry &CatalogEntry::ParentSchema() {
+	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
+}
+
+InCatalogEntry::InCatalogEntry(CatalogType type, Catalog &catalog, string name)
+    : CatalogEntry(type, catalog, std::move(name)), catalog(catalog) {
+}
+
+InCatalogEntry::~InCatalogEntry() {
+}
+
+void InCatalogEntry::Verify(Catalog &catalog_p) {
+	D_ASSERT(&catalog_p == &catalog);
+}
 } // namespace duckdb

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

@@ -131,10 +131,10 @@ void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_sc
 		throw CatalogException("SET schema can set only 1 schema. This has %d", new_paths.size());
 	}
 	for (auto &path : new_paths) {
-		if (!Catalog::GetSchema(context, path.catalog, path.schema, true)) {
+		if (!Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL)) {
 			if (path.catalog.empty()) {
 				// only schema supplied - check if this is a database instead
-				auto schema = Catalog::GetSchema(context, path.schema, DEFAULT_SCHEMA, true);
+				auto schema = Catalog::GetSchema(context, path.schema, DEFAULT_SCHEMA, OnEntryNotFound::RETURN_NULL);
 				if (schema) {
 					path.catalog = std::move(path.schema);
 					path.schema = schema->name;