duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -1,14 +1,19 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_database_info.hpp"
+#include "duckdb/function/create_database_extension.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -33,6 +38,7 @@
 #include "duckdb/parser/constraints/list.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 
 namespace duckdb {
 
@@ -116,7 +122,7 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 
 	auto copy = base.query->Copy();
 	auto query_node = view_binder->Bind(*base.query);
-	base.query = unique_ptr_cast<SQLStatement, SelectStatement>(move(copy));
+	base.query = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(copy));
 	if (base.aliases.size() > query_node.names.size()) {
 		throw BinderException("More VIEW aliases than columns in query result");
 	}
@@ -128,6 +134,33 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	base.types = query_node.types;
 }
 
+static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
+	switch (expr->GetExpressionClass()) {
+	case ExpressionClass::FUNCTION: {
+		auto &func = (FunctionExpression &)*expr;
+		auto function = (StandardEntry *)Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog,
+		                                                   func.schema, func.function_name, true);
+		if (function) {
+			func.catalog = function->catalog->GetName();
+			func.schema = function->schema->name;
+		}
+		break;
+	}
+	case ExpressionClass::SUBQUERY: {
+		// replacing parameters within a subquery is slightly different
+		auto &sq = ((SubqueryExpression &)*expr).subquery;
+		ParsedExpressionIterator::EnumerateQueryNodeChildren(
+		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
+		break;
+	}
+	default: // fall through
+		break;
+	}
+	// unfold child expressions
+	ParsedExpressionIterator::EnumerateChildren(
+	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
+}
+
 SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = (CreateMacroInfo &)info;
 	auto &scalar_function = (ScalarMacroFunction &)*base.function;
@@ -157,6 +190,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto this_macro_binding = make_unique<DummyBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
 	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
+	QualifyFunctionNames(context, scalar_function.expression);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = scalar_function.expression->Copy();
@@ -175,7 +209,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	return BindCreateSchema(info);
 }
 
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const string &catalog, const string &schema) {
+void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog, const string &schema) {
 	if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP) {
 		auto child_type = ListType::GetChildType(type);
 		BindLogicalType(context, child_type, catalog, schema);
@@ -207,10 +241,31 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 		type = LogicalType::UNION(member_types);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::USER) {
-		type = Catalog::GetType(context, catalog, schema, UserType::GetTypeName(type));
+		auto &user_type_name = UserType::GetTypeName(type);
+		if (catalog) {
+			type = catalog->GetType(context, schema, user_type_name, true);
+			if (type.id() == LogicalTypeId::INVALID) {
+				// look in the system catalog if the type was not found
+				type = Catalog::GetType(context, SYSTEM_CATALOG, schema, user_type_name);
+			}
+		} else {
+			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
+		}
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
-		auto enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, catalog, schema, enum_type_name, true);
+		TypeCatalogEntry *enum_type_catalog;
+		if (catalog) {
+			enum_type_catalog = catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, true);
+			if (!enum_type_catalog) {
+				// look in the system catalog if the type was not found
+				enum_type_catalog =
+				    Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name, true);
+			}
+		} else {
+			enum_type_catalog =
+			    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name, true);
+		}
+
 		LogicalType::SetCatalog(type, enum_type_catalog);
 	}
 }
@@ -381,6 +436,35 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 	return false;
 }
 
+unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt,
+                                                         TableCatalogEntry &table, unique_ptr<LogicalOperator> plan) {
+	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
+	auto &base = (CreateIndexInfo &)*stmt.info;
+
+	auto &get = (LogicalGet &)*plan;
+	// bind the index expressions
+	vector<unique_ptr<Expression>> expressions;
+	IndexBinder index_binder(binder, binder.context);
+	for (auto &expr : base.expressions) {
+		expressions.push_back(index_binder.Bind(expr));
+	}
+
+	auto create_index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(stmt.info));
+	for (auto &column_id : get.column_ids) {
+		if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
+			throw BinderException("Cannot create an index on the rowid!");
+		}
+		create_index_info->scan_types.push_back(get.returned_types[column_id]);
+	}
+	create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE);
+	create_index_info->names = get.names;
+	create_index_info->column_ids = get.column_ids;
+
+	// the logical CREATE INDEX also needs all fields to scan the referenced table
+	return make_unique<LogicalCreateIndex>(std::move(get.bind_data), std::move(create_index_info),
+	                                       std::move(expressions), table, std::move(get.function));
+}
+
 BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
@@ -390,29 +474,33 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
 	case CatalogType::SCHEMA_ENTRY:
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, move(stmt.info));
+		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
 		break;
 	case CatalogType::VIEW_ENTRY: {
 		auto &base = (CreateViewInfo &)*stmt.info;
 		// bind the schema
 		auto schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, move(stmt.info), schema);
