duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/constraints/list.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_binder/check_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
@@ -24,7 +25,7 @@
 namespace duckdb {
 
 static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 	for (auto &col : base.columns.Logical()) {
 		if (!col.Generated()) {
 			continue;
@@ -34,12 +35,12 @@ static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
 }
 
 static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, const unique_ptr<Constraint> &cond) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
-	auto bound_constraint = make_unique<BoundCheckConstraint>();
+	auto bound_constraint = make_uniq<BoundCheckConstraint>();
 	// check constraint: bind the expression
 	CheckBinder check_binder(binder, binder.context, base.table, base.columns, bound_constraint->bound_columns);
-	auto &check = (CheckConstraint &)*cond;
+	auto &check = cond->Cast<CheckConstraint>();
 	// create a copy of the unbound expression because the binding destroys the constraint
 	auto unbound_expression = check.expression->Copy();
 	// now bind the constraint and create a new BoundCheckConstraint
@@ -50,7 +51,7 @@ static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, cons
 }
 
 static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
 	bool has_primary_key = false;
 	logical_index_set_t not_null_columns;
@@ -63,14 +64,14 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			break;
 		}
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = (NotNullConstraint &)*cond;
+			auto &not_null = cond->Cast<NotNullConstraint>();
 			auto &col = base.columns.GetColumn(LogicalIndex(not_null.index));
-			info.bound_constraints.push_back(make_unique<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
+			info.bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
 			not_null_columns.insert(not_null.index);
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = (UniqueConstraint &)*cond;
+			auto &unique = cond->Cast<UniqueConstraint>();
 			// have to resolve columns of the unique constraint
 			vector<LogicalIndex> keys;
 			logical_index_set_t key_set;
@@ -109,23 +110,29 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				primary_keys = keys;
 			}
 			info.bound_constraints.push_back(
-			    make_unique<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.is_primary_key));
+			    make_uniq<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.is_primary_key));
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
-			auto &fk = (ForeignKeyConstraint &)*cond;
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
 			D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
 			physical_index_set_t fk_key_set, pk_key_set;
 			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
+				if (pk_key_set.find(fk.info.pk_keys[i]) != pk_key_set.end()) {
+					throw BinderException("Duplicate primary key referenced in FOREIGN KEY constraint");
+				}
 				pk_key_set.insert(fk.info.pk_keys[i]);
 			}
 			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
+				if (fk_key_set.find(fk.info.fk_keys[i]) != fk_key_set.end()) {
+					throw BinderException("Duplicate key specified in FOREIGN KEY constraint");
+				}
 				fk_key_set.insert(fk.info.fk_keys[i]);
 			}
 			info.bound_constraints.push_back(
-			    make_unique<BoundForeignKeyConstraint>(fk.info, std::move(pk_key_set), std::move(fk_key_set)));
+			    make_uniq<BoundForeignKeyConstraint>(fk.info, std::move(pk_key_set), std::move(fk_key_set)));
 			break;
 		}
 		default:
@@ -140,14 +147,14 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				continue;
 			}
 			auto physical_index = base.columns.LogicalToPhysical(column_index);
-			base.constraints.push_back(make_unique<NotNullConstraint>(column_index));
-			info.bound_constraints.push_back(make_unique<BoundNotNullConstraint>(physical_index));
+			base.constraints.push_back(make_uniq<NotNullConstraint>(column_index));
+			info.bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(physical_index));
 		}
 	}
 }
 
 void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
 	vector<string> names;
 	vector<LogicalType> types;
@@ -213,7 +220,7 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 			bound_default = default_binder.Bind(default_copy);
 		} else {
 			// no default value specified: push a default value of constant null
-			bound_default = make_unique<BoundConstantExpression>(Value(column.Type()));
+			bound_default = make_uniq<BoundConstantExpression>(Value(column.Type()));
 		}
 		bound_defaults.push_back(std::move(bound_default));
 	}
