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

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);
 }
 
@@ -115,12 +115,12 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	// 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);
+				tables.push_back(entry->Cast<TableCatalogEntry>());
 			}
 		});
 	}
@@ -135,14 +135,14 @@ 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);
@@ -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();

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

@@ -42,7 +42,7 @@ unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &col
 	if (column.DefaultValue()) {
 		return column.DefaultValue()->Copy();
 	} else {
-		return make_unique<ConstantExpression>(Value(column.Type()));
+		return make_uniq<ConstantExpression>(Value(column.Type()));
 	}
 }
 
@@ -54,12 +54,12 @@ void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDe
 void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &table_name) {
 	// To avoid ambiguity with 'excluded', we explicitly qualify all column references
 	if (expr->type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)*expr;
+		auto &column_ref = expr->Cast<ColumnRefExpression>();
 		if (column_ref.IsQualified()) {
 			return;
 		}
 		auto column_name = column_ref.GetColumnName();
-		expr = make_unique<ColumnRefExpression>(column_name, table_name);
+		expr = make_uniq<ColumnRefExpression>(column_name, table_name);
 	}
 	ParsedExpressionIterator::EnumerateChildren(
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyColumnReferences(child, table_name); });
@@ -68,7 +68,7 @@ void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &t
 // Replace binding.table_index with 'dest' if it's 'source'
 void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_columnref = (BoundColumnRefExpression &)expr;
+		auto &bound_columnref = expr.Cast<BoundColumnRefExpression>();
 		if (bound_columnref.binding.table_index == source) {
 			bound_columnref.binding.table_index = dest;
 		}
@@ -142,7 +142,7 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 }
 
 unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, InsertStatement &insert) {
-	auto set_info = make_unique<UpdateSetInfo>();
+	auto set_info = make_uniq<UpdateSetInfo>();
 
 	auto &columns = set_info->columns;
 	// Figure out which columns are indexed on
@@ -178,7 +178,7 @@ unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, Inse
 
 	// Create 'excluded' qualified column references of these columns
 	for (auto &column : columns) {
-		set_info->expressions.push_back(make_unique<ColumnRefExpression>(column, "excluded"));
+		set_info->expressions.push_back(make_uniq<ColumnRefExpression>(column, "excluded"));
 	}
 
 	return set_info;
@@ -200,7 +200,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		throw BinderException("Can only update base table!");
 	}
 
-	auto &table_ref = (BaseTableRef &)*stmt.table_ref;
+	auto &table_ref = stmt.table_ref->Cast<BaseTableRef>();
 	const string &table_alias = !table_ref.alias.empty() ? table_ref.alias : table_ref.table_name;
 
 	auto &on_conflict = *stmt.on_conflict_info;
@@ -303,7 +303,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 
 	auto bindings = insert.children[0]->GetColumnBindings();
 	idx_t projection_index = DConstants::INVALID_INDEX;