+		result.plan =
+		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, std::move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::SEQUENCE_ENTRY: {
 		auto schema = BindCreateSchema(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, move(stmt.info), schema);
+		result.plan =
+		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, std::move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::TABLE_MACRO_ENTRY: {
 		auto schema = BindCreateSchema(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, move(stmt.info), schema);
+		result.plan =
+		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::MACRO_ENTRY: {
 		auto schema = BindCreateFunctionInfo(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, move(stmt.info), schema);
+		result.plan =
+		    make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::INDEX_ENTRY: {
@@ -421,44 +509,20 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		// visit the table reference
 		auto bound_table = Bind(*base.table);
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
-			throw BinderException("Can only delete from base table!");
+			throw BinderException("Can only create an index over a base table!");
 		}
 		auto &table_binding = (BoundBaseTableRef &)*bound_table;
 		auto table = table_binding.table;
-
-		// bind the index expressions
-		vector<unique_ptr<Expression>> expressions;
-		IndexBinder binder(*this, context);
-		for (auto &expr : base.expressions) {
-			expressions.push_back(binder.Bind(expr));
+		if (table->temporary) {
+			stmt.info->temporary = true;
 		}
-
+		// create a plan over the bound table
 		auto plan = CreatePlan(*bound_table);
 		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
 			throw BinderException("Cannot create index on a view!");
 		}
 
-		auto &get = (LogicalGet &)*plan;
-		for (auto &column_id : get.column_ids) {
-			if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-				throw BinderException("Cannot create an index on the rowid!");
-			}
-		}
-		if (table->temporary) {
-			stmt.info->temporary = true;
-		}
-
-		auto create_index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(move(stmt.info));
-		for (auto &index : get.column_ids) {
-			create_index_info->scan_types.push_back(get.returned_types[index]);
-		}
-		create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE);
-		create_index_info->names = get.names;
-		create_index_info->column_ids = get.column_ids;
-
-		// the logical CREATE INDEX also needs all fields to scan the referenced table
-		result.plan = make_unique<LogicalCreateIndex>(move(get.bind_data), move(create_index_info), move(expressions),
-		                                              *table, move(get.function));
+		result.plan = table->catalog->BindCreateIndex(*this, stmt, *table, std::move(plan));
 		break;
 	}
 	case CatalogType::TABLE_ENTRY: {
@@ -488,11 +552,13 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				auto pk_table_entry_ptr =
 				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
 				fk_schemas.insert(pk_table_entry_ptr->schema);
-				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->columns, pk_table_entry_ptr->constraints, fk);
-				FindForeignKeyIndexes(pk_table_entry_ptr->columns, fk.pk_columns, fk.info.pk_keys);
-				CheckForeignKeyTypes(pk_table_entry_ptr->columns, create_info.columns, fk);
-				auto index = pk_table_entry_ptr->storage->info->indexes.FindForeignKeyIndex(
-				    fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
+				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->GetColumns(), pk_table_entry_ptr->GetConstraints(),
+				                              fk);
+				FindForeignKeyIndexes(pk_table_entry_ptr->GetColumns(), fk.pk_columns, fk.info.pk_keys);
+				CheckForeignKeyTypes(pk_table_entry_ptr->GetColumns(), create_info.columns, fk);
+				auto &storage = pk_table_entry_ptr->GetStorage();
+				auto index = storage.info->indexes.FindForeignKeyIndex(fk.info.pk_keys,
+				                                                       ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
 				if (!index) {
 					auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
 					throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
@@ -507,8 +573,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (AnyConstraintReferencesGeneratedColumn(create_info)) {
 			throw BinderException("Constraints on generated columns are not supported yet");
 		}
-		auto bound_info = BindCreateTableInfo(move(stmt.info));
-		auto root = move(bound_info->query);
+		auto bound_info = BindCreateTableInfo(std::move(stmt.info));
+		auto root = std::move(bound_info->query);
 		for (auto &fk_schema : fk_schemas) {
 			if (fk_schema != bound_info->schema) {
 				throw BinderException("Creating foreign keys across different schemas or catalogs is not supported");
@@ -517,19 +583,20 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 
 		// create the logical operator
 		auto &schema = bound_info->schema;
-		auto create_table = make_unique<LogicalCreateTable>(schema, move(bound_info));
+		auto create_table = make_unique<LogicalCreateTable>(schema, std::move(bound_info));
 		if (root) {
 			// CREATE TABLE AS
 			properties.return_type = StatementReturnType::CHANGED_ROWS;
-			create_table->children.push_back(move(root));
+			create_table->children.push_back(std::move(root));
 		}
-		result.plan = move(create_table);
+		result.plan = std::move(create_table);
 		break;
 	}
 	case CatalogType::TYPE_ENTRY: {
 		auto schema = BindCreateSchema(*stmt.info);
 		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
-		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, move(stmt.info), schema);
+		result.plan =
+		    make_unique<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 = (SelectStatement &)*create_type_info.query;
@@ -553,11 +620,11 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			if (need_to_add) {
 				auto distinct_modifier = make_unique<DistinctModifier>();
 				distinct_modifier->distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1)));
-				query_node.modifiers.emplace(query_node.modifiers.begin(), move(distinct_modifier));
+				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
 			}
 
 			auto query_obj = Bind(*create_type_info.query);
