duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

package/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/expression_binder/order_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/query_node/bound_set_operation_node.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -51,17 +52,7 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 
 			idx_t index = reorder_idx[i];
 
-			if (entry != aliases.end()) {
-				// the alias already exists
-				// check if there is a conflict
-
-				if (entry->second != index) {
-					// there is a conflict
-					// we place "-1" in the aliases map at this location
-					// "-1" signifies that there is an ambiguous reference
-					aliases[name] = DConstants::INVALID_INDEX;
-				}
-			} else {
+			if (entry == aliases.end()) {
 				// the alias is not in there yet, just assign it
 				aliases[name] = index;
 			}
@@ -81,37 +72,37 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 	}
 }
 
-static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain_nulls) {
+static void BuildUnionByNameInfo(ClientContext &context, BoundSetOperationNode &result, bool can_contain_nulls) {
 	D_ASSERT(result.setop_type == SetOperationType::UNION_BY_NAME);
 	case_insensitive_map_t<idx_t> left_names_map;
 	case_insensitive_map_t<idx_t> right_names_map;
 
-	BoundQueryNode *left_node = result.left.get();
-	BoundQueryNode *right_node = result.right.get();
+	auto &left_node = *result.left;
+	auto &right_node = *result.right;
 
 	// Build a name_map to use to check if a name exists
 	// We throw a binder exception if two same name in the SELECT list
-	for (idx_t i = 0; i < left_node->names.size(); ++i) {
-		if (left_names_map.find(left_node->names[i]) != left_names_map.end()) {
+	for (idx_t i = 0; i < left_node.names.size(); ++i) {
+		if (left_names_map.find(left_node.names[i]) != left_names_map.end()) {
 			throw BinderException("UNION(ALL) BY NAME operation doesn't support same name in SELECT list");
 		}
-		left_names_map[left_node->names[i]] = i;
+		left_names_map[left_node.names[i]] = i;
 	}
 
-	for (idx_t i = 0; i < right_node->names.size(); ++i) {
-		if (right_names_map.find(right_node->names[i]) != right_names_map.end()) {
+	for (idx_t i = 0; i < right_node.names.size(); ++i) {
+		if (right_names_map.find(right_node.names[i]) != right_names_map.end()) {
 			throw BinderException("UNION(ALL) BY NAME operation doesn't support same name in SELECT list");
 		}
-		if (left_names_map.find(right_node->names[i]) == left_names_map.end()) {
-			result.names.push_back(right_node->names[i]);
+		if (left_names_map.find(right_node.names[i]) == left_names_map.end()) {
+			result.names.push_back(right_node.names[i]);
 		}
-		right_names_map[right_node->names[i]] = i;
+		right_names_map[right_node.names[i]] = i;
 	}
 
 	idx_t new_size = result.names.size();
 	bool need_reorder = false;
-	vector<idx_t> left_reorder_idx(left_node->names.size());
-	vector<idx_t> right_reorder_idx(right_node->names.size());
+	vector<idx_t> left_reorder_idx(left_node.names.size());
+	vector<idx_t> right_reorder_idx(right_node.names.size());
 
 	// Construct return type and reorder_idxs
 	// reorder_idxs is used to gather correct alias_map
@@ -123,20 +114,20 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 		bool right_exist = right_index != right_names_map.end();
 		LogicalType result_type;
 		if (left_exist && right_exist) {
-			result_type = LogicalType::MaxLogicalType(left_node->types[left_index->second],
-			                                          right_node->types[right_index->second]);
+			result_type = LogicalType::MaxLogicalType(context, left_node.types[left_index->second],
+			                                          right_node.types[right_index->second]);
 			if (left_index->second != i || right_index->second != i) {
 				need_reorder = true;
 			}
 			left_reorder_idx[left_index->second] = i;
 			right_reorder_idx[right_index->second] = i;
 		} else if (left_exist) {
-			result_type = left_node->types[left_index->second];
+			result_type = left_node.types[left_index->second];
 			need_reorder = true;
 			left_reorder_idx[left_index->second] = i;
 		} else {
 			D_ASSERT(right_exist);
-			result_type = right_node->types[right_index->second];
+			result_type = right_node.types[right_index->second];
 			need_reorder = true;
 			right_reorder_idx[right_index->second] = i;
 		}
@@ -165,21 +156,21 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 			unique_ptr<Expression> right_reorder_expr;
 			if (left_exist && right_exist) {
 				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
-				    left_node->types[left_index->second], ColumnBinding(left_node->GetRootIndex(), left_index->second));
+				    left_node.types[left_index->second], ColumnBinding(left_node.GetRootIndex(), left_index->second));
 				right_reorder_expr =
-				    make_uniq<BoundColumnRefExpression>(right_node->types[right_index->second],
-				                                        ColumnBinding(right_node->GetRootIndex(), right_index->second));
+				    make_uniq<BoundColumnRefExpression>(right_node.types[right_index->second],
+				                                        ColumnBinding(right_node.GetRootIndex(), right_index->second));
 			} else if (left_exist) {
 				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
-				    left_node->types[left_index->second], ColumnBinding(left_node->GetRootIndex(), left_index->second));
+				    left_node.types[left_index->second], ColumnBinding(left_node.GetRootIndex(), left_index->second));
 				// create null value here
 				right_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
 			} else {
 				D_ASSERT(right_exist);
 				left_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
 				right_reorder_expr =
-				    make_uniq<BoundColumnRefExpression>(right_node->types[right_index->second],
-				                                        ColumnBinding(right_node->GetRootIndex(), right_index->second));
+				    make_uniq<BoundColumnRefExpression>(right_node.types[right_index->second],
+				                                        ColumnBinding(right_node.GetRootIndex(), right_index->second));
 			}
 			result.left_reorder_exprs.push_back(std::move(left_reorder_expr));
 			result.right_reorder_exprs.push_back(std::move(right_reorder_expr));
@@ -190,6 +181,7 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 	auto result = make_uniq<BoundSetOperationNode>();
 	result->setop_type = statement.setop_type;
+	result->setop_all = statement.setop_all;
 
 	// first recursively visit the set operations
 	// both the left and right sides have an independent BindContext and Binder
@@ -219,12 +211,11 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 	}
 
 	if (result->setop_type == SetOperationType::UNION_BY_NAME) {
-		BuildUnionByNameInfo(*result, can_contain_nulls);
-
+		BuildUnionByNameInfo(context, *result, can_contain_nulls);
 	} else {
 		// figure out the types of the setop result by picking the max of both
 		for (idx_t i = 0; i < result->left->types.size(); i++) {
-			auto result_type = LogicalType::MaxLogicalType(result->left->types[i], result->right->types[i]);
+			auto result_type = LogicalType::ForceMaxLogicalType(result->left->types[i], result->right->types[i]);
 			if (!can_contain_nulls) {
 				if (ExpressionBinder::ContainsNullType(result_type)) {
 					result_type = ExpressionBinder::ExchangeNullType(result_type);

package/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp

@@ -32,7 +32,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	if (!error.empty()) {
 		// cannot use error below as binder rnot in scope
 		// return BindResult(binder. FormatError(*expr->get(), error));
-		throw BinderException(FormatError(function, error));
+		throw BinderException(function, error);
 	}
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
@@ -58,10 +58,9 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	auto eb = ExpressionBinder(*this, this->context);
 
 	eb.macro_binding = new_macro_binding.get();
-
-	/* Does it all goes throu every expression in a selectstmt  */
+	vector<unordered_set<string>> lambda_params;
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
-	    *node, [&](unique_ptr<ParsedExpression> &child) { eb.ReplaceMacroParametersRecursive(child); });
+	    *node, [&](unique_ptr<ParsedExpression> &child) { eb.ReplaceMacroParameters(child, lambda_params); });
 
 	return node;
 }

package/src/duckdb/src/planner/binder/query_node/plan_cte_node.cpp

@@ -17,8 +17,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
 	                                              std::move(cte_query), std::move(cte_child));
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins =
-	    node.child_binder->has_unplanned_dependent_joins || node.query_binder->has_unplanned_dependent_joins;
+	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.child_binder->has_unplanned_dependent_joins ||
+	                                node.query_binder->has_unplanned_dependent_joins;
 
 	return VisitQueryNode(node, std::move(root));
 }

package/src/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp

@@ -17,8 +17,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 	auto right_node = node.right_binder->CreatePlan(*node.right);
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins =
-	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
+	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.left_binder->has_unplanned_dependent_joins ||
+	                                node.right_binder->has_unplanned_dependent_joins;
 
 	// for both the left and right sides, cast them to the same types
 	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
@@ -27,7 +27,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 	if (!node.right_binder->bind_context.cte_references[node.ctename] ||
 	    *node.right_binder->bind_context.cte_references[node.ctename] == 0) {
 		auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
+		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION, true);
 		return VisitQueryNode(node, std::move(root));
 	}
 	auto root = make_uniq<LogicalRecursiveCTE>(node.ctename, node.setop_index, node.types.size(), node.union_all,

package/src/duckdb/src/planner/binder/query_node/plan_setop.cpp

@@ -95,8 +95,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	}
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_dependent_joins =
-	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
+	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.left_binder->has_unplanned_dependent_joins ||
+	                                node.right_binder->has_unplanned_dependent_joins;
 
 	// create actual logical ops for setops
 	LogicalOperatorType logical_type;