@@ -221,7 +228,7 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 
 static void ExtractExpressionDependencies(Expression &expr, DependencyList &dependencies) {
 	if (expr.type == ExpressionType::BOUND_FUNCTION) {
-		auto &function = (BoundFunctionExpression &)expr;
+		auto &function = expr.Cast<BoundFunctionExpression>();
 		if (function.function.dependency) {
 			function.function.dependency(function, dependencies);
 		}
@@ -238,15 +245,14 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 	}
 	for (auto &constraint : info.bound_constraints) {
 		if (constraint->type == ConstraintType::CHECK) {
-			auto &bound_check = (BoundCheckConstraint &)*constraint;
+			auto &bound_check = constraint->Cast<BoundCheckConstraint>();
 			ExtractExpressionDependencies(*bound_check.expression, info.dependencies);
 		}
 	}
 }
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema) {
-	auto &base = (CreateTableInfo &)*info;
-	auto result = make_unique<BoundCreateTableInfo>(std::move(info));
-	result->schema = schema;
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
+	auto &base = info->Cast<CreateTableInfo>();
+	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
@@ -284,29 +290,30 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		if (column.Type().id() == LogicalTypeId::VARCHAR) {
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
-		BindLogicalType(context, column.TypeMutable(), result->schema->catalog);
+		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
 		// We add a catalog dependency
-		auto type_dependency = LogicalType::GetCatalog(column.Type());
+		auto type_dependency = EnumType::GetCatalog(column.Type());
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(type_dependency);
+			result->dependencies.AddDependency(*type_dependency);
 		}
 	}
+	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }
 
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
-	auto &base = (CreateTableInfo &)*info;
-	auto schema = BindCreateSchema(base);
+	auto &base = info->Cast<CreateTableInfo>();
+	auto &schema = BindCreateSchema(base);
 	return BindCreateTableInfo(std::move(info), schema);
 }
 
-vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
+vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry &table, CreateIndexInfo &info) {
+	auto index_binder = IndexBinder(*this, this->context, &table, &info);
 	vector<unique_ptr<Expression>> expressions;
-
-	auto index_binder = IndexBinder(*this, this->context, table, info);
-	for (auto &expr : info->expressions) {
+	expressions.reserve(info.expressions.size());
+	for (auto &expr : info.expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}
 

package/src/duckdb/src/planner/binder/statement/bind_delete.cpp

@@ -20,16 +20,16 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	if (bound_table->type != TableReferenceType::BASE_TABLE) {
 		throw BinderException("Can only delete from base table!");
 	}
-	auto &table_binding = (BoundBaseTableRef &)*bound_table;
-	auto table = table_binding.table;
+	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+	auto &table = table_binding.table;
 
 	auto root = CreatePlan(*bound_table);
-	auto &get = (LogicalGet &)*root;
+	auto &get = root->Cast<LogicalGet>();
 	D_ASSERT(root->type == LogicalOperatorType::LOGICAL_GET);
 
-	if (!table->temporary) {
+	if (!table.temporary) {
 		// delete from persistent table: not read only!
-		properties.modified_databases.insert(table->catalog->GetName());
+		properties.modified_databases.insert(table.catalog.GetName());
 	}
 
 	// Add CTEs as bindable
@@ -62,17 +62,17 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		WhereBinder binder(*this, context);
 		condition = binder.Bind(stmt.condition);
 
-		PlanSubqueries(&condition, &root);
-		auto filter = make_unique<LogicalFilter>(std::move(condition));
+		PlanSubqueries(condition, root);
+		auto filter = make_uniq<LogicalFilter>(std::move(condition));
 		filter->AddChild(std::move(root));
 		root = std::move(filter);
 	}
 	// create the delete node
-	auto del = make_unique<LogicalDelete>(table, GenerateTableIndex());
+	auto del = make_uniq<LogicalDelete>(table, GenerateTableIndex());
 	del->AddChild(std::move(root));
 
 	// set up the delete expression
-	del->expressions.push_back(make_unique<BoundColumnRefExpression>(
+	del->expressions.push_back(make_uniq<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
 	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
@@ -83,7 +83,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		del->table_index = update_table_index;
 
 		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(del_as_logicaloperator), std::move(result));
 	}
 	result.plan = std::move(del);

package/src/duckdb/src/planner/binder/statement/bind_detach.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 BoundStatement Binder::Bind(DetachStatement &stmt) {
 	BoundStatement result;
 
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	properties.allow_stream_result = false;

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -34,17 +34,17 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::TABLE_ENTRY:
 	case CatalogType::TYPE_ENTRY: {
 		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-		auto entry = (StandardEntry *)Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema,
-		                                                stmt.info->name, true);
+		auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name,
+		                               OnEntryNotFound::RETURN_NULL);
 		if (!entry) {
 			break;
 		}
-		stmt.info->catalog = entry->catalog->GetName();
+		stmt.info->catalog = entry->ParentCatalog().GetName();
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode
 			properties.modified_databases.insert(stmt.info->catalog);
 		}
-		stmt.info->schema = entry->schema->name;
+		stmt.info->schema = entry->ParentSchema().name;
 		break;
 	}
 	case CatalogType::DATABASE_ENTRY: {
@@ -75,7 +75,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, std::move(stmt.info));
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, std::move(stmt.info));
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	properties.allow_stream_result = false;