-			auto query = move(query_obj.plan);
+			auto query = std::move(query_obj.plan);
 
 			auto &sql_types = query_obj.types;
 			if (sql_types.size() != 1 || sql_types[0].id() != LogicalType::VARCHAR) {
@@ -565,7 +632,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				throw BinderException("The query must return one varchar column");
 			}
 
-			result.plan->AddChild(move(query));
+			result.plan->AddChild(std::move(query));
 		} else if (create_type_info.type.id() == LogicalTypeId::USER) {
 			// two cases:
 			// 1: create a type with a non-existant type as source, catalog.GetType(...) will throw exception.
@@ -581,6 +648,28 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		}
 		break;
 	}
+	case CatalogType::DATABASE_ENTRY: {
+		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
+		auto &base = (CreateDatabaseInfo &)*stmt.info;
+		string extension_name = base.extension_name;
+		string database_name = base.name;
+		string source_path = base.path;
+
+		auto &config = DBConfig::GetConfig(context);
+		for (auto &extension : config.create_database_extensions) {
+			auto create_database_function_ref =
+			    extension.function(context, extension_name, database_name, source_path, extension.data.get());
+			if (create_database_function_ref) {
+				auto bound_create_database_func = Bind(*create_database_function_ref);
+				result.plan = CreatePlan(*bound_create_database_func);
+				break;
+			}
+		}
+		if (!result.plan) {
+			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
+		}
+		break;
+	}
 	default:
 		throw Exception("Unrecognized type!");
 	}

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

@@ -42,9 +42,9 @@ static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, cons
 	auto unbound_expression = check.expression->Copy();
 	// now bind the constraint and create a new BoundCheckConstraint
 	bound_constraint->expression = check_binder.Bind(check.expression);
-	info.bound_constraints.push_back(move(bound_constraint));
+	info.bound_constraints.push_back(std::move(bound_constraint));
 	// move the unbound constraint back into the original check expression
-	check.expression = move(unbound_expression);
+	check.expression = std::move(unbound_expression);
 }
 
 static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
@@ -107,7 +107,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				primary_keys = keys;
 			}
 			info.bound_constraints.push_back(
-			    make_unique<BoundUniqueConstraint>(move(keys), move(key_set), unique.is_primary_key));
+			    make_unique<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.is_primary_key));
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
@@ -123,7 +123,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				fk_key_set.insert(fk.info.fk_keys[i]);
 			}
 			info.bound_constraints.push_back(
-			    make_unique<BoundForeignKeyConstraint>(fk.info, move(pk_key_set), move(fk_key_set)));
+			    make_unique<BoundForeignKeyConstraint>(fk.info, std::move(pk_key_set), std::move(fk_key_set)));
 			break;
 		}
 		default:
@@ -199,7 +199,7 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 	}
 }
 
-void Binder::BindDefaultValues(ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults) {
+void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults) {
 	for (auto &column : columns.Physical()) {
 		unique_ptr<Expression> bound_default;
 		if (column.DefaultValue()) {
@@ -213,7 +213,7 @@ void Binder::BindDefaultValues(ColumnList &columns, vector<unique_ptr<Expression
 			// no default value specified: push a default value of constant null
 			bound_default = make_unique<BoundConstantExpression>(Value(column.Type()));
 		}
-		bound_defaults.push_back(move(bound_default));
+		bound_defaults.push_back(std::move(bound_default));
 	}
 }
 
@@ -243,12 +243,12 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 }
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema) {
 	auto &base = (CreateTableInfo &)*info;
-	auto result = make_unique<BoundCreateTableInfo>(move(info));
+	auto result = make_unique<BoundCreateTableInfo>(std::move(info));
 	result->schema = schema;
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
-		result->query = move(query_obj.plan);
+		result->query = std::move(query_obj.plan);
 
 		// construct the set of columns based on the names and types of the query
 		auto &names = query_obj.names;
@@ -282,7 +282,7 @@ 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->GetName());
+		BindLogicalType(context, column.TypeMutable(), result->schema->catalog);
 		// We add a catalog dependency
 		auto type_dependency = LogicalType::GetCatalog(column.Type());
 		if (type_dependency) {
@@ -297,7 +297,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
 	auto &base = (CreateTableInfo &)*info;
 	auto schema = BindCreateSchema(base);
-	return BindCreateTableInfo(move(info), schema);
+	return BindCreateTableInfo(std::move(info), schema);
 }
 
 } // namespace duckdb

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

