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

package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp

@@ -13,9 +13,9 @@ PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction fu
                                      unique_ptr<FunctionData> bind_data_p, vector<column_t> column_ids_p,
                                      vector<string> names_p, unique_ptr<TableFilterSet> table_filters_p,
                                      idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data_p)), column_ids(move(column_ids_p)), names(move(names_p)),
-      table_filters(move(table_filters_p)) {
+    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, std::move(types), estimated_cardinality),
+      function(std::move(function_p)), bind_data(std::move(bind_data_p)), column_ids(std::move(column_ids_p)),
+      names(std::move(names_p)), table_filters(std::move(table_filters_p)) {
 }
 
 PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction function_p,
@@ -23,10 +23,10 @@ PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction fu
                                      vector<column_t> column_ids_p, vector<idx_t> projection_ids_p,
                                      vector<string> names_p, unique_ptr<TableFilterSet> table_filters_p,
                                      idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data_p)), returned_types(move(returned_types_p)),
-      column_ids(move(column_ids_p)), projection_ids(move(projection_ids_p)), names(move(names_p)),
-      table_filters(move(table_filters_p)) {
+    : PhysicalOperator(PhysicalOperatorType::TABLE_SCAN, std::move(types), estimated_cardinality),
+      function(std::move(function_p)), bind_data(std::move(bind_data_p)), returned_types(std::move(returned_types_p)),
+      column_ids(std::move(column_ids_p)), projection_ids(std::move(projection_ids_p)), names(std::move(names_p)),
+      table_filters(std::move(table_filters_p)) {
 }
 
 class TableScanGlobalSourceState : public GlobalSourceState {
@@ -135,7 +135,8 @@ string PhysicalTableScan::ParamsToString() const {
 			}
 		}
 	}
-	result += "\nEC=" + to_string(estimated_cardinality) + "\n";
+	result += "\n[INFOSEPARATOR]\n";
+	result += StringUtil::Format("EC: %llu", estimated_props->GetCardinality<idx_t>());
 	return result;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 namespace duckdb {
 
@@ -31,6 +33,8 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	// parse the options
 	auto &config = DBConfig::GetConfig(context.client);
 	AccessMode access_mode = config.options.access_mode;
+	string type;
+	string unrecognized_option;
 	for (auto &entry : info->options) {
 		if (entry.first == "readonly" || entry.first == "read_only") {
 			auto read_only = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
@@ -39,21 +43,42 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 			} else {
 				access_mode = AccessMode::READ_WRITE;
 			}
-		} else if (entry.first == "read_write" || entry.first == "read_write") {
+		} else if (entry.first == "readwrite" || entry.first == "read_write") {
 			auto read_only = !BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
 			if (read_only) {
 				access_mode = AccessMode::READ_ONLY;
 			} else {
 				access_mode = AccessMode::READ_WRITE;
 			}
-		} else {
-			throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
+		} else if (entry.first == "type") {
+			type = StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR));
+		} else if (unrecognized_option.empty()) {
+			unrecognized_option = entry.first;
 		}
 	}
-	// attach the database
-	auto name = info->name;
-	auto path = info->path;
 	auto &db = DatabaseInstance::GetDatabase(context.client);
+	if (type.empty()) {
+		// try to extract type from path
+		type = db.ExtractDatabaseType(info->path);
+	}
+	if (!type.empty()) {
+		type = ExtensionHelper::ApplyExtensionAlias(type);
+	}
+	if (type.empty() && !unrecognized_option.empty()) {
+		throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
+	}
+
+	// if we are loading a database type from an extension - check if that extension is loaded
+	if (!type.empty()) {
+		if (!db.ExtensionIsLoaded(type)) {
+			ExtensionHelper::LoadExternalExtension(context.client, type);
+		}
+	}
+
+	// attach the database
+	auto &name = info->name;
+	const auto &path = info->path;
+
 	if (name.empty()) {
 		name = AttachedDatabase::ExtractDatabaseName(path);
 	}