package/src/duckdb/src/planner/binder/statement/bind_execute.cpp

@@ -56,11 +56,11 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 
 	prepared->Bind(std::move(bind_values));
 	if (rebound_plan) {
-		auto execute_plan = make_unique<LogicalExecute>(std::move(prepared));
+		auto execute_plan = make_uniq<LogicalExecute>(std::move(prepared));
 		execute_plan->children.push_back(std::move(rebound_plan));
 		result.plan = std::move(execute_plan);
 	} else {
-		result.plan = make_unique<LogicalExecute>(std::move(prepared));
+		result.plan = make_uniq<LogicalExecute>(std::move(prepared));
 	}
 	return result;
 }

package/src/duckdb/src/planner/binder/statement/bind_explain.cpp

@@ -11,7 +11,7 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) {
 	auto plan = Bind(*stmt.stmt);
 	// get the unoptimized logical plan, and create the explain statement
 	auto logical_plan_unopt = plan.plan->ToString();
-	auto explain = make_unique<LogicalExplain>(std::move(plan.plan), stmt.explain_type);
+	auto explain = make_uniq<LogicalExplain>(std::move(plan.plan), stmt.explain_type);
 	explain->logical_plan_unopt = logical_plan_unopt;
 
 	result.plan = std::move(explain);

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -41,25 +41,25 @@ string SanitizeExportIdentifier(const string &str) {
 	return result;
 }
 
-bool IsExistMainKeyTable(string &table_name, vector<TableCatalogEntry *> &unordered) {
+bool IsExistMainKeyTable(string &table_name, vector<reference<TableCatalogEntry>> &unordered) {
 	for (idx_t i = 0; i < unordered.size(); i++) {
-		if (unordered[i]->name == table_name) {
+		if (unordered[i].get().name == table_name) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatalogEntry *> &unordered,
+void ScanForeignKeyTable(vector<reference<TableCatalogEntry>> &ordered, vector<reference<TableCatalogEntry>> &unordered,
                          bool move_only_pk_table) {
 	for (auto i = unordered.begin(); i != unordered.end();) {
 		auto table_entry = *i;
 		bool move_to_ordered = true;
-		auto &constraints = table_entry->GetConstraints();
+		auto &constraints = table_entry.get().GetConstraints();
 		for (idx_t j = 0; j < constraints.size(); j++) {
 			auto &cond = constraints[j];
 			if (cond->type == ConstraintType::FOREIGN_KEY) {
-				auto &fk = (ForeignKeyConstraint &)*cond;
+				auto &fk = cond->Cast<ForeignKeyConstraint>();
 				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
 				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
 				     IsExistMainKeyTable(fk.info.table, unordered))) {
@@ -77,9 +77,9 @@ void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatal
 	}
 }
 
-void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
-	vector<TableCatalogEntry *> ordered;
-	vector<TableCatalogEntry *> unordered = tables;
+void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables) {
+	vector<reference<TableCatalogEntry>> ordered;
+	vector<reference<TableCatalogEntry>> unordered = tables;
 	ScanForeignKeyTable(ordered, unordered, true);
 	while (!unordered.empty()) {
 		ScanForeignKeyTable(ordered, unordered, false);
@@ -87,12 +87,12 @@ void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
 	tables = ordered;
 }
 
-string CreateFileName(const string &id_suffix, TableCatalogEntry *table, const string &extension) {
-	auto name = SanitizeExportIdentifier(table->name);
-	if (table->schema->name == DEFAULT_SCHEMA) {
+string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const string &extension) {
+	auto name = SanitizeExportIdentifier(table.name);
+	if (table.schema.name == DEFAULT_SCHEMA) {
 		return StringUtil::Format("%s%s.%s", name, id_suffix, extension);
 	}
-	auto schema = SanitizeExportIdentifier(table->schema->name);
+	auto schema = SanitizeExportIdentifier(table.schema.name);
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
@@ -107,20 +107,20 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	result.names = {"Success"};
 
 	// lookup the format in the catalog
-	auto copy_function =
+	auto &copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_to_bind && !copy_function->function.plan) {
+	if (!copy_function.function.copy_to_bind && !copy_function.function.plan) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 
 	// gather a list of all the tables
 	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
-	vector<TableCatalogEntry *> tables;
+	vector<reference<TableCatalogEntry>> tables;
 	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->type == CatalogType::TABLE_ENTRY) {
-				tables.push_back((TableCatalogEntry *)entry);
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.type == CatalogType::TABLE_ENTRY) {
+				tables.push_back(entry.Cast<TableCatalogEntry>());
 			}
 		});
 	}
@@ -135,18 +135,18 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	BoundExportData exported_tables;
 
 	unordered_set<string> table_name_index;
-	for (auto &table : tables) {
-		auto info = make_unique<CopyInfo>();
+	for (auto &t : tables) {
+		auto &table = t.get();
+		auto info = make_uniq<CopyInfo>();
 		// we copy the options supplied to the EXPORT
 		info->format = stmt.info->format;
 		info->options = stmt.info->options;
 		// set up the file name for the COPY TO
 
-		auto exported_data = ExportedTableData();
 		idx_t id = 0;
 		while (true) {
 			string id_suffix = id == 0 ? string() : "_" + to_string(id);
-			auto name = CreateFileName(id_suffix, table, copy_function->function.extension);
+			auto name = CreateFileName(id_suffix, table, copy_function.function.extension);
 			auto directory = stmt.info->file_path;
 			auto full_path = fs.JoinPath(directory, name);
 			info->file_path = full_path;
@@ -159,23 +159,22 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		}
 		info->is_from = false;
 		info->catalog = catalog;
-		info->schema = table->schema->name;
-		info->table = table->name;
+		info->schema = table.schema.name;
+		info->table = table.name;
 
 		// We can not export generated columns
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			info->select_list.push_back(col.GetName());
 		}
 
+		ExportedTableData exported_data;
 		exported_data.database_name = catalog;
 		exported_data.table_name = info->table;
 		exported_data.schema_name = info->schema;
 
 		exported_data.file_path = info->file_path;
 
-		ExportedTableInfo table_info;
-		table_info.entry = table;
-		table_info.table_data = exported_data;
+		ExportedTableInfo table_info(table, std::move(exported_data));
 		exported_tables.data.push_back(table_info);
 		id++;
 
@@ -188,8 +187,8 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
 			auto copy_union =
-			    make_unique<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
-			                                     std::move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
+			    make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
+			                                   std::move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
 			child_operator = std::move(copy_union);
 		} else {
 			child_operator = std::move(bound_statement.plan);
@@ -203,7 +202,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	}
 
 	// create the export node
-	auto export_node = make_unique<LogicalExport>(copy_function->function, std::move(stmt.info), exported_tables);
+	auto export_node = make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), exported_tables);
 
 	if (child_operator) {
 		export_node->children.push_back(std::move(child_operator));

package/src/duckdb/src/planner/binder/statement/bind_extension.cpp

@@ -19,7 +19,7 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 	// create the plan as a scan of the given table function
 	result.plan = BindTableFunction(parse_result.function, std::move(parse_result.parameters));
 	D_ASSERT(result.plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = (LogicalGet &)*result.plan;
+	auto &get = result.plan->Cast<LogicalGet>();
 	result.names = get.names;
 	result.types = get.returned_types;
 	get.column_ids.clear();