@@ -108,14 +108,16 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	case SetOperationType::EXCEPT:
 		logical_type = LogicalOperatorType::LOGICAL_EXCEPT;
 		break;
-	default:
-		D_ASSERT(node.setop_type == SetOperationType::INTERSECT);
+	case SetOperationType::INTERSECT:
 		logical_type = LogicalOperatorType::LOGICAL_INTERSECT;
 		break;
+	default:
+		D_ASSERT(false);
+		break;
 	}
 
 	auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-	                                           std::move(right_node), logical_type);
+	                                           std::move(right_node), logical_type, node.setop_all);
 
 	return VisitQueryNode(node, std::move(root));
 }

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -333,6 +333,11 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 
 void RecursiveDependentJoinPlanner::VisitOperator(LogicalOperator &op) {
 	if (!op.children.empty()) {
+		// Collect all recursive CTEs during recursive descend
+		if (op.type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
+			auto &rec_cte = op.Cast<LogicalRecursiveCTE>();
+			binder.recursive_ctes[rec_cte.table_index] = &op;
+		}
 		root = std::move(op.children[0]);
 		D_ASSERT(root);
 		if (root->type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
@@ -433,6 +438,11 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	// fetch the set of columns
 	auto plan_columns = dependent_join->GetColumnBindings();
 
+	// in case of a materialized CTE, the output is defined by the second children operator
+	if (dependent_join->type == LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
+		plan_columns = dependent_join->children[1]->GetColumnBindings();
+	}
+
 	// now create the join conditions
 	// start off with the conditions that were passed in (if any)
 	D_ASSERT(delim_join->conditions.empty());

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

@@ -5,7 +5,6 @@
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
-#include "duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
@@ -24,32 +23,8 @@
 
 namespace duckdb {
 
-vector<string> GetUniqueNames(const vector<string> &original_names) {
-	unordered_set<string> name_set;
-	vector<string> unique_names;
-	unique_names.reserve(original_names.size());
-
-	for (auto &name : original_names) {
-		auto insert_result = name_set.insert(name);
-		if (insert_result.second == false) {
-			// Could not be inserted, name already exists
-			idx_t index = 1;
-			string postfixed_name;
-			while (true) {
-				postfixed_name = StringUtil::Format("%s:%d", name, index);
-				auto res = name_set.insert(postfixed_name);
-				if (!res.second) {
-					index++;
-					continue;
-				}
-				break;
-			}
-			unique_names.push_back(postfixed_name);
-		} else {
-			unique_names.push_back(name);
-		}
-	}
-	return unique_names;
+static bool GetBooleanArg(ClientContext &context, const vector<Value> &arg) {
+	return arg.empty() || arg[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 }
 
 BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
@@ -76,59 +51,76 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	if (!copy_function.function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
+
 	bool use_tmp_file = true;
 	bool overwrite_or_ignore = false;
 	FilenamePattern filename_pattern;
 	bool user_set_use_tmp_file = false;
 	bool per_thread_output = false;
+	optional_idx file_size_bytes;
 	vector<idx_t> partition_cols;
 
+	CopyFunctionBindInput bind_input(*stmt.info);
+
+	bind_input.file_extension = copy_function.function.extension;
+
 	auto original_options = stmt.info->options;
 	stmt.info->options.clear();
 
 	for (auto &option : original_options) {
 		auto loption = StringUtil::Lower(option.first);
 		if (loption == "use_tmp_file") {
-			use_tmp_file =
-			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			use_tmp_file = GetBooleanArg(context, option.second);
 			user_set_use_tmp_file = true;
-			continue;
-		}
-		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") {
+		} else if (loption == "overwrite_or_ignore") {
+			overwrite_or_ignore = GetBooleanArg(context, option.second);
+		} else 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 =
-			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
-			continue;
-		}
-		if (loption == "partition_by") {
+		} else if (loption == "file_extension") {
+			if (option.second.empty()) {
+				throw IOException("FILE_EXTENSION cannot be empty");
+			}
+			bind_input.file_extension = option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>();
+		} else if (loption == "per_thread_output") {
+			per_thread_output = GetBooleanArg(context, option.second);
+		} else if (loption == "file_size_bytes") {
+			if (option.second.empty()) {
+				throw BinderException("FILE_SIZE_BYTES cannot be empty");
+			}
+			if (!copy_function.function.file_size_bytes) {
+				throw NotImplementedException("FILE_SIZE_BYTES not implemented for FORMAT \"%s\"", stmt.info->format);
+			}
+			if (option.second[0].GetTypeMutable().id() == LogicalTypeId::VARCHAR) {
+				file_size_bytes = DBConfig::ParseMemoryLimit(option.second[0].ToString());
+			} else {
+				file_size_bytes = option.second[0].GetValue<uint64_t>();
+			}
+		} else if (loption == "partition_by") {
 			auto converted = ConvertVectorToValue(std::move(option.second));
 			partition_cols = ParseColumnsOrdered(converted, select_node.names, loption);
-			continue;
+		} else {
+			stmt.info->options[option.first] = option.second;
 		}
-		stmt.info->options[option.first] = option.second;
 	}
 	if (user_set_use_tmp_file && per_thread_output) {
 		throw NotImplementedException("Can't combine USE_TMP_FILE and PER_THREAD_OUTPUT for COPY");
 	}
+	if (user_set_use_tmp_file && file_size_bytes.IsValid()) {
+		throw NotImplementedException("Can't combine USE_TMP_FILE and FILE_SIZE_BYTES for COPY");
+	}
 	if (user_set_use_tmp_file && !partition_cols.empty()) {
 		throw NotImplementedException("Can't combine USE_TMP_FILE and PARTITION_BY for COPY");
 	}
 	if (per_thread_output && !partition_cols.empty()) {
 		throw NotImplementedException("Can't combine PER_THREAD_OUTPUT and PARTITION_BY for COPY");
 	}
+	if (file_size_bytes.IsValid() && !partition_cols.empty()) {
+		throw NotImplementedException("Can't combine FILE_SIZE_BYTES and PARTITION_BY for COPY");
+	}
 	bool is_remote_file = config.file_system->IsRemoteFile(stmt.info->file_path);
 	if (is_remote_file) {
 		use_tmp_file = false;
@@ -140,18 +132,24 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 		}
 	}
 
-	auto unique_column_names = GetUniqueNames(select_node.names);
+	auto unique_column_names = select_node.names;
+	QueryResult::DeduplicateColumns(unique_column_names);
 	auto file_path = stmt.info->file_path;
 
 	auto function_data =
-	    copy_function.function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
+	    copy_function.function.copy_to_bind(context, bind_input, unique_column_names, select_node.types);
+
 	// now create the copy information
 	auto copy = make_uniq<LogicalCopyToFile>(copy_function.function, std::move(function_data), std::move(stmt.info));
 	copy->file_path = file_path;
 	copy->use_tmp_file = use_tmp_file;
 	copy->overwrite_or_ignore = overwrite_or_ignore;
 	copy->filename_pattern = filename_pattern;
+	copy->file_extension = bind_input.file_extension;
 	copy->per_thread_output = per_thread_output;
+	if (file_size_bytes.IsValid()) {
+		copy->file_size_bytes = file_size_bytes;
+	}
 	copy->partition_output = !partition_cols.empty();
 	copy->partition_columns = std::move(partition_cols);
 

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

@@ -0,0 +1,187 @@
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/parser/statement/copy_database_statement.hpp"
+#include "duckdb/catalog/catalog_entry/list.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/planner/operator/logical_copy_database.hpp"
+#include "duckdb/execution/operator/persistent/physical_export.hpp"
+#include "duckdb/planner/operator/logical_create_table.hpp"
+#include "duckdb/planner/operator/logical_set_operation.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/statement/insert_statement.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/operator/logical_dummy_scan.hpp"
+#include "duckdb/planner/operator/logical_expression_get.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement &stmt, Catalog &from_database,
+                                                           Catalog &to_database) {
+	auto from_schemas = from_database.GetSchemas(context);
+
+	ExportEntries entries;
+	PhysicalExport::ExtractEntries(context, from_schemas, entries);
+
+	auto info = make_uniq<CopyDatabaseInfo>(from_database, to_database);
+
+	// get a list of all schemas to copy over
+	for (auto &schema_ref : from_schemas) {
+		auto &schema = schema_ref.get().Cast<SchemaCatalogEntry>();
+		if (schema.internal) {
+			continue;
+		}
+		auto create_info = schema.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+	// get a list of all types to copy over
+	for (auto &seq_ref : entries.sequences) {
+		auto &seq_entry = seq_ref.get().Cast<SequenceCatalogEntry>();
+		if (seq_entry.internal) {
+			continue;
+		}
+		auto create_info = seq_entry.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+	// get a list of all types to copy over
+	for (auto &type_ref : entries.custom_types) {
+		auto &type_entry = type_ref.get().Cast<TypeCatalogEntry>();
+		if (type_entry.internal) {
+			continue;
+		}
+		auto create_info = type_entry.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+	// get a list of all tables to copy over
+	for (auto &table_ref : entries.tables) {
+		auto &table = table_ref.get().Cast<TableCatalogEntry>();
+		if (table.internal) {
+			continue;
+		}
+		auto create_info = table.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+	for (auto &macro_ref : entries.macros) {
+		auto &macro = macro_ref.get().Cast<MacroCatalogEntry>();
+		if (macro.internal) {
+			continue;
+		}
+		auto create_info = macro.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+	// get a list of all views to copy over
+	for (auto &view_ref : entries.views) {
+		auto &view = view_ref.get().Cast<ViewCatalogEntry>();
+		if (view.internal) {
+			continue;
+		}
+		auto create_info = view.GetInfo();
+		create_info->catalog = to_database.GetName();
+		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+		info->entries.push_back(std::move(create_info));
+	}
+
+	// FIXME: copy indexes
+	return make_uniq<LogicalCopyDatabase>(std::move(info));
+}
+
+unique_ptr<LogicalOperator> Binder::BindCopyDatabaseData(CopyDatabaseStatement &stmt, Catalog &from_database,
+                                                         Catalog &to_database) {
+	auto from_schemas = from_database.GetSchemas(context);
+
+	ExportEntries entries;
+	PhysicalExport::ExtractEntries(context, from_schemas, entries);
+
+	unique_ptr<LogicalOperator> result;
+	for (auto &table_ref : entries.tables) {
+		auto &table = table_ref.get();
+		// generate the insert statement
+		InsertStatement insert_stmt;
+		insert_stmt.catalog = stmt.to_database;
+		insert_stmt.schema = table.ParentSchema().name;
+		insert_stmt.table = table.name;
+
+		auto from_tbl = make_uniq<BaseTableRef>();
+		from_tbl->catalog_name = stmt.from_database;
+		from_tbl->schema_name = table.ParentSchema().name;
+		from_tbl->table_name = table.name;
+
+		auto select_node = make_uniq<SelectNode>();
+		select_node->select_list.push_back(make_uniq<StarExpression>());
+		select_node->from_table = std::move(from_tbl);
+
+		auto select_stmt = make_uniq<SelectStatement>();
+		select_stmt->node = std::move(select_node);
+
+		insert_stmt.select_statement = std::move(select_stmt);
+		auto bound_insert = Bind(insert_stmt);
+		auto insert_plan = std::move(bound_insert.plan);
+		if (result) {
+			// use UNION ALL to combine the individual copy statements into a single node
+			auto copy_union =
+			    make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(insert_plan), std::move(result),
+			                                   LogicalOperatorType::LOGICAL_UNION, true, false);
+			result = std::move(copy_union);
+		} else {
+			result = std::move(insert_plan);
+		}
+	}
+	if (!result) {
+		vector<LogicalType> result_types;
+		result_types.push_back(LogicalType::BIGINT);
+		vector<unique_ptr<Expression>> expression_list;
+		expression_list.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(0)));
+		vector<vector<unique_ptr<Expression>>> expressions;
+		expressions.push_back(std::move(expression_list));
+		result = make_uniq<LogicalExpressionGet>(GenerateTableIndex(), std::move(result_types), std::move(expressions));
+		result->children.push_back(make_uniq<LogicalDummyScan>(GenerateTableIndex()));
+	}
+	return result;
+}
+
+BoundStatement Binder::Bind(CopyDatabaseStatement &stmt) {
+	BoundStatement result;
+
+	unique_ptr<LogicalOperator> plan;
+	auto &from_database = Catalog::GetCatalog(context, stmt.from_database);
+	auto &to_database = Catalog::GetCatalog(context, stmt.to_database);
+	if (&from_database == &to_database) {
+		throw BinderException("Cannot copy from \"%s\" to \"%s\" - FROM and TO databases are the same",
+		                      stmt.from_database, stmt.to_database);
+	}
+	if (stmt.copy_type == CopyDatabaseType::COPY_SCHEMA) {
+		result.types = {LogicalType::BOOLEAN};
+		result.names = {"Success"};
+
+		plan = BindCopyDatabaseSchema(stmt, from_database, to_database);
+	} else {
+		result.types = {LogicalType::BIGINT};
+		result.names = {"Count"};
+
+		plan = BindCopyDatabaseData(stmt, from_database, to_database);
+	}
+
+	result.plan = std::move(plan);
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
+	properties.modified_databases.insert(stmt.to_database);
+	return result;
+}
+
+} // namespace duckdb