-	std::vector<unique_ptr<LogicalOperator>> *insert_child_operators;
+	vector<unique_ptr<LogicalOperator>> *insert_child_operators;
 	insert_child_operators = &insert.children;
 	while (projection_index == DConstants::INVALID_INDEX) {
 		if (insert_child_operators->empty()) {
@@ -335,6 +335,16 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
 	}
 
+	if (insert.action_type == OnConflictAction::REPLACE) {
+		D_ASSERT(on_conflict.set_info == nullptr);
+		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
+		insert.action_type = OnConflictAction::UPDATE;
+	}
+	if (on_conflict.set_info && on_conflict.set_info->columns.empty()) {
+		// if we are doing INSERT OR REPLACE on a table with no columns outside of the primary key column
+		// convert to INSERT OR IGNORE
+		insert.action_type = OnConflictAction::NOTHING;
+	}
 	if (insert.action_type == OnConflictAction::NOTHING) {
 		if (!insert.on_conflict_condition) {
 			return;
@@ -342,19 +352,13 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		// Get the column_ids we need to fetch later on from the conflicting tuples
 		// of the original table, to execute the expressions
 		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-		auto table_binding = (TableBinding *)original_binding;
-		insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+		auto &table_binding = (TableBinding &)*original_binding;
+		insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 		return;
 	}
-	if (insert.action_type == OnConflictAction::REPLACE) {
-		D_ASSERT(on_conflict.set_info == nullptr);
-		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
-		insert.action_type = OnConflictAction::UPDATE;
-	}
 
 	D_ASSERT(on_conflict.set_info);
 	auto &set_info = *on_conflict.set_info;
-	D_ASSERT(!set_info.columns.empty());
 	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
 
 	if (set_info.condition) {
@@ -374,8 +378,8 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// Get the column_ids we need to fetch later on from the conflicting tuples
 	// of the original table, to execute the expressions
 	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-	auto table_binding = (TableBinding *)original_binding;
-	insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+	auto &table_binding = (TableBinding &)*original_binding;
+	insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 
 	// Replace the column bindings to refer to the child operator
 	for (auto &expr : insert.expressions) {
@@ -394,14 +398,13 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 
 	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
-	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
-	D_ASSERT(table);
-	if (!table->temporary) {
+	auto &table = *Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
+	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
-		properties.modified_databases.insert(table->catalog->GetName());
+		properties.modified_databases.insert(table.catalog->GetName());
 	}
 
-	auto insert = make_unique<LogicalInsert>(table, GenerateTableIndex());
+	auto insert = make_uniq<LogicalInsert>(table, GenerateTableIndex());
 	// Add CTEs as bindable
 	AddCTEMap(stmt.cte_map);
 
@@ -413,18 +416,18 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		case_insensitive_map_t<idx_t> column_name_map;
 		for (idx_t i = 0; i < stmt.columns.size(); i++) {
 			column_name_map[stmt.columns[i]] = i;
-			auto column_index = table->GetColumnIndex(stmt.columns[i]);
+			auto column_index = table.GetColumnIndex(stmt.columns[i]);
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
 				throw BinderException("Cannot explicitly insert values into rowid column");
 			}
-			auto &col = table->GetColumn(column_index);
+			auto &col = table.GetColumn(column_index);
 			if (col.Generated()) {
 				throw BinderException("Cannot insert into a generated column");
 			}
 			insert->expected_types.push_back(col.Type());
 			named_column_map.push_back(column_index);
 		}
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto entry = column_name_map.find(col.Name());
 			if (entry == column_name_map.end()) {
 				// column not specified, set index to DConstants::INVALID_INDEX
@@ -437,32 +440,32 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	} else {
 		// No columns specified, assume insertion into all columns
 		// Intentionally don't populate 'column_index_map' as an indication of this
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			named_column_map.push_back(col.Logical());
 			insert->expected_types.push_back(col.Type());
 		}
 	}
 
 	// bind the default values
-	BindDefaultValues(table->GetColumns(), insert->bound_defaults);
+	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
 	if (!stmt.select_statement) {
 		result.plan = std::move(insert);
 		return result;
 	}
 
 	// Exclude the generated columns from this amount
-	idx_t expected_columns = stmt.columns.empty() ? table->GetColumns().PhysicalColumnCount() : stmt.columns.size();
+	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
 	// special case: check if we are inserting from a VALUES statement
 	auto values_list = stmt.GetValuesList();
 	if (values_list) {
-		auto &expr_list = (ExpressionListRef &)*values_list;
+		auto &expr_list = values_list->Cast<ExpressionListRef>();
 		expr_list.expected_types.resize(expected_columns);
 		expr_list.expected_names.resize(expected_columns);
 
 		D_ASSERT(expr_list.values.size() > 0);
 		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-		                               table->name.c_str());
+		                               table.name.c_str());
 
 		// VALUES list!
 		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
@@ -470,7 +473,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			auto &table_col_idx = named_column_map[col_idx];
 
 			// set the expected types as the types for the INSERT statement
-			auto &column = table->GetColumn(table_col_idx);
+			auto &column = table.GetColumn(table_col_idx);
 			expr_list.expected_types[col_idx] = column.Type();
 			expr_list.expected_names[col_idx] = column.Name();
 
@@ -490,12 +493,12 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	MoveCorrelatedExpressions(*select_binder);
 
 	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-	                               table->name.c_str());
+	                               table.name.c_str());
 
 	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
 	insert->AddChild(std::move(root));
 
-	BindOnConflictClause(*insert, *table, stmt);
+	BindOnConflictClause(*insert, table, stmt);
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
@@ -505,8 +508,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		insert->table_index = insert_table_index;
 		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
-		return BindReturning(std::move(stmt.returning_list), table, insert_table_index,
-		                     std::move(index_as_logicaloperator), std::move(result));
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
+		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());

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

@@ -10,7 +10,7 @@ BoundStatement Binder::Bind(LoadStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, std::move(stmt.info));
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, std::move(stmt.info));
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -30,7 +30,7 @@ BoundStatement Binder::Bind(PragmaStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalPragma>(bound_function, *stmt.info);
+	result.plan = make_uniq<LogicalPragma>(bound_function, *stmt.info);
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }

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

