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

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 
 ListColumnData::ListColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
                                LogicalType type_p, ColumnData *parent)
-    : ColumnData(block_manager, info, column_index, start_row, move(type_p), parent),
+    : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
       validity(block_manager, info, 0, start_row, this) {
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	auto &child_type = ListType::GetChildType(type);
@@ -31,12 +31,12 @@ void ListColumnData::InitializeScan(ColumnScanState &state) {
 	// initialize the validity segment
 	ColumnScanState validity_state;
 	validity.InitializeScan(validity_state);
-	state.child_states.push_back(move(validity_state));
+	state.child_states.push_back(std::move(validity_state));
 
 	// initialize the child scan
 	ColumnScanState child_state;
 	child_column->InitializeScan(child_state);
-	state.child_states.push_back(move(child_state));
+	state.child_states.push_back(std::move(child_state));
 }
 
 list_entry_t ListColumnData::FetchListEntry(idx_t row_idx) {
@@ -60,7 +60,7 @@ void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_
 	// initialize the validity segment
 	ColumnScanState validity_state;
 	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(move(validity_state));
+	state.child_states.push_back(std::move(validity_state));
 
 	// we need to read the list at position row_idx to get the correct row offset of the child
 	auto list_entry = FetchListEntry(row_idx);
@@ -71,7 +71,7 @@ void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_
 	if (child_offset < child_column->GetMaxEntry()) {
 		child_column->InitializeScanWithOffset(child_state, start + child_offset);
 	}
-	state.child_states.push_back(move(child_state));
+	state.child_states.push_back(std::move(child_state));
 }
 
 idx_t ListColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
@@ -155,12 +155,12 @@ void ListColumnData::InitializeAppend(ColumnAppendState &state) {
 	// initialize the validity append
 	ColumnAppendState validity_append_state;
 	validity.InitializeAppend(validity_append_state);
-	state.child_appends.push_back(move(validity_append_state));
+	state.child_appends.push_back(std::move(validity_append_state));
 
 	// initialize the child column append
 	ColumnAppendState child_append_state;
 	child_column->InitializeAppend(child_append_state);
-	state.child_appends.push_back(move(child_append_state));
+	state.child_appends.push_back(std::move(child_append_state));
 }
 
 void ListColumnData::Append(BaseStatistics &stats_p, ColumnAppendState &state, Vector &vector, idx_t count) {
@@ -279,7 +279,7 @@ void ListColumnData::FetchRow(TransactionData transaction, ColumnFetchState &sta
 	// this is because we will (potentially) fetch more than one tuple from the list child
 	if (state.child_states.empty()) {
 		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 	// fetch the list_entry_t and the validity mask for that list
 	auto segment = (ColumnSegment *)data.GetSegment(row_id);
@@ -364,8 +364,8 @@ unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group
 	auto child_state = child_column->Checkpoint(row_group, partial_block_manager, checkpoint_info);
 
 	auto &checkpoint_state = (ListColumnCheckpointState &)*base_state;
-	checkpoint_state.validity_state = move(validity_state);
-	checkpoint_state.child_state = move(child_state);
+	checkpoint_state.validity_state = std::move(validity_state);
+	checkpoint_state.child_state = std::move(child_state);
 	return base_state;
 }
 
@@ -375,7 +375,7 @@ void ListColumnData::DeserializeColumn(Deserializer &source) {
 	child_column->DeserializeColumn(source);
 }
 
-void ListColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
+void ListColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
 	col_path.push_back(0);
 	validity.GetStorageInfo(row_group_index, col_path, result);
 	col_path.back() = 1;

package/src/duckdb/src/storage/table/row_group.cpp

@@ -11,9 +11,10 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
 #include "duckdb/storage/meta_block_reader.hpp"
-#include "duckdb/transaction/transaction_manager.hpp"
+#include "duckdb/transaction/duck_transaction_manager.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 
 namespace duckdb {
 
@@ -46,16 +47,17 @@ RowGroup::RowGroup(AttachedDatabase &db, BlockManager &block_manager, DataTableI
 	// set up the statistics
 	for (auto &stats : pointer.statistics) {
 		auto stats_type = stats->type;
-		this->stats.push_back(make_shared<SegmentStatistics>(stats_type, move(stats)));
+		this->stats.push_back(make_shared<SegmentStatistics>(stats_type, std::move(stats)));
 	}
-	this->version_info = move(pointer.versions);
+	this->version_info = std::move(pointer.versions);
 
 	Verify();
 }
 
 RowGroup::RowGroup(RowGroup &row_group, idx_t start)
     : SegmentBase(start, row_group.count), db(row_group.db), block_manager(row_group.block_manager),
-      table_info(row_group.table_info), version_info(move(row_group.version_info)), stats(move(row_group.stats)) {
+      table_info(row_group.table_info), version_info(std::move(row_group.version_info)),
+      stats(std::move(row_group.stats)) {
 	for (auto &column : row_group.columns) {
 		this->columns.push_back(ColumnData::CreateColumn(*column, start));
 	}
@@ -87,7 +89,7 @@ void RowGroup::InitializeEmpty(const vector<LogicalType> &types) {
 	for (idx_t i = 0; i < types.size(); i++) {
 		auto column_data = ColumnData::CreateColumn(block_manager, GetTableInfo(), i, start, types[i]);
 		stats.push_back(make_shared<SegmentStatistics>(types[i]));
-		columns.push_back(move(column_data));
+		columns.push_back(std::move(column_data));
 	}
 }
 
@@ -175,8 +177,8 @@ unique_ptr<RowGroup> RowGroup::AlterType(const LogicalType &target_type, idx_t c
 	for (idx_t i = 0; i < columns.size(); i++) {
 		if (i == changed_idx) {
 			// this is the altered column: use the new column
-			row_group->columns.push_back(move(column_data));
-			row_group->stats.push_back(move(altered_col_stats));
+			row_group->columns.push_back(std::move(column_data));
+			row_group->stats.push_back(std::move(altered_col_stats));
 		} else {
 			// this column was not altered: use the data directly
 			row_group->columns.push_back(columns[i]);
@@ -219,8 +221,8 @@ unique_ptr<RowGroup> RowGroup::AddColumn(ColumnDefinition &new_column, Expressio
 	row_group->columns = columns;
 	row_group->stats = stats;
 	// now add the new column
-	row_group->columns.push_back(move(added_column));
-	row_group->stats.push_back(move(added_col_stats));
+	row_group->columns.push_back(std::move(added_column));
+	row_group->stats.push_back(std::move(added_col_stats));
 
 	row_group->Verify();
 	return row_group;
@@ -459,7 +461,8 @@ void RowGroup::Scan(TransactionData transaction, RowGroupScanState &state, DataC
 }
 
 void RowGroup::ScanCommitted(RowGroupScanState &state, DataChunk &result, TableScanType type) {
-	auto &transaction_manager = TransactionManager::Get(db);
+	auto &transaction_manager = DuckTransactionManager::Get(db);
+
 	auto lowest_active_start = transaction_manager.LowestActiveStart();
 	auto lowest_active_id = transaction_manager.LowestActiveId();
 	TransactionData data(lowest_active_id, lowest_active_start);
@@ -559,7 +562,7 @@ void RowGroup::AppendVersionInfo(TransactionData transaction, idx_t count) {
 			auto constant_info = make_unique<ChunkConstantInfo>(this->start + vector_idx * STANDARD_VECTOR_SIZE);
 			constant_info->insert_id = transaction.transaction_id;
 			constant_info->delete_id = NOT_DELETED_ID;
-			version_info->info[vector_idx] = move(constant_info);
+			version_info->info[vector_idx] = std::move(constant_info);
 		} else {
 			// part of a vector is encapsulated: append to that part
 			ChunkVectorInfo *info;
@@ -567,7 +570,7 @@ void RowGroup::AppendVersionInfo(TransactionData transaction, idx_t count) {
 				// first time appending to this vector: create new info
 				auto insert_info = make_unique<ChunkVectorInfo>(this->start + vector_idx * STANDARD_VECTOR_SIZE);
 				info = insert_info.get();
-				version_info->info[vector_idx] = move(insert_info);
+				version_info->info[vector_idx] = std::move(insert_info);
 			} else {
 				D_ASSERT(version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
 				// use existing vector
@@ -708,8 +711,8 @@ RowGroupWriteData RowGroup::WriteToDisk(PartialBlockManager &manager,
 		auto stats = checkpoint_state->GetStatistics();
 		D_ASSERT(stats);
 
-		result.statistics.push_back(move(stats));
-		result.states.push_back(move(checkpoint_state));
+		result.statistics.push_back(std::move(stats));
+		result.states.push_back(std::move(checkpoint_state));
 	}
 	D_ASSERT(result.states.size() == result.statistics.size());
 	return result;
@@ -727,7 +730,7 @@ RowGroupPointer RowGroup::Checkpoint(RowGroupWriter &writer, vector<unique_ptr<B
 	for (idx_t column_idx = 0; column_idx < columns.size(); column_idx++) {
 		global_stats[column_idx]->Merge(*result.statistics[column_idx]);
 	}
-	row_group_pointer.statistics = move(result.statistics);
+	row_group_pointer.statistics = std::move(result.statistics);
 
 	// construct the row group pointer and write the column meta data to disk
 	D_ASSERT(result.states.size() == columns.size());
@@ -826,7 +829,7 @@ RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const ColumnLis
 	auto &source = reader.GetSource();
 	for (auto &col : columns.Physical()) {
 		auto stats = BaseStatistics::Deserialize(source, col.Type());
-		result.statistics.push_back(move(stats));
+		result.statistics.push_back(std::move(stats));
 	}
 	for (idx_t i = 0; i < columns.PhysicalColumnCount(); i++) {
 		BlockPointer pointer;
@@ -843,7 +846,7 @@ RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const ColumnLis
 //===--------------------------------------------------------------------===//
 // GetStorageInfo
 //===--------------------------------------------------------------------===//
-void RowGroup::GetStorageInfo(idx_t row_group_index, vector<vector<Value>> &result) {
+void RowGroup::GetStorageInfo(idx_t row_group_index, TableStorageInfo &result) {
 	for (idx_t col_idx = 0; col_idx < columns.size(); col_idx++) {
 		columns[col_idx]->GetStorageInfo(row_group_index, {col_idx}, result);
 	}
@@ -920,7 +923,7 @@ void VersionDeleteState::Delete(row_t row_id) {
 			for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
 				new_info->inserted[i] = constant.insert_id.load();
 			}
-			info.version_info->info[vector_idx] = move(new_info);
+			info.version_info->info[vector_idx] = std::move(new_info);
 		}
 		D_ASSERT(info.version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
 		current_info = (ChunkVectorInfo *)info.version_info->info[vector_idx].get();

package/src/duckdb/src/storage/table/row_group_collection.cpp

@@ -11,7 +11,7 @@ namespace duckdb {
 
 RowGroupCollection::RowGroupCollection(shared_ptr<DataTableInfo> info_p, BlockManager &block_manager,
                                        vector<LogicalType> types_p, idx_t row_start_p, idx_t total_rows_p)
-    : block_manager(block_manager), total_rows(total_rows_p), info(move(info_p)), types(move(types_p)),
+    : block_manager(block_manager), total_rows(total_rows_p), info(std::move(info_p)), types(std::move(types_p)),
       row_start(row_start_p) {
 	row_groups = make_shared<SegmentTree>();
 }
@@ -35,12 +35,12 @@ void RowGroupCollection::Initialize(PersistentTableData &data) {
 	D_ASSERT(this->row_start == 0);
 	auto l = row_groups->Lock();
 	for (auto &row_group_pointer : data.row_groups) {
-		auto new_row_group = make_unique<RowGroup>(info->db, block_manager, *info, types, move(row_group_pointer));
+		auto new_row_group = make_unique<RowGroup>(info->db, block_manager, *info, types, std::move(row_group_pointer));
 		auto row_group_count = new_row_group->start + new_row_group->count;
 		if (row_group_count > this->total_rows) {
 			this->total_rows = row_group_count;
 		}
-		row_groups->AppendSegment(l, move(new_row_group));
+		row_groups->AppendSegment(l, std::move(new_row_group));
 	}
 	stats.Initialize(types, data);
 }
@@ -53,7 +53,7 @@ void RowGroupCollection::AppendRowGroup(SegmentLock &l, idx_t start_row) {
 	D_ASSERT(start_row >= row_start);
 	auto new_row_group = make_unique<RowGroup>(info->db, block_manager, *info, start_row, 0);
 	new_row_group->InitializeEmpty(types);
-	row_groups->AppendSegment(l, move(new_row_group));
+	row_groups->AppendSegment(l, std::move(new_row_group));
 }
 
 RowGroup *RowGroupCollection::GetRowGroup(int64_t index) {
@@ -151,7 +151,7 @@ bool RowGroupCollection::NextParallelScan(ClientContext &context, ParallelCollec
 	return false;
 }
 
-bool RowGroupCollection::Scan(Transaction &transaction, const vector<column_t> &column_ids,
+bool RowGroupCollection::Scan(DuckTransaction &transaction, const vector<column_t> &column_ids,
                               const std::function<bool(DataChunk &chunk)> &fun) {
 	vector<LogicalType> scan_types;
 	for (idx_t i = 0; i < column_ids.size(); i++) {
@@ -177,7 +177,7 @@ bool RowGroupCollection::Scan(Transaction &transaction, const vector<column_t> &
 	}
 }
 
-bool RowGroupCollection::Scan(Transaction &transaction, const std::function<bool(DataChunk &chunk)> &fun) {
+bool RowGroupCollection::Scan(DuckTransaction &transaction, const std::function<bool(DataChunk &chunk)> &fun) {
 	vector<column_t> column_ids;
 	column_ids.reserve(types.size());
 	for (idx_t i = 0; i < types.size(); i++) {
@@ -190,7 +190,7 @@ bool RowGroupCollection::Scan(Transaction &transaction, const std::function<bool
 // Fetch
 //===--------------------------------------------------------------------===//
 void RowGroupCollection::Fetch(TransactionData transaction, DataChunk &result, const vector<column_t> &column_ids,
-                               Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
+                               const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) {
 	// figure out which row_group to fetch from
 	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
 	idx_t count = 0;
@@ -391,7 +391,7 @@ void RowGroupCollection::MergeStorage(RowGroupCollection &data) {
 		auto &row_group = (RowGroup &)*segment;
 		auto new_group = make_unique<RowGroup>(row_group, index);
 		index += new_group->count;
-		row_groups->AppendSegment(move(new_group));
+		row_groups->AppendSegment(std::move(new_group));
 	}
 	stats.MergeStats(data.stats);
 	total_rows += data.total_rows.load();
@@ -409,7 +409,7 @@ idx_t RowGroupCollection::Delete(TransactionData transaction, DataTable *table,
 	idx_t pos = 0;
 	do {
 		idx_t start = pos;
-		auto row_group = (RowGroup *)row_groups->GetSegment(ids[pos]);
+		auto row_group = (RowGroup *)row_groups->GetSegment(ids[start]);
 		for (pos++; pos < count; pos++) {
 			D_ASSERT(ids[pos] >= 0);
 			// check if this id still belongs to this row group
@@ -487,7 +487,7 @@ void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_
 	for (idx_t i = 0; i < types.size(); i++) {
 		column_ids.push_back(i);
 	}
-	state.Initialize(move(column_ids));
+	state.Initialize(std::move(column_ids));
 
 	DataChunk result;
 	result.Initialize(GetAllocator(), types);
@@ -524,7 +524,7 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, vector<unique_ptr<B
 	     row_group = (RowGroup *)row_group->Next()) {
 		auto rowg_writer = writer.GetRowGroupWriter(*row_group);
 		auto pointer = row_group->Checkpoint(*rowg_writer, global_stats);
-		writer.AddRowGroup(move(pointer), move(rowg_writer));
+		writer.AddRowGroup(std::move(pointer), std::move(rowg_writer));
 	}
 }
 
@@ -550,9 +550,7 @@ void RowGroupCollection::CommitDropTable() {
 //===--------------------------------------------------------------------===//
 // GetStorageInfo
 //===--------------------------------------------------------------------===//
-vector<vector<Value>> RowGroupCollection::GetStorageInfo() {
-	vector<vector<Value>> result;
-
+void RowGroupCollection::GetStorageInfo(TableStorageInfo &result) {
 	auto row_group = (RowGroup *)row_groups->GetRootSegment();
 	idx_t row_group_index = 0;
 	while (row_group) {
@@ -561,8 +559,6 @@ vector<vector<Value>> RowGroupCollection::GetStorageInfo() {
 
 		row_group = (RowGroup *)row_group->Next();
 	}
-
-	return result;
 }
 
 //===--------------------------------------------------------------------===//
@@ -573,7 +569,8 @@ shared_ptr<RowGroupCollection> RowGroupCollection::AddColumn(ClientContext &cont
 	idx_t new_column_idx = types.size();
 	auto new_types = types;
 	new_types.push_back(new_column.GetType());
-	auto result = make_shared<RowGroupCollection>(info, block_manager, move(new_types), row_start, total_rows.load());
+	auto result =
+	    make_shared<RowGroupCollection>(info, block_manager, std::move(new_types), row_start, total_rows.load());
 
 	ExpressionExecutor executor(context);
 	DataChunk dummy_chunk;
@@ -595,7 +592,7 @@ shared_ptr<RowGroupCollection> RowGroupCollection::AddColumn(ClientContext &cont
 		// merge in the statistics
 		new_row_group->MergeIntoStatistics(new_column_idx, *new_column_stats.stats);
 
-		result->row_groups->AppendSegment(move(new_row_group));
+		result->row_groups->AppendSegment(std::move(new_row_group));
 		current_row_group = (RowGroup *)current_row_group->Next();
 	}
 	return result;
@@ -606,13 +603,14 @@ shared_ptr<RowGroupCollection> RowGroupCollection::RemoveColumn(idx_t col_idx) {
 	auto new_types = types;
 	new_types.erase(new_types.begin() + col_idx);
 
-	auto result = make_shared<RowGroupCollection>(info, block_manager, move(new_types), row_start, total_rows.load());
+	auto result =
+	    make_shared<RowGroupCollection>(info, block_manager, std::move(new_types), row_start, total_rows.load());
 	result->stats.InitializeRemoveColumn(stats, col_idx);
 
 	auto current_row_group = (RowGroup *)row_groups->GetRootSegment();
 	while (current_row_group) {
 		auto new_row_group = current_row_group->RemoveColumn(col_idx);
-		result->row_groups->AppendSegment(move(new_row_group));
+		result->row_groups->AppendSegment(std::move(new_row_group));
 		current_row_group = (RowGroup *)current_row_group->Next();
 	}
 	return result;
@@ -625,7 +623,8 @@ shared_ptr<RowGroupCollection> RowGroupCollection::AlterType(ClientContext &cont
 	auto new_types = types;
 	new_types[changed_idx] = target_type;
 
-	auto result = make_shared<RowGroupCollection>(info, block_manager, move(new_types), row_start, total_rows.load());
+	auto result =
+	    make_shared<RowGroupCollection>(info, block_manager, std::move(new_types), row_start, total_rows.load());
 	result->stats.InitializeAlterType(stats, changed_idx, target_type);
 
 	vector<LogicalType> scan_types;
@@ -653,7 +652,7 @@ shared_ptr<RowGroupCollection> RowGroupCollection::AlterType(ClientContext &cont
 		auto new_row_group = current_row_group->AlterType(target_type, changed_idx, executor,
 		                                                  scan_state.table_state.row_group_state, scan_chunk);
 		new_row_group->MergeIntoStatistics(changed_idx, *changed_stats.stats);
-		result->row_groups->AppendSegment(move(new_row_group));
+		result->row_groups->AppendSegment(std::move(new_row_group));
 		current_row_group = (RowGroup *)current_row_group->Next();
 	}
 

package/src/duckdb/src/storage/table/scan_state.cpp

@@ -1,12 +1,12 @@
 #include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 
 namespace duckdb {
 
 void TableScanState::Initialize(vector<column_t> column_ids, TableFilterSet *table_filters) {
-	this->column_ids = move(column_ids);
+	this->column_ids = std::move(column_ids);
 	this->table_filters = table_filters;
 	if (table_filters) {
 		D_ASSERT(table_filters->filters.size() > 0);
@@ -84,7 +84,7 @@ AdaptiveFilter *CollectionScanState::GetAdaptiveFilter() {
 	return parent.GetAdaptiveFilter();
 }
 
-bool CollectionScanState::Scan(Transaction &transaction, DataChunk &result) {
+bool CollectionScanState::Scan(DuckTransaction &transaction, DataChunk &result) {
 	auto current_row_group = row_group_state.row_group;
 	while (current_row_group) {
 		current_row_group->Scan(transaction, row_group_state, result);

package/src/duckdb/src/storage/table/segment_tree.cpp

@@ -17,7 +17,7 @@ SegmentBase *SegmentTree::GetRootSegment(SegmentLock &l) {
 }
 
 vector<SegmentNode> SegmentTree::MoveSegments(SegmentLock &) {
-	return move(nodes);
+	return std::move(nodes);
 }
 
 SegmentBase *SegmentTree::GetRootSegment() {
@@ -133,13 +133,13 @@ void SegmentTree::AppendSegment(SegmentLock &, unique_ptr<SegmentBase> segment)
 	}
 	SegmentNode node;
 	node.row_start = segment->start;
-	node.node = move(segment);
-	nodes.push_back(move(node));
+	node.node = std::move(segment);
+	nodes.push_back(std::move(node));
 }
 
 void SegmentTree::AppendSegment(unique_ptr<SegmentBase> segment) {
 	auto l = Lock();
-	AppendSegment(l, move(segment));
+	AppendSegment(l, std::move(segment));
 }
 
 void SegmentTree::EraseSegments(SegmentLock &, idx_t segment_start) {
@@ -150,7 +150,7 @@ void SegmentTree::EraseSegments(SegmentLock &, idx_t segment_start) {
 }
 
 void SegmentTree::Replace(SegmentLock &, SegmentTree &other) {
-	nodes = move(other.nodes);
+	nodes = std::move(other.nodes);
 }
 
 void SegmentTree::Replace(SegmentTree &other) {

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 
 StandardColumnData::StandardColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
                                        idx_t start_row, LogicalType type, ColumnData *parent)
-    : ColumnData(block_manager, info, column_index, start_row, move(type), parent),
+    : ColumnData(block_manager, info, column_index, start_row, std::move(type), parent),
       validity(block_manager, info, 0, start_row, this) {
 }
 
@@ -46,7 +46,7 @@ void StandardColumnData::InitializeScan(ColumnScanState &state) {
 	// initialize the validity segment
 	ColumnScanState child_state;
 	validity.InitializeScan(child_state);
-	state.child_states.push_back(move(child_state));
+	state.child_states.push_back(std::move(child_state));
 }
 
 void StandardColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
@@ -55,7 +55,7 @@ void StandardColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t
 	// initialize the validity segment
 	ColumnScanState child_state;
 	validity.InitializeScanWithOffset(child_state, row_idx);
-	state.child_states.push_back(move(child_state));
+	state.child_states.push_back(std::move(child_state));
 }
 
 idx_t StandardColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state,
@@ -85,7 +85,7 @@ void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
 
 	ColumnAppendState child_append;
 	validity.InitializeAppend(child_append);
-	state.child_appends.push_back(move(child_append));
+	state.child_appends.push_back(std::move(child_append));
 }
 
 void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
@@ -105,7 +105,7 @@ idx_t StandardColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &re
 	// fetch validity mask
 	if (state.child_states.empty()) {
 		ColumnScanState child_state;
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 	auto scan_count = ColumnData::Fetch(state, row_id, result);
 	validity.Fetch(state.child_states[0], row_id, result);
@@ -138,7 +138,7 @@ unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
 	if (!stats) {
 		stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
 	}
-	stats->validity_stats = move(validity_stats);
+	stats->validity_stats = std::move(validity_stats);
 	return stats;
 }
 
@@ -147,7 +147,7 @@ void StandardColumnData::FetchRow(TransactionData transaction, ColumnFetchState
 	// find the segment the row belongs to
 	if (state.child_states.empty()) {
 		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
 	ColumnData::FetchRow(transaction, state, row_id, result, result_idx);
@@ -170,7 +170,7 @@ public:
 	unique_ptr<BaseStatistics> GetStatistics() override {
 		D_ASSERT(global_stats);
 		global_stats->validity_stats = validity_state->GetStatistics();
-		return move(global_stats);
+		return std::move(global_stats);
 	}
 
 	void WriteDataPointers(RowGroupWriter &writer) override {
@@ -195,7 +195,7 @@ unique_ptr<ColumnCheckpointState> StandardColumnData::Checkpoint(RowGroup &row_g
 	auto validity_state = validity.Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	auto base_state = ColumnData::Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	auto &checkpoint_state = (StandardColumnCheckpointState &)*base_state;
-	checkpoint_state.validity_state = move(validity_state);
+	checkpoint_state.validity_state = std::move(validity_state);
 	return base_state;
 }
 
@@ -212,10 +212,10 @@ void StandardColumnData::DeserializeColumn(Deserializer &source) {
 	validity.DeserializeColumn(source);
 }
 
-void StandardColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
+void StandardColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
 	ColumnData::GetStorageInfo(row_group_index, col_path, result);
 	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, move(col_path), result);
+	validity.GetStorageInfo(row_group_index, std::move(col_path), result);
 }
 
 void StandardColumnData::Verify(RowGroup &parent) {

package/src/duckdb/src/storage/table/struct_column_data.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 
 StructColumnData::StructColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
                                    idx_t start_row, LogicalType type_p, ColumnData *parent)
-    : ColumnData(block_manager, info, column_index, start_row, move(type_p), parent),
+    : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
       validity(block_manager, info, 0, start_row, this) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
 	auto &child_types = StructType::GetChildTypes(type);
@@ -46,13 +46,13 @@ void StructColumnData::InitializeScan(ColumnScanState &state) {
 	// initialize the validity segment
 	ColumnScanState validity_state;
 	validity.InitializeScan(validity_state);
-	state.child_states.push_back(move(validity_state));
+	state.child_states.push_back(std::move(validity_state));
 
 	// initialize the sub-columns
 	for (auto &sub_column : sub_columns) {
 		ColumnScanState child_state;
 		sub_column->InitializeScan(child_state);
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 }
 
@@ -65,13 +65,13 @@ void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t ro
 	// initialize the validity segment
 	ColumnScanState validity_state;
 	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(move(validity_state));
+	state.child_states.push_back(std::move(validity_state));
 
 	// initialize the sub-columns
 	for (auto &sub_column : sub_columns) {
 		ColumnScanState child_state;
 		sub_column->InitializeScanWithOffset(child_state, row_idx);
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 }
 
@@ -114,12 +114,12 @@ void StructColumnData::Skip(ColumnScanState &state, idx_t count) {
 void StructColumnData::InitializeAppend(ColumnAppendState &state) {
 	ColumnAppendState validity_append;
 	validity.InitializeAppend(validity_append);
-	state.child_appends.push_back(move(validity_append));
+	state.child_appends.push_back(std::move(validity_append));
 
 	for (auto &sub_column : sub_columns) {
 		ColumnAppendState child_append;
 		sub_column->InitializeAppend(child_append);
-		state.child_appends.push_back(move(child_append));
+		state.child_appends.push_back(std::move(child_append));
 	}
 }
 
@@ -149,7 +149,7 @@ idx_t StructColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &resu
 	// insert any child states that are required
 	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
 		ColumnScanState child_state;
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 	// fetch the validity state
 	idx_t scan_count = validity.Fetch(state.child_states[0], row_id, result);
@@ -196,7 +196,7 @@ unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
 	for (idx_t i = 0; i < sub_columns.size(); i++) {
 		auto child_stats = sub_columns[i]->GetUpdateStatistics();
 		if (child_stats) {
-			struct_stats.child_stats[i] = move(child_stats);
+			struct_stats.child_stats[i] = std::move(child_stats);
 		}
 	}
 	return stats;
@@ -209,7 +209,7 @@ void StructColumnData::FetchRow(TransactionData transaction, ColumnFetchState &s
 	// insert any child states that are required
 	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
 		auto child_state = make_unique<ColumnFetchState>();
-		state.child_states.push_back(move(child_state));
+		state.child_states.push_back(std::move(child_state));
 	}
 	// fetch the validity state
 	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
@@ -245,7 +245,7 @@ public:
 			stats->child_stats[i] = child_states[i]->GetStatistics();
 			D_ASSERT(stats->child_stats[i]);
 		}
-		return move(stats);
+		return std::move(stats);
 	}
 
 	void WriteDataPointers(RowGroupWriter &writer) override {
@@ -276,7 +276,7 @@ unique_ptr<ColumnCheckpointState> StructColumnData::Checkpoint(RowGroup &row_gro
 		checkpoint_state->child_states.push_back(
 		    sub_column->Checkpoint(row_group, partial_block_manager, checkpoint_info));
 	}
-	return move(checkpoint_state);
+	return std::move(checkpoint_state);
 }
 
 void StructColumnData::DeserializeColumn(Deserializer &source) {
@@ -286,7 +286,7 @@ void StructColumnData::DeserializeColumn(Deserializer &source) {
 	}
 }
 
-void StructColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
+void StructColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
 	col_path.push_back(0);
 	validity.GetStorageInfo(row_group_index, col_path, result);
 	for (idx_t i = 0; i < sub_columns.size(); i++) {

package/src/duckdb/src/storage/table/table_statistics.cpp

@@ -8,7 +8,7 @@ void TableStatistics::Initialize(const vector<LogicalType> &types, PersistentTab
 
 	column_stats.reserve(data.column_stats.size());
 	for (auto &stats : data.column_stats) {
-		column_stats.push_back(make_shared<ColumnStatistics>(move(stats)));
+		column_stats.push_back(make_shared<ColumnStatistics>(std::move(stats)));
 	}
 	if (column_stats.size() != types.size()) { // LCOV_EXCL_START
 		throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");