@@ -62,10 +87,10 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	if (existing_db) {
 		throw BinderException("Database \"%s\" is already attached with alias \"%s\"", path, existing_db->GetName());
 	}
-	auto new_db = make_unique<AttachedDatabase>(db, Catalog::GetSystemCatalog(context.client), name, path, access_mode);
+	auto new_db = db.CreateAttachedDatabase(*info, type, access_mode);
 	new_db->Initialize();
 
-	db_manager.AddDatabase(context.client, move(new_db));
+	db_manager.AddDatabase(context.client, std::move(new_db));
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -1,15 +1,27 @@
 #include "duckdb/execution/operator/schema/physical_create_index.hpp"
 
-#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
+PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table_p,
+                                         const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
+                                         vector<unique_ptr<Expression>> unbound_expressions,
+                                         idx_t estimated_cardinality)
+    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
+      table((DuckTableEntry &)table_p), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)) {
+	D_ASSERT(table_p.IsDuckTable());
+	// convert virtual column ids to storage column ids
+	for (auto &column_id : column_ids) {
+		storage_ids.push_back(table.GetColumns().LogicalToPhysical(LogicalIndex(column_id)).index);
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
@@ -22,20 +34,13 @@ public:
 
 class CreateIndexLocalSinkState : public LocalSinkState {
 public:
-	explicit CreateIndexLocalSinkState(const vector<unique_ptr<Expression>> &expressions) : executor(expressions) {
-	}
+	explicit CreateIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
 
-	//! Local indexes build from chunks of the scanned data
 	unique_ptr<Index> local_index;
-
+	ArenaAllocator arena_allocator;
+	vector<Key> keys;
 	DataChunk key_chunk;
-	unique_ptr<GlobalSortState> global_sort_state;
-	LocalSortState local_sort_state;
-
-	RowLayout payload_layout;
-	vector<LogicalType> payload_types;
-
-	ExpressionExecutor executor;
+	vector<column_t> key_column_ids;
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContext &context) const {
@@ -44,110 +49,77 @@ unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContex
 	// create the global index
 	switch (info->index_type) {
 	case IndexType::ART: {
-		state->global_index = make_unique<ART>(storage_ids, TableIOManager::Get(*table.storage), unbound_expressions,
-		                                       info->constraint_type, table.storage->db);
+		auto &storage = table.GetStorage();
+		state->global_index = make_unique<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+		                                       info->constraint_type, storage.db, true);
 		break;
 	}
 	default:
 		throw InternalException("Unimplemented index type");
 	}
-
-	return (move(state));
+	return (std::move(state));
 }
 
 unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionContext &context) const {
-	auto &allocator = Allocator::Get(table.storage->db);
-
-	auto state = make_unique<CreateIndexLocalSinkState>(expressions);
+	auto state = make_unique<CreateIndexLocalSinkState>(context.client);
 
 	// create the local index
 	switch (info->index_type) {
 	case IndexType::ART: {
-		state->local_index = make_unique<ART>(storage_ids, TableIOManager::Get(*table.storage), unbound_expressions,
-		                                      info->constraint_type, table.storage->db);
+		auto &storage = table.GetStorage();
+		state->local_index = make_unique<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+		                                      info->constraint_type, storage.db, false);
 		break;
 	}
 	default:
 		throw InternalException("Unimplemented index type");
 	}
+	state->keys = vector<Key>(STANDARD_VECTOR_SIZE);
+	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
 
-	state->key_chunk.Initialize(allocator, state->local_index->logical_types);
-
-	// ordering of the entries of the index
-	vector<BoundOrderByNode> orders;
-	for (idx_t i = 0; i < state->local_index->logical_types.size(); i++) {
-		auto col_expr = make_unique_base<Expression, BoundReferenceExpression>(state->local_index->logical_types[i], i);
-		orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, move(col_expr));
+	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
+		state->key_column_ids.push_back(i);
 	}
