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

package/src/duckdb/src/storage/statistics/list_statistics.cpp

@@ -6,7 +6,7 @@
 
 namespace duckdb {
 
-ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
+ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(std::move(type_p), StatisticsType::LOCAL_STATS) {
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	InitializeBase();
 	auto &child_type = ListType::GetChildType(type);
@@ -35,7 +35,7 @@ unique_ptr<BaseStatistics> ListStatistics::Copy() const {
 	result->CopyBase(*this);
 
 	result->child_stats = child_stats ? child_stats->Copy() : nullptr;
-	return move(result);
+	return std::move(result);
 }
 
 void ListStatistics::Serialize(FieldWriter &writer) const {
@@ -44,10 +44,10 @@ void ListStatistics::Serialize(FieldWriter &writer) const {
 
 unique_ptr<BaseStatistics> ListStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto result = make_unique<ListStatistics>(move(type));
+	auto result = make_unique<ListStatistics>(std::move(type));
 	auto &child_type = ListType::GetChildType(result->type);
 	result->child_stats = reader.ReadRequiredSerializable<BaseStatistics>(child_type);
-	return move(result);
+	return std::move(result);
 }
 
 string ListStatistics::ToString() const {

package/src/duckdb/src/storage/statistics/numeric_statistics.cpp

@@ -15,14 +15,14 @@ void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entr
 }
 
 NumericStatistics::NumericStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type) {
+    : BaseStatistics(std::move(type_p), stats_type) {
 	InitializeBase();
 	min = Value::MaximumValue(type);
 	max = Value::MinimumValue(type);
 }
 
 NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type), min(move(min_p)), max(move(max_p)) {
+    : BaseStatistics(std::move(type_p), stats_type), min(std::move(min_p)), max(std::move(max_p)) {
 	InitializeBase();
 }
 
@@ -117,22 +117,120 @@ FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_
 unique_ptr<BaseStatistics> NumericStatistics::Copy() const {
 	auto result = make_unique<NumericStatistics>(type, min, max, stats_type);
 	result->CopyBase(*this);
-	return move(result);
+	return std::move(result);
 }
 
 bool NumericStatistics::IsConstant() const {
 	return max <= min;
 }
 
+void SerializeNumericStatsValue(const Value &val, FieldWriter &writer) {
+	writer.WriteField<bool>(val.IsNull());
+	if (val.IsNull()) {
+		return;
+	}
+	switch (val.type().InternalType()) {
+	case PhysicalType::BOOL:
+		writer.WriteField<bool>(BooleanValue::Get(val));
+		break;
+	case PhysicalType::INT8:
+		writer.WriteField<int8_t>(TinyIntValue::Get(val));
+		break;
+	case PhysicalType::INT16:
+		writer.WriteField<int16_t>(SmallIntValue::Get(val));
+		break;
+	case PhysicalType::INT32:
+		writer.WriteField<int32_t>(IntegerValue::Get(val));
+		break;
+	case PhysicalType::INT64:
+		writer.WriteField<int64_t>(BigIntValue::Get(val));
+		break;
+	case PhysicalType::UINT8:
+		writer.WriteField<int8_t>(UTinyIntValue::Get(val));
+		break;
+	case PhysicalType::UINT16:
+		writer.WriteField<int16_t>(USmallIntValue::Get(val));
+		break;
+	case PhysicalType::UINT32:
+		writer.WriteField<int32_t>(UIntegerValue::Get(val));
+		break;
+	case PhysicalType::UINT64:
+		writer.WriteField<int64_t>(UBigIntValue::Get(val));
+		break;
+	case PhysicalType::INT128:
+		writer.WriteField<hugeint_t>(HugeIntValue::Get(val));
+		break;
+	case PhysicalType::FLOAT:
+		writer.WriteField<float>(FloatValue::Get(val));
+		break;
+	case PhysicalType::DOUBLE:
+		writer.WriteField<double>(DoubleValue::Get(val));
+		break;
+	default:
+		throw InternalException("Unsupported type for serializing numeric statistics");
+	}
+}
+
 void NumericStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(min);
-	writer.WriteSerializable(max);
+	SerializeNumericStatsValue(min, writer);
+	SerializeNumericStatsValue(max, writer);
+}
+
+Value DeserializeNumericStatsValue(const LogicalType &type, FieldReader &reader) {
+	auto is_null = reader.ReadRequired<bool>();
+	if (is_null) {
+		return Value(type);
+	}
+	Value result;
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+		result = Value::BOOLEAN(reader.ReadRequired<bool>());
+		break;
+	case PhysicalType::INT8:
+		result = Value::TINYINT(reader.ReadRequired<int8_t>());
+		break;
+	case PhysicalType::INT16:
+		result = Value::SMALLINT(reader.ReadRequired<int16_t>());
+		break;
+	case PhysicalType::INT32:
+		result = Value::INTEGER(reader.ReadRequired<int32_t>());
+		break;
+	case PhysicalType::INT64:
+		result = Value::BIGINT(reader.ReadRequired<int64_t>());
+		break;
+	case PhysicalType::UINT8:
+		result = Value::UTINYINT(reader.ReadRequired<uint8_t>());
+		break;
+	case PhysicalType::UINT16:
+		result = Value::USMALLINT(reader.ReadRequired<uint16_t>());
+		break;
+	case PhysicalType::UINT32:
+		result = Value::UINTEGER(reader.ReadRequired<uint32_t>());
+		break;
+	case PhysicalType::UINT64:
+		result = Value::UBIGINT(reader.ReadRequired<uint64_t>());
+		break;
+	case PhysicalType::INT128:
+		result = Value::HUGEINT(reader.ReadRequired<hugeint_t>());
+		break;
+	case PhysicalType::FLOAT:
+		result = Value::FLOAT(reader.ReadRequired<float>());
+		break;
+	case PhysicalType::DOUBLE:
+		result = Value::DOUBLE(reader.ReadRequired<double>());
+		break;
+	default:
+		throw InternalException("Unsupported type for deserializing numeric statistics");
+	}
+	result.Reinterpret(type);
+	return result;
 }
 
 unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto min = reader.ReadRequiredSerializable<Value, Value>();
-	auto max = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique_base<BaseStatistics, NumericStatistics>(move(type), min, max, StatisticsType::LOCAL_STATS);
+	auto min = DeserializeNumericStatsValue(type, reader);
+	auto max = DeserializeNumericStatsValue(type, reader);
+	return make_unique_base<BaseStatistics, NumericStatistics>(std::move(type), std::move(min), std::move(max),
+	                                                           StatisticsType::LOCAL_STATS);
 }
 
 string NumericStatistics::ToString() const {

package/src/duckdb/src/storage/statistics/segment_statistics.cpp

@@ -4,12 +4,12 @@
 
 namespace duckdb {
 
-SegmentStatistics::SegmentStatistics(LogicalType type) : type(move(type)) {
+SegmentStatistics::SegmentStatistics(LogicalType type) : type(std::move(type)) {
 	Reset();
 }
 
 SegmentStatistics::SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> stats)
-    : type(move(type)), statistics(move(stats)) {
+    : type(std::move(type)), statistics(std::move(stats)) {
 	if (!statistics) {
 		Reset();
 	}

package/src/duckdb/src/storage/statistics/string_statistics.cpp

@@ -8,7 +8,7 @@
 namespace duckdb {
 
 StringStatistics::StringStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(move(type_p), stats_type) {
+    : BaseStatistics(std::move(type_p), stats_type) {
 	InitializeBase();
 	for (idx_t i = 0; i < MAX_STRING_MINMAX_SIZE; i++) {
 		min[i] = 0xFF;
@@ -27,7 +27,7 @@ unique_ptr<BaseStatistics> StringStatistics::Copy() const {
 	memcpy(result->max, max, MAX_STRING_MINMAX_SIZE);
 	result->has_unicode = has_unicode;
 	result->max_string_length = max_string_length;
-	return move(result);
+	return std::move(result);
 }
 
 void StringStatistics::Serialize(FieldWriter &writer) const {
@@ -39,13 +39,13 @@ void StringStatistics::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<BaseStatistics> StringStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto stats = make_unique<StringStatistics>(move(type), StatisticsType::LOCAL_STATS);
+	auto stats = make_unique<StringStatistics>(std::move(type), StatisticsType::LOCAL_STATS);
 	reader.ReadBlob(stats->min, MAX_STRING_MINMAX_SIZE);
 	reader.ReadBlob(stats->max, MAX_STRING_MINMAX_SIZE);
 	stats->has_unicode = reader.ReadRequired<bool>();
 	stats->max_string_length = reader.ReadRequired<uint32_t>();
 	stats->has_overflow_strings = reader.ReadRequired<bool>();
-	return move(stats);
+	return std::move(stats);
 }
 
 static int StringValueComparison(const_data_ptr_t data, idx_t len, const_data_ptr_t comparison) {

package/src/duckdb/src/storage/statistics/struct_statistics.cpp

@@ -5,7 +5,8 @@
 
 namespace duckdb {
 
-StructStatistics::StructStatistics(LogicalType type_p) : BaseStatistics(move(type_p), StatisticsType::LOCAL_STATS) {
+StructStatistics::StructStatistics(LogicalType type_p)
+    : BaseStatistics(std::move(type_p), StatisticsType::LOCAL_STATS) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
 	InitializeBase();
 
@@ -43,7 +44,7 @@ unique_ptr<BaseStatistics> StructStatistics::Copy() const {
 	for (idx_t i = 0; i < child_stats.size(); i++) {
 		result->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
 	}
-	return move(result);
+	return std::move(result);
 }
 
 void StructStatistics::Serialize(FieldWriter &writer) const {
@@ -59,7 +60,7 @@ void StructStatistics::Serialize(FieldWriter &writer) const {
 
 unique_ptr<BaseStatistics> StructStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto result = make_unique<StructStatistics>(move(type));
+	auto result = make_unique<StructStatistics>(std::move(type));
 	auto &child_types = StructType::GetChildTypes(result->type);
 
 	auto child_type_count = reader.ReadRequired<uint32_t>();
@@ -75,7 +76,7 @@ unique_ptr<BaseStatistics> StructStatistics::Deserialize(FieldReader &reader, Lo
 			result->child_stats[i].reset();
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 string StructStatistics::ToString() const {

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 41;
+const uint64_t VERSION_NUMBER = 43;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/src/storage/storage_manager.cpp

@@ -16,7 +16,7 @@
 namespace duckdb {
 
 StorageManager::StorageManager(AttachedDatabase &db, string path_p, bool read_only)
-    : db(db), path(move(path_p)), read_only(read_only) {
+    : db(db), path(std::move(path_p)), read_only(read_only) {
 	if (path.empty()) {
 		path = ":memory:";
 	}
@@ -81,7 +81,7 @@ public:
 };
 
 SingleFileStorageManager::SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only)
-    : StorageManager(db, move(path), read_only) {
+    : StorageManager(db, std::move(path), read_only) {
 }
 
 void SingleFileStorageManager::LoadDatabase() {
@@ -107,11 +107,15 @@ void SingleFileStorageManager::LoadDatabase() {
 			fs.RemoveFile(wal_path);
 		}
 		// initialize the block manager while creating a new db file
-		block_manager = make_unique<SingleFileBlockManager>(db, path, read_only, true, config.options.use_direct_io);
+		auto sf_block_manager = make_unique<SingleFileBlockManager>(db, path, read_only, config.options.use_direct_io);
+		sf_block_manager->CreateNewDatabase();
+		block_manager = std::move(sf_block_manager);
 		table_io_manager = make_unique<SingleFileTableIOManager>(*block_manager);
 	} else {
 		// initialize the block manager while loading the current db file
-		block_manager = make_unique<SingleFileBlockManager>(db, path, read_only, false, config.options.use_direct_io);
+		auto sf_block_manager = make_unique<SingleFileBlockManager>(db, path, read_only, config.options.use_direct_io);
+		sf_block_manager->LoadExistingDatabase();
+		block_manager = std::move(sf_block_manager);
 		table_io_manager = make_unique<SingleFileTableIOManager>(*block_manager);
 
 		//! Load from storage

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

@@ -95,7 +95,7 @@ unique_ptr<ChunkInfo> ChunkConstantInfo::Deserialize(Deserializer &source) {
 	auto info = make_unique<ChunkConstantInfo>(start);
 	info->insert_id = 0;
 	info->delete_id = 0;
-	return move(info);
+	return std::move(info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -256,7 +256,7 @@ unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
 			result->deleted[i] = 0;
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

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

@@ -24,7 +24,7 @@ ColumnCheckpointState::~ColumnCheckpointState() {
 
 unique_ptr<BaseStatistics> ColumnCheckpointState::GetStatistics() {
 	D_ASSERT(global_stats);
-	return move(global_stats);
+	return std::move(global_stats);
 }
 
 struct PartialBlockForCheckpoint : PartialBlock {
@@ -134,7 +134,7 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_
 			    &column_data, segment.get(), *allocation.block_manager, allocation.state);
 		}
 		// Writer will decide whether to reuse this block.
-		partial_block_manager.RegisterPartialBlock(move(allocation));
+		partial_block_manager.RegisterPartialBlock(std::move(allocation));
 	} else {
 		// constant block: no need to write anything to disk besides the stats
 		// set up the compression function to constant
@@ -158,8 +158,8 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_
 	data_pointer.statistics = segment->stats.statistics->Copy();
 
 	// append the segment to the new segment tree
-	new_tree.AppendSegment(move(segment));
-	data_pointers.push_back(move(data_pointer));
+	new_tree.AppendSegment(std::move(segment));
+	data_pointers.push_back(std::move(data_pointer));
 }
 
 void ColumnCheckpointState::WriteDataPointers(RowGroupWriter &writer) {

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

@@ -14,19 +14,21 @@
 
 #include "duckdb/storage/table/struct_column_data.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
 ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
                        LogicalType type, ColumnData *parent)
-    : block_manager(block_manager), info(info), column_index(column_index), start(start_row), type(move(type)),
+    : block_manager(block_manager), info(info), column_index(column_index), start(start_row), type(std::move(type)),
       parent(parent), version(0) {
 }
 
 ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
     : block_manager(other.block_manager), info(other.info), column_index(other.column_index), start(start),
-      type(move(other.type)), parent(parent), updates(move(other.updates)), version(parent ? parent->version + 1 : 0) {
+      type(std::move(other.type)), parent(parent), updates(std::move(other.updates)),
+      version(parent ? parent->version + 1 : 0) {
 	idx_t offset = 0;
 	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
 		auto &other = (ColumnSegment &)*segment;
@@ -124,7 +126,7 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 			if (!state.current->next) {
 				break;
 			}
-			state.previous_states.emplace_back(move(state.scan_state));
+			state.previous_states.emplace_back(std::move(state.scan_state));
 			state.current = (ColumnSegment *)state.current->Next();
 			state.current->InitializeScan(state);
 			state.segment_checked = false;
@@ -349,7 +351,7 @@ void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
 #endif
 	}
 	auto new_segment = ColumnSegment::CreateTransientSegment(GetDatabase(), type, start_row, segment_size);
-	data.AppendSegment(l, move(new_segment));
+	data.AppendSegment(l, std::move(new_segment));
 }
 
 void ColumnData::CommitDropColumn() {
@@ -396,7 +398,7 @@ unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group,
 	lock_guard<mutex> update_guard(update_lock);
 
 	ColumnDataCheckpointer checkpointer(*this, row_group, *checkpoint_state, checkpoint_info);
-	checkpointer.Checkpoint(move(nodes));
+	checkpointer.Checkpoint(std::move(nodes));
 
 	// replace the old tree with the new one
 	data.Replace(l, checkpoint_state->new_tree);
@@ -422,8 +424,8 @@ void ColumnData::DeserializeColumn(Deserializer &source) {
 		auto segment = ColumnSegment::CreatePersistentSegment(
 		    GetDatabase(), block_manager, data_pointer.block_pointer.block_id, data_pointer.block_pointer.offset, type,
 		    data_pointer.row_start, data_pointer.tuple_count, data_pointer.compression_type,
-		    move(data_pointer.statistics));
-		data.AppendSegment(move(segment));
+		    std::move(data_pointer.statistics));
+		data.AppendSegment(std::move(segment));
 	}
 }
 
@@ -435,7 +437,7 @@ shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, Data
 	return entry;
 }
 
-void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, vector<vector<Value>> &result) {
+void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
 	D_ASSERT(!col_path.empty());
 
 	// convert the column path to a string
@@ -452,42 +454,30 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, v
 	idx_t segment_idx = 0;
 	auto segment = (ColumnSegment *)data.GetRootSegment();
 	while (segment) {
-		vector<Value> column_info;
-		// row_group_id
-		column_info.push_back(Value::BIGINT(row_group_index));
-		// column_id
-		column_info.push_back(Value::BIGINT(col_path[0]));
-		// column_path
-		column_info.emplace_back(col_path_str);
-		// segment_id
-		column_info.push_back(Value::BIGINT(segment_idx));
-		// segment_type
-		column_info.emplace_back(type.ToString());
-		// start
-		column_info.push_back(Value::BIGINT(segment->start));
-		// count
-		column_info.push_back(Value::BIGINT(segment->count));
-		// compression
-		column_info.emplace_back(CompressionTypeToString(segment->function->type));
-		// stats
-		column_info.emplace_back(segment->stats.statistics ? segment->stats.statistics->ToString()
-		                                                   : string("No Stats"));
-		// has_updates
-		column_info.push_back(Value::BOOLEAN(updates ? true : false));
+		ColumnSegmentInfo column_info;
+		column_info.row_group_index = row_group_index;
+		;
+		column_info.column_id = col_path[0];
+		column_info.column_path = col_path_str;
+		column_info.segment_idx = segment_idx;
+		column_info.segment_type = type.ToString();
+		column_info.segment_start = segment->start;
+		column_info.segment_count = segment->count;
+		column_info.compression_type = CompressionTypeToString(segment->function->type);
+		column_info.segment_stats =
+		    segment->stats.statistics ? segment->stats.statistics->ToString() : string("No Stats");
+		column_info.has_updates = updates ? true : false;
 		// persistent
 		// block_id
 		// block_offset
 		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			column_info.push_back(Value::BOOLEAN(true));
-			column_info.push_back(Value::BIGINT(segment->GetBlockId()));
-			column_info.push_back(Value::BIGINT(segment->GetBlockOffset()));
+			column_info.persistent = true;
+			column_info.block_id = segment->GetBlockId();
+			column_info.block_offset = segment->GetBlockOffset();
 		} else {
-			column_info.push_back(Value::BOOLEAN(false));
-			column_info.emplace_back();
-			column_info.emplace_back();
+			column_info.persistent = false;
 		}
-
-		result.push_back(move(column_info));
+		result.column_segments.push_back(std::move(column_info));
 
 		segment_idx++;
 		segment = (ColumnSegment *)segment->Next();

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

@@ -144,7 +144,7 @@ unique_ptr<AnalyzeState> ColumnDataCheckpointer::DetectBestCompressionMethod(idx
 		if (score < best_score || forced_method_found) {
 			compression_idx = i;
 			best_score = score;
-			state = move(analyze_states[i]);
+			state = std::move(analyze_states[i]);
 		}
 		//! If we have found the forced method, we're done
 		if (forced_method_found) {
@@ -184,7 +184,7 @@ void ColumnDataCheckpointer::WriteToDisk() {
 
 	// now that we have analyzed the compression functions we can start writing to disk
 	auto best_function = compression_functions[compression_idx];
-	auto compress_state = best_function->init_compression(*this, move(analyze_state));
+	auto compress_state = best_function->init_compression(*this, std::move(analyze_state));
 	ScanSegments(
 	    [&](Vector &scan_vector, idx_t count) { best_function->compress(*compress_state, scan_vector, count); });
 	best_function->compress_finalize(*compress_state);
@@ -230,15 +230,15 @@ void ColumnDataCheckpointer::WritePersistentSegments() {
 		state.global_stats->Merge(*segment->stats.statistics);
 
 		// directly append the current segment to the new tree
-		state.new_tree.AppendSegment(move(nodes[segment_idx].node));
+		state.new_tree.AppendSegment(std::move(nodes[segment_idx].node));
 
-		state.data_pointers.push_back(move(pointer));
+		state.data_pointers.push_back(std::move(pointer));
 	}
 }
 
 void ColumnDataCheckpointer::Checkpoint(vector<SegmentNode> nodes) {
 	D_ASSERT(!nodes.empty());
-	this->nodes = move(nodes);
+	this->nodes = std::move(nodes);
 	// first check if any of the segments have changes
 	if (!HasChanges()) {
 		// no changes: only need to write the metadata for this column

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

@@ -31,8 +31,8 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
 		block = block_manager.RegisterBlock(block_id);
 	}
 	auto segment_size = Storage::BLOCK_SIZE;
-	return make_unique<ColumnSegment>(db, move(block), type, ColumnSegmentType::PERSISTENT, start, count, function,
-	                                  move(statistics), block_id, offset, segment_size);
+	return make_unique<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, function,
+	                                  std::move(statistics), block_id, offset, segment_size);
 }
 
 unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance &db, const LogicalType &type,
@@ -47,8 +47,8 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance
 	} else {
 		buffer_manager.Allocate(segment_size, false, &block);
 	}
-	return make_unique<ColumnSegment>(db, move(block), type, ColumnSegmentType::TRANSIENT, start, 0, function, nullptr,
-	                                  INVALID_BLOCK, 0, segment_size);
+	return make_unique<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, function,
+	                                  nullptr, INVALID_BLOCK, 0, segment_size);
 }
 
 unique_ptr<ColumnSegment> ColumnSegment::CreateSegment(ColumnSegment &other, idx_t start) {
@@ -59,8 +59,8 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block
                              ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction *function_p,
                              unique_ptr<BaseStatistics> statistics, block_id_t block_id_p, idx_t offset_p,
                              idx_t segment_size_p)
-    : SegmentBase(start, count), db(db), type(move(type_p)), type_size(GetTypeIdSize(type.InternalType())),
-      segment_type(segment_type), function(function_p), stats(type, move(statistics)), block(move(block)),
+    : SegmentBase(start, count), db(db), type(std::move(type_p)), type_size(GetTypeIdSize(type.InternalType())),
+      segment_type(segment_type), function(function_p), stats(type, std::move(statistics)), block(std::move(block)),
       block_id(block_id_p), offset(offset_p), segment_size(segment_size_p) {
 	D_ASSERT(function);
 	if (function->init_segment) {
@@ -69,10 +69,10 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block
 }
 
 ColumnSegment::ColumnSegment(ColumnSegment &other, idx_t start)
-    : SegmentBase(start, other.count), db(other.db), type(move(other.type)), type_size(other.type_size),
-      segment_type(other.segment_type), function(other.function), stats(move(other.stats)), block(move(other.block)),
-      block_id(other.block_id), offset(other.offset), segment_size(other.segment_size),
-      segment_state(move(other.segment_state)) {
+    : SegmentBase(start, other.count), db(other.db), type(std::move(other.type)), type_size(other.type_size),
+      segment_type(other.segment_type), function(other.function), stats(std::move(other.stats)),
+      block(std::move(other.block)), block_id(other.block_id), offset(other.offset), segment_size(other.segment_size),
+      segment_state(std::move(other.segment_state)) {
 }
 
 ColumnSegment::~ColumnSegment() {
@@ -133,7 +133,7 @@ void ColumnSegment::Resize(idx_t new_size) {
 	auto new_handle = buffer_manager.Allocate(Storage::BLOCK_SIZE, false, &new_block);
 	memcpy(new_handle.Ptr(), old_handle.Ptr(), segment_size);
 	this->block_id = new_block->BlockId();
-	this->block = move(new_block);
+	this->block = std::move(new_block);
 	this->segment_size = new_size;
 }
 
@@ -191,7 +191,7 @@ void ColumnSegment::ConvertToPersistent(BlockManager *block_manager, block_id_t
 		// non-constant block: write the block to disk
 		// the data for the block already exists in-memory of our block
 		// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-		block = block_manager->ConvertToPersistent(block_id, move(block));
+		block = block_manager->ConvertToPersistent(block_id, std::move(block));
 	}
 
 	segment_state.reset();
@@ -206,7 +206,7 @@ void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t o
 
 	block_id = block_p->BlockId();
 	offset = offset_p;
-	block = move(block_p);
+	block = std::move(block_p);
 
 	segment_state.reset();
 	if (function->init_segment) {
@@ -334,7 +334,7 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
 		idx_t count_total = 0;
 		SelectionVector result_sel(approved_tuple_count);
-		auto &conjunction_or = (ConjunctionOrFilter &)filter;
+		auto &conjunction_or = (const ConjunctionOrFilter &)filter;
 		for (auto &child_filter : conjunction_or.child_filters) {
 			SelectionVector temp_sel;
 			temp_sel.Initialize(sel);
@@ -360,14 +360,14 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (ConjunctionAndFilter &)filter;
+		auto &conjunction_and = (const ConjunctionAndFilter &)filter;
 		for (auto &child_filter : conjunction_and.child_filters) {
 			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
 		}
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = (const ConstantFilter &)filter;
 		// the inplace loops take the result as the last parameter
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::UINT8: {