duckdb 0.7.2-dev1901.0 → 0.7.2-dev2144.0

package/src/duckdb/src/optimizer/join_order/join_relation_set.cpp

@@ -18,16 +18,16 @@ string JoinRelationSet::ToString() const {
 // LCOV_EXCL_STOP
 
 //! Returns true if sub is a subset of super
-bool JoinRelationSet::IsSubset(JoinRelationSet *super, JoinRelationSet *sub) {
-	D_ASSERT(sub->count > 0);
-	if (sub->count > super->count) {
+bool JoinRelationSet::IsSubset(JoinRelationSet &super, JoinRelationSet &sub) {
+	D_ASSERT(sub.count > 0);
+	if (sub.count > super.count) {
 		return false;
 	}
 	idx_t j = 0;
-	for (idx_t i = 0; i < super->count; i++) {
-		if (sub->relations[j] == super->relations[i]) {
+	for (idx_t i = 0; i < super.count; i++) {
+		if (sub.relations[j] == super.relations[i]) {
 			j++;
-			if (j == sub->count) {
+			if (j == sub.count) {
 				return true;
 			}
 		}
@@ -35,29 +35,29 @@ bool JoinRelationSet::IsSubset(JoinRelationSet *super, JoinRelationSet *sub) {
 	return false;
 }
 
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count) {
+JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count) {
 	// now look it up in the tree
-	JoinRelationTreeNode *info = &root;
+	reference<JoinRelationTreeNode> info(root);
 	for (idx_t i = 0; i < count; i++) {
-		auto entry = info->children.find(relations[i]);
-		if (entry == info->children.end()) {
+		auto entry = info.get().children.find(relations[i]);
+		if (entry == info.get().children.end()) {
 			// node not found, create it
-			auto insert_it = info->children.insert(make_pair(relations[i], make_uniq<JoinRelationTreeNode>()));
+			auto insert_it = info.get().children.insert(make_pair(relations[i], make_uniq<JoinRelationTreeNode>()));
 			entry = insert_it.first;
 		}
 		// move to the next node
-		info = entry->second.get();
+		info = *entry->second;
 	}
 	// now check if the JoinRelationSet has already been created
-	if (!info->relation) {
+	if (!info.get().relation) {
 		// if it hasn't we need to create it
-		info->relation = make_uniq<JoinRelationSet>(std::move(relations), count);
+		info.get().relation = make_uniq<JoinRelationSet>(std::move(relations), count);
 	}
-	return info->relation.get();
+	return *info.get().relation;
 }
 
 //! Create or get a JoinRelationSet from a single node with the given index
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(idx_t index) {
+JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
 	// create a sorted vector of the relations
 	auto relations = unique_ptr<idx_t[]>(new idx_t[1]);
 	relations[0] = index;
@@ -65,7 +65,7 @@ JoinRelationSet *JoinRelationSetManager::GetJoinRelation(idx_t index) {
 	return GetJoinRelation(std::move(relations), count);
 }
 
-JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
+JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
 	// create a sorted vector of the relations
 	unique_ptr<idx_t[]> relations = bindings.empty() ? nullptr : unique_ptr<idx_t[]>(new idx_t[bindings.size()]);
 	idx_t count = 0;
@@ -76,36 +76,36 @@ JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &b
 	return GetJoinRelation(std::move(relations), count);
 }
 
-JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelationSet *right) {
-	auto relations = unique_ptr<idx_t[]>(new idx_t[left->count + right->count]);
+JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelationSet &right) {
+	auto relations = unique_ptr<idx_t[]>(new idx_t[left.count + right.count]);
 	idx_t count = 0;
 	// move through the left and right relations, eliminating duplicates
 	idx_t i = 0, j = 0;
 	while (true) {
-		if (i == left->count) {
+		if (i == left.count) {
 			// exhausted left relation, add remaining of right relation
-			for (; j < right->count; j++) {
-				relations[count++] = right->relations[j];
+			for (; j < right.count; j++) {
+				relations[count++] = right.relations[j];
 			}
 			break;
-		} else if (j == right->count) {
+		} else if (j == right.count) {
 			// exhausted right relation, add remaining of left
-			for (; i < left->count; i++) {
-				relations[count++] = left->relations[i];
+			for (; i < left.count; i++) {
+				relations[count++] = left.relations[i];
 			}
 			break;
-		} else if (left->relations[i] == right->relations[j]) {
+		} else if (left.relations[i] == right.relations[j]) {
 			// equivalent, add only one of the two pairs
-			relations[count++] = left->relations[i];
+			relations[count++] = left.relations[i];
 			i++;
 			j++;
-		} else if (left->relations[i] < right->relations[j]) {
+		} else if (left.relations[i] < right.relations[j]) {
 			// left is smaller, progress left and add it to the set
-			relations[count++] = left->relations[i];
+			relations[count++] = left.relations[i];
 			i++;
 		} else {
 			// right is smaller, progress right and add it to the set
-			relations[count++] = right->relations[j];
+			relations[count++] = right.relations[j];
 			j++;
 		}
 	}

package/src/duckdb/src/optimizer/join_order/query_graph.cpp

@@ -18,7 +18,7 @@ static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
 	}
 	source += "]";
 	for (auto &entry : info->neighbors) {
-		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor->ToString().c_str());
+		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor.ToString().c_str());
 	}
 	for (auto &entry : info->children) {
 		vector<idx_t> new_prefix = prefix;
@@ -37,59 +37,58 @@ void QueryGraph::Print() {
 }
 // LCOV_EXCL_STOP
 
-QueryEdge *QueryGraph::GetQueryEdge(JoinRelationSet *left) {
-	D_ASSERT(left && left->count > 0);
+QueryEdge &QueryGraph::GetQueryEdge(JoinRelationSet &left) {
+	D_ASSERT(left.count > 0);
 	// find the EdgeInfo corresponding to the left set
-	QueryEdge *info = &root;
-	for (idx_t i = 0; i < left->count; i++) {
-		auto entry = info->children.find(left->relations[i]);
-		if (entry == info->children.end()) {
+	reference<QueryEdge> info(root);
+	for (idx_t i = 0; i < left.count; i++) {
+		auto entry = info.get().children.find(left.relations[i]);
+		if (entry == info.get().children.end()) {
 			// node not found, create it
-			auto insert_it = info->children.insert(make_pair(left->relations[i], make_uniq<QueryEdge>()));
+			auto insert_it = info.get().children.insert(make_pair(left.relations[i], make_uniq<QueryEdge>()));
 			entry = insert_it.first;
 		}
 		// move to the next node
-		info = entry->second.get();
+		info = *entry->second;
 	}
 	return info;
 }
 
-void QueryGraph::CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *filter_info) {
-	D_ASSERT(left && right && left->count > 0 && right->count > 0);
+void QueryGraph::CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> filter_info) {
+	D_ASSERT(left.count > 0 && right.count > 0);
 	// find the EdgeInfo corresponding to the left set
-	auto info = GetQueryEdge(left);
+	auto &info = GetQueryEdge(left);
 	// now insert the edge to the right relation, if it does not exist
-	for (idx_t i = 0; i < info->neighbors.size(); i++) {
-		if (info->neighbors[i]->neighbor == right) {
+	for (idx_t i = 0; i < info.neighbors.size(); i++) {
+		if (&info.neighbors[i]->neighbor == &right) {
 			if (filter_info) {
 				// neighbor already exists just add the filter, if we have any
-				info->neighbors[i]->filters.push_back(filter_info);
+				info.neighbors[i]->filters.push_back(*filter_info);
 			}
 			return;
 		}
 	}
 	// neighbor does not exist, create it
-	auto n = make_uniq<NeighborInfo>();
+	auto n = make_uniq<NeighborInfo>(right);
 	if (filter_info) {
-		n->filters.push_back(filter_info);
+		n->filters.push_back(*filter_info);
 	}
-	n->neighbor = right;
-	info->neighbors.push_back(std::move(n));
+	info.neighbors.push_back(std::move(n));
 }
 
-void QueryGraph::EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback) {
-	for (idx_t j = 0; j < node->count; j++) {
-		QueryEdge *info = &root;
-		for (idx_t i = j; i < node->count; i++) {
-			auto entry = info->children.find(node->relations[i]);
-			if (entry == info->children.end()) {
+void QueryGraph::EnumerateNeighbors(JoinRelationSet &node, const std::function<bool(NeighborInfo &)> &callback) {
+	for (idx_t j = 0; j < node.count; j++) {
+		reference<QueryEdge> info = root;
+		for (idx_t i = j; i < node.count; i++) {
+			auto entry = info.get().children.find(node.relations[i]);
+			if (entry == info.get().children.end()) {
 				// node not found
 				break;
 			}
 			// check if any subset of the other set is in this sets neighbors
-			info = entry->second.get();
-			for (auto &neighbor : info->neighbors) {
-				if (callback(neighbor.get())) {
+			info = *entry->second;
+			for (auto &neighbor : info.get().neighbors) {
+				if (callback(*neighbor)) {
 					return;
 				}
 			}
@@ -98,16 +97,16 @@ void QueryGraph::EnumerateNeighbors(JoinRelationSet *node, const std::function<b
 }
 
 //! Returns true if a JoinRelationSet is banned by the list of exclusion_set, false otherwise
-static bool JoinRelationSetIsExcluded(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	return exclusion_set.find(node->relations[0]) != exclusion_set.end();
+static bool JoinRelationSetIsExcluded(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) {
+	return exclusion_set.find(node.relations[0]) != exclusion_set.end();
 }
 
-vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
+vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) {
 	unordered_set<idx_t> result;
-	EnumerateNeighbors(node, [&](NeighborInfo *info) -> bool {
-		if (!JoinRelationSetIsExcluded(info->neighbor, exclusion_set)) {
+	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
+		if (!JoinRelationSetIsExcluded(info.neighbor, exclusion_set)) {
 			// add the smallest node of the neighbor to the set
-			result.insert(info->neighbor->relations[0]);
+			result.insert(info.neighbor.relations[0]);
 		}
 		return false;
 	});
@@ -116,10 +115,10 @@ vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet *node, unordered_set<idx_
 	return neighbors;
 }
 
-vector<NeighborInfo *> QueryGraph::GetConnections(JoinRelationSet *node, JoinRelationSet *other) {
-	vector<NeighborInfo *> connections;
-	EnumerateNeighbors(node, [&](NeighborInfo *info) -> bool {
-		if (JoinRelationSet::IsSubset(other, info->neighbor)) {
+vector<reference<NeighborInfo>> QueryGraph::GetConnections(JoinRelationSet &node, JoinRelationSet &other) {
+	vector<reference<NeighborInfo>> connections;
+	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
+		if (JoinRelationSet::IsSubset(other, info.neighbor)) {
 			connections.push_back(info);
 		}
 		return false;

package/src/duckdb/src/parallel/executor.cpp

@@ -303,7 +303,7 @@ void Executor::InitializeInternal(PhysicalOperator *plan) {
 		// build and ready the pipelines
 		PipelineBuildState state;
 		auto root_pipeline = make_shared<MetaPipeline>(*this, state, nullptr);
-		root_pipeline->Build(physical_plan);
+		root_pipeline->Build(*physical_plan);
 		root_pipeline->Ready();
 
 		// ready recursive cte pipelines too

package/src/duckdb/src/parallel/meta_pipeline.cpp

@@ -67,11 +67,11 @@ void MetaPipeline::AssignNextBatchIndex(Pipeline *pipeline) {
 	pipeline->base_batch_index = next_batch_index++ * PipelineBuildState::BATCH_INCREMENT;
 }
 
-void MetaPipeline::Build(PhysicalOperator *op) {
+void MetaPipeline::Build(PhysicalOperator &op) {
 	D_ASSERT(pipelines.size() == 1);
 	D_ASSERT(children.empty());
 	D_ASSERT(final_pipelines.empty());
-	op->BuildPipelines(*pipelines.back(), *this);
+	op.BuildPipelines(*pipelines.back(), *this);
 }
 
 void MetaPipeline::Ready() {

package/src/duckdb/src/parser/transform/helpers/transform_cte.cpp

@@ -68,7 +68,7 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause,
 		if (cte->cterecursive || de_with_clause->recursive) {
 			info->query = TransformRecursiveCTE(cte, *info);
 		} else {
-			Transformer cte_transformer(this);
+			Transformer cte_transformer(*this);
 			info->query = cte_transformer.TransformSelect(cte->ctequery);
 		}
 		D_ASSERT(info->query);

package/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root) {
-	Transformer subquery_transformer(this);
+	Transformer subquery_transformer(*this);
 	auto subquery = subquery_transformer.TransformSelect(root->subquery);
 	if (!subquery) {
 		return nullptr;

package/src/duckdb/src/parser/transformer.cpp

@@ -26,8 +26,8 @@ Transformer::Transformer(ParserOptions &options)
     : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
-Transformer::Transformer(Transformer *parent)
-    : parent(parent), options(parent->options), stack_depth(DConstants::INVALID_INDEX) {
+Transformer::Transformer(Transformer &parent)
+    : parent(&parent), options(parent.options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::~Transformer() {
@@ -59,17 +59,14 @@ void Transformer::InitializeStackCheck() {
 }
 
 StackChecker Transformer::StackCheck(idx_t extra_stack) {
-	auto node = this;
-	while (node->parent) {
-		node = node->parent;
-	}
-	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
-	if (node->stack_depth + extra_stack >= options.max_expression_depth) {
+	auto &root = RootTransformer();
+	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
+	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
 		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
 		                      "increase the maximum expression depth.",
 		                      options.max_expression_depth);
 	}
-	return StackChecker(*node, extra_stack);
+	return StackChecker(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
@@ -82,6 +79,50 @@ unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNo
 	return result;
 }
 
+Transformer &Transformer::RootTransformer() {
+	reference<Transformer> node = *this;
+	while (node.get().parent) {
+		node = *node.get().parent;
+	}
+	return node.get();
+}
+
+const Transformer &Transformer::RootTransformer() const {
+	reference<const Transformer> node = *this;
+	while (node.get().parent) {
+		node = *node.get().parent;
+	}
+	return node.get();
+}
+
+idx_t Transformer::ParamCount() const {
+	auto &root = RootTransformer();
+	return root.prepared_statement_parameter_index;
+}
+
+void Transformer::SetParamCount(idx_t new_count) {
+	auto &root = RootTransformer();
+	root.prepared_statement_parameter_index = new_count;
+}
+void Transformer::SetNamedParam(const string &name, int32_t index) {
+	auto &root = RootTransformer();
+	D_ASSERT(!root.named_param_map.count(name));
+	root.named_param_map[name] = index;
+}
+bool Transformer::GetNamedParam(const string &name, int32_t &index) {
+	auto &root = RootTransformer();
+	auto entry = root.named_param_map.find(name);
+	if (entry == root.named_param_map.end()) {
+		return false;
+	}
+	index = entry->second;
+	return true;
+}
+bool Transformer::HasNamedParameters() const {
+	auto &root = RootTransformer();
+	return !root.named_param_map.empty();
+}
+
 unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode *stmt) {
 	switch (stmt->type) {
 	case duckdb_libpgquery::T_PGRawStmt: {

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

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/common/bind_helpers.hpp"
+#include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
 #include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
@@ -76,7 +77,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
-	bool allow_overwrite = false;
+	bool overwrite_or_ignore = false;
+	FilenamePattern filename_pattern;
 	bool user_set_use_tmp_file = false;
 	bool per_thread_output = false;
 	vector<idx_t> partition_cols;
@@ -92,11 +94,19 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 			user_set_use_tmp_file = true;
 			continue;
 		}
-		if (loption == "allow_overwrite") {
-			allow_overwrite =
+		if (loption == "overwrite_or_ignore") {
+			overwrite_or_ignore =
 			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
+		if (loption == "filename_pattern") {
+			if (option.second.empty()) {
+				throw IOException("FILENAME_PATTERN cannot be empty");
+			}
+			filename_pattern.SetFilenamePattern(
+			    option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>());
+			continue;
+		}
 
 		if (loption == "per_thread_output") {
 			per_thread_output =
@@ -133,8 +143,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto copy = make_uniq<LogicalCopyToFile>(copy_function->function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
 	copy->use_tmp_file = use_tmp_file;
-	copy->allow_overwrite = allow_overwrite;
-	copy->per_thread_output = per_thread_output;
+	copy->overwrite_or_ignore = overwrite_or_ignore;
+	copy->filename_pattern = filename_pattern;
 	copy->per_thread_output = per_thread_output;
 	copy->partition_output = !partition_cols.empty();
 	copy->partition_columns = std::move(partition_cols);

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

@@ -66,7 +66,7 @@ void Binder::BindSchemaOrCatalog(string &catalog, string &schema) {
 	BindSchemaOrCatalog(context, catalog, schema);
 }
 
-SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
+SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
 	BindSchemaOrCatalog(info.catalog, info.schema);
 	if (IsInvalidCatalog(info.catalog) && info.temporary) {
 		info.catalog = TEMP_CATALOG;
@@ -101,12 +101,12 @@ SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
 	if (!info.temporary) {
 		properties.modified_databases.insert(schema_obj->catalog->GetName());
 	}
-	return schema_obj;
+	return *schema_obj;
 }
 
-SchemaCatalogEntry *Binder::BindCreateSchema(CreateInfo &info) {
-	auto schema = BindSchema(info);
-	if (schema->catalog->IsSystemCatalog()) {
+SchemaCatalogEntry &Binder::BindCreateSchema(CreateInfo &info) {
+	auto &schema = BindSchema(info);
+	if (schema.catalog->IsSystemCatalog()) {
 		throw BinderException("Cannot create entry in system catalog");
 	}
 	return schema;
@@ -159,7 +159,7 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
 }
 
-SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
+SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = (CreateMacroInfo &)info;
 	auto &scalar_function = (ScalarMacroFunction &)*base.function;
 
@@ -477,25 +477,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	case CatalogType::VIEW_ENTRY: {
 		auto &base = (CreateViewInfo &)*stmt.info;
 		// bind the schema
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), schema);
+		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::SEQUENCE_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		result.plan =
-		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), schema);
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
+		auto &schema = BindCreateSchema(*stmt.info);
+		result.plan =
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::MACRO_ENTRY: {
-		auto schema = BindCreateFunctionInfo(*stmt.info);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
+		auto &schema = BindCreateFunctionInfo(*stmt.info);
+		result.plan =
+		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
 		break;
 	}
 	case CatalogType::INDEX_ENTRY: {
@@ -589,9 +591,9 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		break;
 	}
 	case CatalogType::TYPE_ENTRY: {
-		auto schema = BindCreateSchema(*stmt.info);
+		auto &schema = BindCreateSchema(*stmt.info);
 		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
-		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), schema);
+		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
 			auto &select_stmt = create_type_info.query->Cast<SelectStatement>();
@@ -634,7 +636,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// 2: create a type alias with a custom type.
 			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
 			// We set b to be an alias for the underlying type of a
-			auto inner_type = Catalog::GetType(context, schema->catalog->GetName(), schema->name,
+			auto inner_type = Catalog::GetType(context, schema.catalog->GetName(), schema.name,
 			                                   UserType::GetTypeName(create_type_info.type));
 			// clear to nullptr, we don't need this
 			LogicalType::SetCatalog(inner_type, nullptr);

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

@@ -251,10 +251,10 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 		}
 	}
 }
-unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema) {
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
 	auto &base = (CreateTableInfo &)*info;
 	auto result = make_uniq<BoundCreateTableInfo>(std::move(info));
-	result->schema = schema;
+	result->schema = &schema;
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
@@ -300,14 +300,14 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			result->dependencies.AddDependency(*type_dependency);
 		}
 	}
-	result->dependencies.VerifyDependencies(*schema->catalog, result->Base().table);
+	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 &schema = BindCreateSchema(base);
 	return BindCreateTableInfo(std::move(info), schema);
 }