@@ -8,6 +8,7 @@
 #include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -44,14 +45,14 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 			auto op = CreatePlan(*bound_node);
 			if (child_operator) {
 				// already bound a child: create a cross product to unify the two
-				child_operator = LogicalCrossProduct::Create(move(child_operator), move(op));
+				child_operator = LogicalCrossProduct::Create(std::move(child_operator), std::move(op));
 			} else {
-				child_operator = move(op);
+				child_operator = std::move(op);
 			}
-			bind_context.AddContext(move(using_binder->bind_context));
+			bind_context.AddContext(std::move(using_binder->bind_context));
 		}
 		if (child_operator) {
-			root = LogicalCrossProduct::Create(move(root), move(child_operator));
+			root = LogicalCrossProduct::Create(std::move(root), std::move(child_operator));
 		}
 	}
 
@@ -62,13 +63,13 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		condition = binder.Bind(stmt.condition);
 
 		PlanSubqueries(&condition, &root);
-		auto filter = make_unique<LogicalFilter>(move(condition));
-		filter->AddChild(move(root));
-		root = move(filter);
+		auto filter = make_unique<LogicalFilter>(std::move(condition));
+		filter->AddChild(std::move(root));
+		root = std::move(filter);
 	}
 	// create the delete node
 	auto del = make_unique<LogicalDelete>(table, GenerateTableIndex());
-	del->AddChild(move(root));
+	del->AddChild(std::move(root));
 
 	// set up the delete expression
 	del->expressions.push_back(make_unique<BoundColumnRefExpression>(
@@ -81,11 +82,11 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		auto update_table_index = GenerateTableIndex();
 		del->table_index = update_table_index;
 
-		unique_ptr<LogicalOperator> del_as_logicaloperator = move(del);
-		return BindReturning(move(stmt.returning_list), table, update_table_index, move(del_as_logicaloperator),
-		                     move(result));
+		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
+		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		                     std::move(del_as_logicaloperator), std::move(result));
 	}
-	result.plan = move(del);
+	result.plan = std::move(del);
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
 	properties.allow_stream_result = false;

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

@@ -50,7 +50,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, move(stmt.info));
+	result.plan = make_unique<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

@@ -33,7 +33,7 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 		auto bound_expr = cbinder.Bind(stmt.values[i]);
 
 		Value value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-		bind_values.push_back(move(value));
+		bind_values.push_back(std::move(value));
 	}
 	unique_ptr<LogicalOperator> rebound_plan;
 	if (prepared->RequireRebind(context, bind_values)) {
@@ -43,7 +43,7 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 			prepared_planner.parameter_data.emplace_back(bind_values[i]);
 		}
 		prepared = prepared_planner.PrepareSQLStatement(entry->second->unbound_statement->Copy());
-		rebound_plan = move(prepared_planner.plan);
+		rebound_plan = std::move(prepared_planner.plan);
 		D_ASSERT(prepared->properties.bound_all_parameters);
 		this->bound_tables = prepared_planner.binder->bound_tables;
 	}
@@ -54,13 +54,13 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 	result.names = prepared->names;
 	result.types = prepared->types;
 
-	prepared->Bind(move(bind_values));
+	prepared->Bind(std::move(bind_values));
 	if (rebound_plan) {
-		auto execute_plan = make_unique<LogicalExecute>(move(prepared));
-		execute_plan->children.push_back(move(rebound_plan));
-		result.plan = move(execute_plan);
+		auto execute_plan = make_unique<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>(move(prepared));
+		result.plan = make_unique<LogicalExecute>(std::move(prepared));
 	}
 	return result;
 }

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

@@ -11,10 +11,10 @@ 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>(move(plan.plan), stmt.explain_type);
+	auto explain = make_unique<LogicalExplain>(std::move(plan.plan), stmt.explain_type);
 	explain->logical_plan_unopt = logical_plan_unopt;
 
-	result.plan = move(explain);
+	result.plan = std::move(explain);
 	result.names = {"explain_key", "explain_value"};
 	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
 	properties.return_type = StatementReturnType::QUERY_RESULT;