-
-	// row layout of the global sort state
-	state->payload_types = state->local_index->logical_types;
-	state->payload_types.emplace_back(LogicalType::ROW_TYPE);
-	state->payload_layout.Initialize(state->payload_types);
-
-	// initialize global and local sort state
-	auto &buffer_manager = BufferManager::GetBufferManager(table.storage->db);
-	state->global_sort_state = make_unique<GlobalSortState>(buffer_manager, orders, state->payload_layout);
-	state->local_sort_state.Initialize(*state->global_sort_state, buffer_manager);
-
-	return move(state);
+	return std::move(state);
 }
 
 SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                          DataChunk &input) const {
 
-	// here, we sink all incoming data into the local_sink_state after executing the expression executor
+	D_ASSERT(input.ColumnCount() >= 2);
 	auto &lstate = (CreateIndexLocalSinkState &)lstate_p;
-
-	// resolve the expressions for this chunk
-	D_ASSERT(!lstate.executor.HasContext());
-	lstate.key_chunk.Reset();
-	lstate.executor.Execute(input, lstate.key_chunk);
-
-	// create the payload chunk
-	DataChunk payload_chunk;
-	payload_chunk.InitializeEmpty(lstate.payload_types);
-	for (idx_t i = 0; i < lstate.local_index->logical_types.size(); i++) {
-		payload_chunk.data[i].Reference(lstate.key_chunk.data[i]);
+	auto &row_identifiers = input.data[input.ColumnCount() - 1];
+
+	// generate the keys for the given input
+	lstate.key_chunk.ReferenceColumns(input, lstate.key_column_ids);
+	lstate.arena_allocator.Reset();
+	ART::GenerateKeys(lstate.arena_allocator, lstate.key_chunk, lstate.keys);
+
+	auto &storage = table.GetStorage();
+	auto art = make_unique<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
+	                            lstate.local_index->unbound_expressions, lstate.local_index->constraint_type,
+	                            storage.db, false);
+	if (!art->ConstructFromSorted(lstate.key_chunk.size(), lstate.keys, row_identifiers)) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
-	payload_chunk.data[lstate.payload_types.size() - 1].Reference(input.data[input.ColumnCount() - 1]);
-	payload_chunk.SetCardinality(input.size());
-
-	// sink the chunks into the local sort state
-	lstate.local_sort_state.SinkChunk(lstate.key_chunk, payload_chunk);
 
+	// merge into the local ART
+	if (!lstate.local_index->MergeIndexes(art.get())) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                   LocalSinkState &lstate_p) const {
 
-	// here, we take the sunk data chunks and sort them
-	// then, we scan the sorted data and build a local index from it
-	// finally, we merge the local index into the global index
-
 	auto &gstate = (CreateIndexGlobalSinkState &)gstate_p;
 	auto &lstate = (CreateIndexLocalSinkState &)lstate_p;
 
-	auto &allocator = Allocator::Get(table.storage->db);
-
-	// add local state to global state, which sorts the data
-	lstate.global_sort_state->AddLocalState(lstate.local_sort_state);
-	lstate.global_sort_state->PrepareMergePhase();
-
-	// scan the sorted row data and construct the index from it
-	{
-		IndexLock local_lock;
-		lstate.local_index->InitializeLock(local_lock);
-		if (!lstate.global_sort_state->sorted_blocks.empty()) {
-			PayloadScanner scanner(*lstate.global_sort_state->sorted_blocks[0]->payload_data,
-			                       *lstate.global_sort_state);
-			lstate.local_index->ConstructAndMerge(local_lock, scanner, allocator);
-		}
-	}
-
 	// merge the local index into the global index
-	gstate.global_index->MergeIndexes(lstate.local_index.get());
+	if (!gstate.global_index->MergeIndexes(lstate.local_index.get())) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
 }
 
 SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -156,25 +128,30 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 	// here, we just set the resulting global index as the newly created index of the table
 
 	auto &state = (CreateIndexGlobalSinkState &)gstate_p;