@@ -10,7 +10,7 @@ BoundStatement Binder::Bind(PrepareStatement &stmt) {
 	auto prepared_data = prepared_planner.PrepareSQLStatement(std::move(stmt.statement));
 	this->bound_tables = prepared_planner.binder->bound_tables;
 
-	auto prepare = make_unique<LogicalPrepare>(stmt.name, std::move(prepared_data), std::move(prepared_planner.plan));
+	auto prepare = make_uniq<LogicalPrepare>(stmt.name, std::move(prepared_data), std::move(prepared_planner.plan));
 	// we can always prepare, even if the transaction has been invalidated
 	// this is required because most clients ALWAYS invoke prepared statements
 	properties.requires_valid_transaction = false;

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

@@ -11,7 +11,7 @@ BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_unique<LogicalSet>(stmt.name, stmt.value, stmt.scope);
+	result.plan = make_uniq<LogicalSet>(stmt.name, stmt.value, stmt.scope);
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -21,7 +21,7 @@ BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_unique<LogicalReset>(stmt.name, stmt.scope);
+	result.plan = make_uniq<LogicalReset>(stmt.name, stmt.scope);
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -29,11 +29,11 @@ BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
 BoundStatement Binder::Bind(SetStatement &stmt) {
 	switch (stmt.set_type) {
 	case SetType::SET: {
-		auto &set_stmt = (SetVariableStatement &)stmt;
+		auto &set_stmt = stmt.Cast<SetVariableStatement>();
 		return Bind(set_stmt);
 	}
 	case SetType::RESET: {
-		auto &set_stmt = (ResetVariableStatement &)stmt;
+		auto &set_stmt = stmt.Cast<ResetVariableStatement>();
 		return Bind(set_stmt);
 	}
 	default:

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

@@ -14,7 +14,7 @@ BoundStatement Binder::Bind(ShowStatement &stmt) {
 	stmt.info->types = plan.types;
 	stmt.info->aliases = plan.names;
 
-	auto show = make_unique<LogicalShow>(std::move(plan.plan));
+	auto show = make_uniq<LogicalShow>(std::move(plan.plan));
 	show->types_select = plan.types;
 	show->aliases = plan.names;
 

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

@@ -27,7 +27,7 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 		stmt.info->catalog = entry->catalog->GetName();
 		stmt.info->schema = ((StandardEntry *)entry)->schema->name;
 	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -39,7 +39,7 @@ BoundStatement Binder::Bind(TransactionStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, std::move(stmt.info));
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

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

@@ -11,35 +11,35 @@ namespace duckdb {
 
 static unique_ptr<ParsedExpression> SummarizeWrapUnnest(vector<unique_ptr<ParsedExpression>> &children,
                                                         const string &alias) {
-	auto list_function = make_unique<FunctionExpression>("list_value", std::move(children));
+	auto list_function = make_uniq<FunctionExpression>("list_value", std::move(children));
 	vector<unique_ptr<ParsedExpression>> unnest_children;
 	unnest_children.push_back(std::move(list_function));
-	auto unnest_function = make_unique<FunctionExpression>("unnest", std::move(unnest_children));
+	auto unnest_function = make_uniq<FunctionExpression>("unnest", std::move(unnest_children));
 	unnest_function->alias = alias;
 	return std::move(unnest_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name) {
 	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(std::move(column_name)));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, std::move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
+	children.push_back(make_uniq<ColumnRefExpression>(std::move(column_name)));
+	auto aggregate_function = make_uniq<FunctionExpression>(aggregate, std::move(children));
+	auto cast_function = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
 	return std::move(cast_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateAggregate(const string &aggregate, string column_name,
                                                              const Value &modifier) {
 	vector<unique_ptr<ParsedExpression>> children;
-	children.push_back(make_unique<ColumnRefExpression>(std::move(column_name)));
-	children.push_back(make_unique<ConstantExpression>(modifier));
-	auto aggregate_function = make_unique<FunctionExpression>(aggregate, std::move(children));
-	auto cast_function = make_unique<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
+	children.push_back(make_uniq<ColumnRefExpression>(std::move(column_name)));
+	children.push_back(make_uniq<ConstantExpression>(modifier));
+	auto aggregate_function = make_uniq<FunctionExpression>(aggregate, std::move(children));
+	auto cast_function = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(aggregate_function));
 	return std::move(cast_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateCountStar() {
 	vector<unique_ptr<ParsedExpression>> children;
-	auto aggregate_function = make_unique<FunctionExpression>("count_star", std::move(children));
+	auto aggregate_function = make_uniq<FunctionExpression>("count_star", std::move(children));
 	return std::move(aggregate_function);
 }
 
@@ -48,23 +48,23 @@ static unique_ptr<ParsedExpression> SummarizeCreateBinaryFunction(const string &
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(std::move(left));
 	children.push_back(std::move(right));
-	auto binary_function = make_unique<FunctionExpression>(op, std::move(children));
+	auto binary_function = make_uniq<FunctionExpression>(op, std::move(children));
 	return std::move(binary_function);
 }
 
 static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_name) {
-	auto count_star = make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateCountStar());
+	auto count_star = make_uniq<CastExpression>(LogicalType::DOUBLE, SummarizeCreateCountStar());
 	auto count =
-	    make_unique<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", std::move(column_name)));
+	    make_uniq<CastExpression>(LogicalType::DOUBLE, SummarizeCreateAggregate("count", std::move(column_name)));
 	auto null_percentage = SummarizeCreateBinaryFunction("/", std::move(count), std::move(count_star));
-	auto negate_x = SummarizeCreateBinaryFunction("-", make_unique<ConstantExpression>(Value::DOUBLE(1)),
-	                                              std::move(null_percentage));
+	auto negate_x =
+	    SummarizeCreateBinaryFunction("-", make_uniq<ConstantExpression>(Value::DOUBLE(1)), std::move(null_percentage));
 	auto percentage_x =
-	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_unique<ConstantExpression>(Value::DOUBLE(100)));
+	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_uniq<ConstantExpression>(Value::DOUBLE(100)));
 	auto round_x = SummarizeCreateBinaryFunction("round", std::move(percentage_x),
-	                                             make_unique<ConstantExpression>(Value::INTEGER(2)));
+	                                             make_uniq<ConstantExpression>(Value::INTEGER(2)));
 	auto concat_x =
-	    SummarizeCreateBinaryFunction("concat", std::move(round_x), make_unique<ConstantExpression>(Value("%")));
+	    SummarizeCreateBinaryFunction("concat", std::move(round_x), make_uniq<ConstantExpression>(Value("%")));
 
 	return concat_x;
 }
@@ -88,11 +88,11 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	vector<unique_ptr<ParsedExpression>> q75_children;
 	vector<unique_ptr<ParsedExpression>> count_children;
 	vector<unique_ptr<ParsedExpression>> null_percentage_children;
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = std::move(query_copy);
 	for (idx_t i = 0; i < plan.names.size(); i++) {
-		name_children.push_back(make_unique<ConstantExpression>(Value(plan.names[i])));
-		type_children.push_back(make_unique<ConstantExpression>(Value(plan.types[i].ToString())));
+		name_children.push_back(make_uniq<ConstantExpression>(Value(plan.names[i])));
+		type_children.push_back(make_uniq<ConstantExpression>(Value(plan.types[i].ToString())));
 		min_children.push_back(SummarizeCreateAggregate("min", plan.names[i]));
 		max_children.push_back(SummarizeCreateAggregate("max", plan.names[i]));
 		unique_children.push_back(SummarizeCreateAggregate("approx_count_distinct", plan.names[i]));
@@ -103,19 +103,19 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 			q50_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.50)));
 			q75_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.75)));
 		} else {
-			avg_children.push_back(make_unique<ConstantExpression>(Value()));
-			std_children.push_back(make_unique<ConstantExpression>(Value()));
-			q25_children.push_back(make_unique<ConstantExpression>(Value()));
-			q50_children.push_back(make_unique<ConstantExpression>(Value()));
-			q75_children.push_back(make_unique<ConstantExpression>(Value()));
+			avg_children.push_back(make_uniq<ConstantExpression>(Value()));
+			std_children.push_back(make_uniq<ConstantExpression>(Value()));
+			q25_children.push_back(make_uniq<ConstantExpression>(Value()));
+			q50_children.push_back(make_uniq<ConstantExpression>(Value()));
+			q75_children.push_back(make_uniq<ConstantExpression>(Value()));
 		}
 		count_children.push_back(SummarizeCreateCountStar());
 		null_percentage_children.push_back(SummarizeCreateNullPercentage(plan.names[i]));
 	}
-	auto subquery_ref = make_unique<SubqueryRef>(std::move(select), "summarize_tbl");
+	auto subquery_ref = make_uniq<SubqueryRef>(std::move(select), "summarize_tbl");
 	subquery_ref->column_name_alias = plan.names;
 
-	auto select_node = make_unique<SelectNode>();
+	auto select_node = make_uniq<SelectNode>();
 	select_node->select_list.push_back(SummarizeWrapUnnest(name_children, "column_name"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(type_children, "column_type"));
 	select_node->select_list.push_back(SummarizeWrapUnnest(min_children, "min"));