-
-	if (!table.storage->IsRoot()) {
+	auto &storage = table.GetStorage();
+	if (!storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
 	}
 
+	state.global_index->Verify();
+	if (state.global_index->track_memory) {
+		state.global_index->buffer_manager.IncreaseUsedMemory(state.global_index->memory_size);
+	}
+
 	auto &schema = *table.schema;
-	auto index_entry = (IndexCatalogEntry *)schema.CreateIndex(context, info.get(), &table);
+	auto index_entry = (DuckIndexEntry *)schema.CreateIndex(context, info.get(), &table);
 	if (!index_entry) {
 		// index already exists, but error ignored because of IF NOT EXISTS
 		return SinkFinalizeType::READY;
 	}
 
 	index_entry->index = state.global_index.get();
-	index_entry->info = table.storage->info;
+	index_entry->info = storage.info;
 	for (auto &parsed_expr : info->parsed_expressions) {
 		index_entry->parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
-	table.storage->info->indexes.AddIndex(move(state.global_index));
+	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry *schema,
                                          unique_ptr<BoundCreateTableInfo> info, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TABLE, op.types, estimated_cardinality), schema(schema),
-      info(move(info)) {
+      info(std::move(info)) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TYPE, {LogicalType::BIGINT}, estimated_cardinality),
-      info(move(info)) {
+      info(std::move(info)) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -1,6 +1,10 @@
 #include "duckdb/execution/operator/schema/physical_drop.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -39,6 +43,24 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 		db_manager.DetachDatabase(context.client, info->name, info->if_exists);
 		break;
 	}
+	case CatalogType::SCHEMA_ENTRY: {
+		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+		catalog.DropEntry(context.client, info.get());
+		auto qualified_name = QualifiedName::Parse(info->name);
+
+		// Check if the dropped schema was set as the current schema
+		auto &client_data = ClientData::Get(context.client);
+		auto &default_entry = client_data.catalog_search_path->GetDefault();
+		auto &current_catalog = default_entry.catalog;
+		auto &current_schema = default_entry.schema;
+		D_ASSERT(info->name != DEFAULT_SCHEMA);
+
+		if (info->catalog == current_catalog && current_schema == info->name) {
+			// Reset the schema to default
+			SchemaSetting::SetLocal(context.client, DEFAULT_SCHEMA);
+		}
+		break;
+	}
 	default: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 		catalog.DropEntry(context.client, info.get());

package/src/duckdb/src/execution/operator/set/physical_recursive_cte.cpp

@@ -14,9 +14,10 @@ namespace duckdb {
 
 PhysicalRecursiveCTE::PhysicalRecursiveCTE(vector<LogicalType> types, bool union_all, unique_ptr<PhysicalOperator> top,
                                            unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::RECURSIVE_CTE, move(types), estimated_cardinality), union_all(union_all) {
-	children.push_back(move(top));
-	children.push_back(move(bottom));
+    : PhysicalOperator(PhysicalOperatorType::RECURSIVE_CTE, std::move(types), estimated_cardinality),
+      union_all(union_all) {
+	children.push_back(std::move(top));
+	children.push_back(std::move(bottom));
 }
 
 PhysicalRecursiveCTE::~PhysicalRecursiveCTE() {

package/src/duckdb/src/execution/operator/set/physical_union.cpp

@@ -8,9 +8,9 @@ namespace duckdb {
 
 PhysicalUnion::PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top,
                              unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::UNION, move(types), estimated_cardinality) {
-	children.push_back(move(top));
-	children.push_back(move(bottom));
+    : PhysicalOperator(PhysicalOperatorType::UNION, std::move(types), estimated_cardinality) {
+	children.push_back(std::move(top));
+	children.push_back(std::move(bottom));
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/partitionable_hashtable.cpp

@@ -48,9 +48,9 @@ PartitionableHashTable::PartitionableHashTable(ClientContext &context, Allocator
                                                RadixPartitionInfo &partition_info_p, vector<LogicalType> group_types_p,
                                                vector<LogicalType> payload_types_p,
                                                vector<BoundAggregateExpression *> bindings_p)
-    : context(context), allocator(allocator), group_types(move(group_types_p)), payload_types(move(payload_types_p)),
-      bindings(move(bindings_p)), is_partitioned(false), partition_info(partition_info_p), hashes(LogicalType::HASH),
-      hashes_subset(LogicalType::HASH) {
+    : context(context), allocator(allocator), group_types(std::move(group_types_p)),
+      payload_types(std::move(payload_types_p)), bindings(std::move(bindings_p)), is_partitioned(false),
+      partition_info(partition_info_p), hashes(LogicalType::HASH), hashes_subset(LogicalType::HASH) {
 
 	sel_vectors.resize(partition_info.n_partitions);
 	sel_vector_sizes.resize(partition_info.n_partitions);
@@ -159,11 +159,11 @@ HashTableList PartitionableHashTable::GetPartition(idx_t partition) {
 	D_ASSERT(IsPartitioned());
 	D_ASSERT(partition < partition_info.n_partitions);
 	D_ASSERT(radix_partitioned_hts.size() > partition);
-	return move(radix_partitioned_hts[partition]);
+	return std::move(radix_partitioned_hts[partition]);
 }
 HashTableList PartitionableHashTable::GetUnpartitioned() {
 	D_ASSERT(!IsPartitioned());
-	return move(unpartitioned_hts);
+	return std::move(unpartitioned_hts);
 }
 
 void PartitionableHashTable::Finalize() {

package/src/duckdb/src/execution/perfect_aggregate_hashtable.cpp

@@ -9,9 +9,9 @@ PerfectAggregateHashTable::PerfectAggregateHashTable(ClientContext &context, All
                                                      vector<LogicalType> payload_types_p,
                                                      vector<AggregateObject> aggregate_objects_p,
                                                      vector<Value> group_minima_p, vector<idx_t> required_bits_p)
-    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, move(payload_types_p)),
-      addresses(LogicalType::POINTER), required_bits(move(required_bits_p)), total_required_bits(0),
-      group_minima(move(group_minima_p)), sel(STANDARD_VECTOR_SIZE) {
+    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
+      addresses(LogicalType::POINTER), required_bits(std::move(required_bits_p)), total_required_bits(0),
+      group_minima(std::move(group_minima_p)), sel(STANDARD_VECTOR_SIZE) {
 	for (auto &group_bits : required_bits) {
 		total_required_bits += group_bits;
 	}
@@ -19,7 +19,7 @@ PerfectAggregateHashTable::PerfectAggregateHashTable(ClientContext &context, All
 	total_groups = (uint64_t)1 << total_required_bits;
 	// we don't need to store the groups in a perfect hash table, since the group keys can be deduced by their location
 	grouping_columns = group_types_p.size();
-	layout.Initialize(move(aggregate_objects_p));
+	layout.Initialize(std::move(aggregate_objects_p));
 	tuple_size = layout.GetRowWidth();
 
 	// allocate and null initialize the data

package/src/duckdb/src/execution/physical_operator.cpp

@@ -230,7 +230,7 @@ bool CachingPhysicalOperator::CanCacheType(const LogicalType &type) {
 
 CachingPhysicalOperator::CachingPhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types_p,
                                                  idx_t estimated_cardinality)
-    : PhysicalOperator(type, move(types_p), estimated_cardinality) {
+    : PhysicalOperator(type, std::move(types_p), estimated_cardinality) {
 
 	caching_supported = true;
 	for (auto &col_type : types) {

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -123,7 +123,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	plan = ExtractAggregateExpressions(move(plan), op.expressions, op.groups);
+	plan = ExtractAggregateExpressions(std::move(plan), op.expressions, op.groups);
 
 	if (op.groups.empty()) {
 		// no groups, check if we can use a simple aggregation
@@ -138,11 +138,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 			}
 		}
 		if (use_simple_aggregation) {
-			groupby = make_unique_base<PhysicalOperator, PhysicalUngroupedAggregate>(op.types, move(op.expressions),
-			                                                                         op.estimated_cardinality);
+			groupby = make_unique_base<PhysicalOperator, PhysicalUngroupedAggregate>(
+			    op.types, std::move(op.expressions), op.estimated_cardinality);
 		} else {
-			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(context, op.types, move(op.expressions),
-			                                                                    op.estimated_cardinality);
+			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(
+			    context, op.types, std::move(op.expressions), op.estimated_cardinality);
 		}
 	} else {
 		// groups! create a GROUP BY aggregator
@@ -150,15 +150,15 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 		vector<idx_t> required_bits;
 		if (CanUsePerfectHashAggregate(context, op, required_bits)) {
 			groupby = make_unique_base<PhysicalOperator, PhysicalPerfectHashAggregate>(
-			    context, op.types, move(op.expressions), move(op.groups), move(op.group_stats), move(required_bits),
-			    op.estimated_cardinality);
+			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.group_stats),
+			    std::move(required_bits), op.estimated_cardinality);
 		} else {
 			groupby = make_unique_base<PhysicalOperator, PhysicalHashAggregate>(
-			    context, op.types, move(op.expressions), move(op.groups), move(op.grouping_sets),
-			    move(op.grouping_functions), op.estimated_cardinality);
+			    context, op.types, std::move(op.expressions), std::move(op.groups), std::move(op.grouping_sets),
+			    std::move(op.grouping_functions), op.estimated_cardinality);
 		}
 	}
-	groupby->children.push_back(move(plan));
+	groupby->children.push_back(std::move(plan));
 	return groupby;
 }
 
@@ -172,8 +172,8 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 	for (auto &group : groups) {
 		auto ref = make_unique<BoundReferenceExpression>(group->return_type, expressions.size());
 		types.push_back(group->return_type);
-		expressions.push_back(move(group));
-		group = move(ref);
+		expressions.push_back(std::move(group));
+		group = std::move(ref);
 	}
 
 	for (auto &aggr : aggregates) {
@@ -181,23 +181,24 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 		for (auto &child : bound_aggr.children) {
 			auto ref = make_unique<BoundReferenceExpression>(child->return_type, expressions.size());
 			types.push_back(child->return_type);
-			expressions.push_back(move(child));
-			child = move(ref);
+			expressions.push_back(std::move(child));
+			child = std::move(ref);
 		}
 		if (bound_aggr.filter) {
 			auto &filter = bound_aggr.filter;
 			auto ref = make_unique<BoundReferenceExpression>(filter->return_type, expressions.size());
 			types.push_back(filter->return_type);
-			expressions.push_back(move(filter));
-			bound_aggr.filter = move(ref);
+			expressions.push_back(std::move(filter));
+			bound_aggr.filter = std::move(ref);
 		}
 	}
 	if (expressions.empty()) {
 		return child;
 	}
-	auto projection = make_unique<PhysicalProjection>(move(types), move(expressions), child->estimated_cardinality);
-	projection->children.push_back(move(child));
-	return move(projection);
+	auto projection =
+	    make_unique<PhysicalProjection>(std::move(types), std::move(expressions), child->estimated_cardinality);
+	projection->children.push_back(std::move(child));
+	return std::move(projection);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_any_join.cpp

@@ -13,8 +13,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAnyJoin &o
 	auto right = CreatePlan(*op.children[1]);
 
 	// create the blockwise NL join
-	return make_unique<PhysicalBlockwiseNLJoin>(op, move(left), move(right), move(op.condition), op.join_type,
-	                                            op.estimated_cardinality);
+	return make_unique<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(op.condition),
+	                                            op.join_type, op.estimated_cardinality);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_column_data_get.cpp

@@ -11,9 +11,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalColumnData
 	// create a PhysicalChunkScan pointing towards the owned collection
 	auto chunk_scan =
 	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = move(op.collection);
+	chunk_scan->owned_collection = std::move(op.collection);
 	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb