duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

package/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp

@@ -0,0 +1,295 @@
+#include "duckdb/common/bitpacking.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Unpacking
+//===--------------------------------------------------------------------===//
+
+static void UnpackSingle(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta, uint16_t shr) {
+	if (delta + shr < 32) {
+		*out = ((static_cast<hugeint_t>(in[0])) >> shr) % (hugeint_t(1) << delta);
+	}
+
+	else if (delta + shr >= 32 && delta + shr < 64) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		++in;
+
+		if (delta + shr > 32) {
+			const uint16_t NEXT_SHR = shr + delta - 32;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (32 - shr);
+		}
+	}
+
+	else if (delta + shr >= 64 && delta + shr < 96) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		in += 2;
+
+		if (delta + shr > 64) {
+			const uint16_t NEXT_SHR = delta + shr - 64;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (64 - shr);
+		}
+	}
+
+	else if (delta + shr >= 96 && delta + shr < 128) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
+		in += 3;
+
+		if (delta + shr > 96) {
+			const uint16_t NEXT_SHR = delta + shr - 96;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (96 - shr);
+		}
+	}
+
+	else if (delta + shr >= 128) {
+		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
+		*out |= static_cast<hugeint_t>(in[3]) << (96 - shr);
+		in += 4;
+
+		if (delta + shr > 128) {
+			const uint16_t NEXT_SHR = delta + shr - 128;
+			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (128 - shr);
+		}
+	}
+}
+
+static void UnpackLast(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta) {
+	const uint8_t LAST_IDX = 31;
+	const uint16_t SHIFT = (delta * 31) % 32;
+	out[LAST_IDX] = in[0] >> SHIFT;
+	if (delta > 32) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[1]) << (32 - SHIFT);
+	}
+	if (delta > 64) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[2]) << (64 - SHIFT);
+	}
+	if (delta > 96) {
+		out[LAST_IDX] |= static_cast<hugeint_t>(in[3]) << (96 - SHIFT);
+	}
+}
+
+// Unpacks for specific deltas
+static void UnpackDelta0(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		out[i] = 0;
+	}
+}
+
+static void UnpackDelta32(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t k = 0; k < 32; ++k) {
+		out[k] = static_cast<hugeint_t>(in[k]);
+	}
+}
+
+static void UnpackDelta64(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 2;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+	}
+}
+
+static void UnpackDelta96(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 3;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
+	}
+}
+
+static void UnpackDelta128(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = i * 4;
+		out[i] = in[OFFSET];
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
+		out[i] |= static_cast<hugeint_t>(in[OFFSET + 3]) << 96;
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// Packing
+//===--------------------------------------------------------------------===//
+
+static void PackSingle(const hugeint_t in, uint32_t *__restrict &out, uint16_t delta, uint16_t shl, hugeint_t mask) {
+	if (delta + shl < 32) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>((in & mask) << shl);
+		}
+
+	} else if (delta + shl >= 32 && delta + shl < 64) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>((in & mask) << shl);
+		}
+		++out;
+
+		if (delta + shl > 32) {
+			*out = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		}
+	}
+
+	else if (delta + shl >= 64 && delta + shl < 96) {
+
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>(in << shl);
+		}
+
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out += 2;
+
+		if (delta + shl > 64) {
+			*out = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		}
+	}
+
+	else if (delta + shl >= 96 && delta + shl < 128) {
+		if (shl == 0) {
+			out[0] = static_cast<uint32_t>(in & mask);
+		} else {
+			out[0] |= static_cast<uint32_t>(in << shl);
+		}
+
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		out += 3;
+
+		if (delta + shl > 96) {
+			*out = static_cast<uint32_t>((in & mask) >> (96 - shl));
+		}
+	}
+
+	else if (delta + shl >= 128) {
+		// shl == 0 won't ever happen here considering a delta of 128 calls PackDelta128
+		out[0] |= static_cast<uint32_t>(in << shl);
+		out[1] = static_cast<uint32_t>((in & mask) >> (32 - shl));
+		out[2] = static_cast<uint32_t>((in & mask) >> (64 - shl));
+		out[3] = static_cast<uint32_t>((in & mask) >> (96 - shl));
+		out += 4;
+
+		if (delta + shl > 128) {
+			*out = static_cast<uint32_t>((in & mask) >> (128 - shl));
+		}
+	}
+}
+
+static void PackLast(const hugeint_t *__restrict in, uint32_t *__restrict out, uint16_t delta) {
+	const uint8_t LAST_IDX = 31;
+	const uint16_t SHIFT = (delta * 31) % 32;
+	out[0] |= static_cast<uint32_t>(in[LAST_IDX] << SHIFT);
+	if (delta > 32) {
+		out[1] = static_cast<uint32_t>(in[LAST_IDX] >> (32 - SHIFT));
+	}
+	if (delta > 64) {
+		out[2] = static_cast<uint32_t>(in[LAST_IDX] >> (64 - SHIFT));
+	}
+	if (delta > 96) {
+		out[3] = static_cast<uint32_t>(in[LAST_IDX] >> (96 - SHIFT));
+	}
+}
+
+// Packs for specific deltas
+static void PackDelta32(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		out[i] = static_cast<uint32_t>(in[i]);
+	}
+}
+
+static void PackDelta64(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 2 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+	}
+}
+
+static void PackDelta96(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 3 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
+	}
+}
+
+static void PackDelta128(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+	for (uint8_t i = 0; i < 32; ++i) {
+		const uint8_t OFFSET = 4 * i;
+		out[OFFSET] = static_cast<uint32_t>(in[i]);
+		out[OFFSET + 1] = static_cast<uint32_t>(in[i] >> 32);
+		out[OFFSET + 2] = static_cast<uint32_t>(in[i] >> 64);
+		out[OFFSET + 3] = static_cast<uint32_t>(in[i] >> 96);
+	}
+}
+
+//===--------------------------------------------------------------------===//
+// HugeIntPacker
+//===--------------------------------------------------------------------===//
+
+void HugeIntPacker::Pack(const hugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width) {
+	D_ASSERT(width <= 128);
+	switch (width) {
+	case 0:
+		break;
+	case 32:
+		PackDelta32(in, out);
+		break;
+	case 64:
+		PackDelta64(in, out);
+		break;
+	case 96:
+		PackDelta96(in, out);
+		break;
+	case 128:
+		PackDelta128(in, out);
+		break;
+	default:
+		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
+			PackSingle(in[oindex], out, width, (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE,
+			           (hugeint_t(1) << width) - 1);
+		}
+		PackLast(in, out, width);
+	}
+}
+
+void HugeIntPacker::Unpack(const uint32_t *__restrict in, hugeint_t *__restrict out, bitpacking_width_t width) {
+	D_ASSERT(width <= 128);
+	switch (width) {
+	case 0:
+		UnpackDelta0(in, out);
+		break;
+	case 32:
+		UnpackDelta32(in, out);
+		break;
+	case 64:
+		UnpackDelta64(in, out);
+		break;
+	case 96:
+		UnpackDelta96(in, out);
+		break;
+	case 128:
+		UnpackDelta128(in, out);
+		break;
+	default:
+		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
+			UnpackSingle(in, out + oindex, width,
+			             (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE);
+		}
+		UnpackLast(in, out, width);
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/compression/fsst.cpp

@@ -461,7 +461,7 @@ void FSSTStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t
 	    &sizes_in[0],         /* IN: byte-lengths of the inputs */
 	    &strings_in[0],       /* IN: input string start pointers. */
 	    compress_buffer_size, /* IN: byte-length of output buffer. */
-	    &compress_buffer[0],  /* OUT: memorxy buffer to put the compressed strings in (one after the other). */
+	    &compress_buffer[0],  /* OUT: memory buffer to put the compressed strings in (one after the other). */
 	    &sizes_out[0],        /* OUT: byte-lengths of the compressed strings. */
 	    &strings_out[0]       /* OUT: output string start pointers. Will all point into [output,output+size). */
 	);

package/src/duckdb/src/storage/compression/rle.cpp

@@ -166,8 +166,8 @@ struct RLECompressState : public CompressionState {
 	void WriteValue(T value, rle_count_t count, bool is_null) {
 		// write the RLE entry
 		auto handle_ptr = handle.Ptr() + RLEConstants::RLE_HEADER_SIZE;
-		auto data_pointer = (T *)handle_ptr;
-		auto index_pointer = (rle_count_t *)(handle_ptr + max_rle_count * sizeof(T));
+		auto data_pointer = reinterpret_cast<T *>(handle_ptr);
+		auto index_pointer = reinterpret_cast<rle_count_t *>(handle_ptr + max_rle_count * sizeof(T));
 		data_pointer[entry_count] = value;
 		index_pointer[entry_count] = count;
 		entry_count++;
@@ -257,7 +257,7 @@ struct RLEScanState : public SegmentScanState {
 
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
 		auto data = handle.Ptr() + segment.GetBlockOffset();
-		auto index_pointer = (rle_count_t *)(data + rle_count_offset);
+		auto index_pointer = reinterpret_cast<rle_count_t *>(data + rle_count_offset);
 
 		for (idx_t i = 0; i < skip_count; i++) {
 			// assign the current value
@@ -272,7 +272,6 @@ struct RLEScanState : public SegmentScanState {
 	}
 
 	BufferHandle handle;
-	uint32_t rle_offset;
 	idx_t entry_pos;
 	idx_t position_in_entry;
 	uint32_t rle_count_offset;
@@ -293,14 +292,58 @@ void RLESkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
 	scan_state.Skip(segment, skip_count);
 }
 
+static bool CanEmitConstantVector(idx_t position, idx_t run_length, idx_t scan_count) {
+	if (scan_count != STANDARD_VECTOR_SIZE) {
+		// Only when we can fill an entire Vector can we emit a ConstantVector, because subsequent scans require the
+		// input Vector to be flat
+		return false;
+	}
+	D_ASSERT(position < run_length);
+	auto remaining_in_run = run_length - position;
+	// The amount of values left in this run are equal or greater than the amount of values we need to scan
+	return remaining_in_run >= scan_count;
+}
+
+template <class T>
+inline static void ForwardToNextRun(RLEScanState<T> &scan_state) {
+	// handled all entries in this RLE value
+	// move to the next entry
+	scan_state.entry_pos++;
+	scan_state.position_in_entry = 0;
+}
+
+template <class T>
+inline static bool ExhaustedRun(RLEScanState<T> &scan_state, rle_count_t *index_pointer) {
+	return scan_state.position_in_entry >= index_pointer[scan_state.entry_pos];
+}
+
+template <class T>
+static void RLEScanConstant(RLEScanState<T> &scan_state, rle_count_t *index_pointer, T *data_pointer, idx_t scan_count,
+                            Vector &result) {
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	auto result_data = ConstantVector::GetData<T>(result);
+	result_data[0] = data_pointer[scan_state.entry_pos];
+	scan_state.position_in_entry += scan_count;
+	if (ExhaustedRun(scan_state, index_pointer)) {
+		ForwardToNextRun(scan_state);
+	}
+	return;
+}
+
 template <class T>
 void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                     idx_t result_offset) {
 	auto &scan_state = state.scan_state->Cast<RLEScanState<T>>();
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
-	auto index_pointer = (rle_count_t *)(data + scan_state.rle_count_offset);
+	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
+	auto index_pointer = reinterpret_cast<rle_count_t *>(data + scan_state.rle_count_offset);
+
+	// If we are scanning an entire Vector and it contains only a single run
+	if (CanEmitConstantVector(scan_state.position_in_entry, index_pointer[scan_state.entry_pos], scan_count)) {
+		RLEScanConstant<T>(scan_state, index_pointer, data_pointer, scan_count, result);
+		return;
+	}
 
 	auto result_data = FlatVector::GetData<T>(result);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -308,18 +351,14 @@ void RLEScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_c
 		// assign the current value
 		result_data[result_offset + i] = data_pointer[scan_state.entry_pos];
 		scan_state.position_in_entry++;
-		if (scan_state.position_in_entry >= index_pointer[scan_state.entry_pos]) {
-			// handled all entries in this RLE value
-			// move to the next entry
-			scan_state.entry_pos++;
-			scan_state.position_in_entry = 0;
+		if (ExhaustedRun(scan_state, index_pointer)) {
+			ForwardToNextRun(scan_state);
 		}
 	}
 }
 
 template <class T>
 void RLEScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
-	// FIXME: emit constant vector if repetition of single value is >= scan_count
 	RLEScanPartial<T>(segment, state, scan_count, result, 0);
 }
 
@@ -332,7 +371,7 @@ void RLEFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id,
 	scan_state.Skip(segment, row_id);
 
 	auto data = scan_state.handle.Ptr() + segment.GetBlockOffset();
-	auto data_pointer = (T *)(data + RLEConstants::RLE_HEADER_SIZE);
+	auto data_pointer = reinterpret_cast<T *>(data + RLEConstants::RLE_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<T>(result);
 	result_data[result_idx] = data_pointer[scan_state.entry_pos];
 }

package/src/duckdb/src/storage/data_table.cpp

@@ -56,7 +56,7 @@ DataTable::DataTable(AttachedDatabase &db, shared_ptr<TableIOManager> table_io_m
 	row_groups->Verify();
 }
 
-DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value)
+DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression &default_value)
     : info(parent.info), db(parent.db), is_root(true) {
 	// add the column definitions from this DataTable
 	for (auto &column_def : parent.column_definitions) {
@@ -1073,20 +1073,19 @@ void DataTable::VerifyUpdateConstraints(ClientContext &context, TableCatalogEntr
                                         const vector<PhysicalIndex> &column_ids) {
 	auto &constraints = table.GetConstraints();
 	auto &bound_constraints = table.GetBoundConstraints();
-	for (idx_t i = 0; i < bound_constraints.size(); i++) {
-		auto &base_constraint = constraints[i];
-		auto &constraint = bound_constraints[i];
+	for (idx_t constr_idx = 0; constr_idx < bound_constraints.size(); constr_idx++) {
+		auto &base_constraint = constraints[constr_idx];
+		auto &constraint = bound_constraints[constr_idx];
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
 			auto &bound_not_null = *reinterpret_cast<BoundNotNullConstraint *>(constraint.get());
 			auto &not_null = *reinterpret_cast<NotNullConstraint *>(base_constraint.get());
 			// check if the constraint is in the list of column_ids
-			// FIXME: double usage of 'i'?
-			for (idx_t i = 0; i < column_ids.size(); i++) {
-				if (column_ids[i] == bound_not_null.index) {
+			for (idx_t col_idx = 0; col_idx < column_ids.size(); col_idx++) {
+				if (column_ids[col_idx] == bound_not_null.index) {
 					// found the column id: check the data in
 					auto &col = table.GetColumn(LogicalIndex(not_null.index));
-					VerifyNotNullConstraint(table, chunk.data[i], chunk.size(), col.Name());
+					VerifyNotNullConstraint(table, chunk.data[col_idx], chunk.size(), col.Name());
 					break;
 				}
 			}
@@ -1122,10 +1121,10 @@ void DataTable::VerifyUpdateConstraints(ClientContext &context, TableCatalogEntr
 void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
                        const vector<PhysicalIndex> &column_ids, DataChunk &updates) {
 	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
-
 	D_ASSERT(column_ids.size() == updates.ColumnCount());
-	auto count = updates.size();
 	updates.Verify();
+
+	auto count = updates.size();
 	if (count == 0) {
 		return;
 	}
@@ -1138,24 +1137,36 @@ void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector
 	VerifyUpdateConstraints(context, table, updates, column_ids);
 
 	// now perform the actual update
-	auto &transaction = DuckTransaction::Get(context, db);
+	Vector max_row_id_vec(Value::BIGINT(MAX_ROW_ID));
+	Vector row_ids_slice(LogicalType::BIGINT);
+	DataChunk updates_slice;
+	updates_slice.InitializeEmpty(updates.GetTypes());
 
-	updates.Flatten();
-	row_ids.Flatten(count);
-	auto ids = FlatVector::GetData<row_t>(row_ids);
-	auto first_id = FlatVector::GetValue<row_t>(row_ids, 0);
-	if (first_id >= MAX_ROW_ID) {
-		// update is in transaction-local storage: push update into local storage
-		auto &local_storage = LocalStorage::Get(context, db);
-		local_storage.Update(*this, row_ids, column_ids, updates);
-		return;
+	SelectionVector sel_local_update(count), sel_global_update(count);
+	auto n_local_update = VectorOperations::GreaterThanEquals(row_ids, max_row_id_vec, nullptr, count,
+	                                                          &sel_local_update, &sel_global_update);
+	auto n_global_update = count - n_local_update;
+
+	// row id > MAX_ROW_ID? transaction-local storage
+	if (n_local_update > 0) {
+		updates_slice.Slice(updates, sel_local_update, n_local_update);
+		updates_slice.Flatten();
+		row_ids_slice.Slice(row_ids, sel_local_update, n_local_update);
+		row_ids_slice.Flatten(n_local_update);
+
+		LocalStorage::Get(context, db).Update(*this, row_ids_slice, column_ids, updates_slice);
 	}
 
-	// update is in the row groups
-	// we need to figure out for each id to which row group it belongs
-	// usually all (or many) ids belong to the same row group
-	// we iterate over the ids and check for every id if it belongs to the same row group as their predecessor
-	row_groups->Update(transaction, ids, column_ids, updates);
+	// otherwise global storage
+	if (n_global_update > 0) {
+		updates_slice.Slice(updates, sel_global_update, n_global_update);
+		updates_slice.Flatten();
+		row_ids_slice.Slice(row_ids, sel_global_update, n_global_update);
+		row_ids_slice.Flatten(n_global_update);
+
+		row_groups->Update(DuckTransaction::Get(context, db), FlatVector::GetData<row_t>(row_ids_slice), column_ids,
+		                   updates_slice);
+	}
 }
 
 void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,

package/src/duckdb/src/storage/index.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/execution/index/art/art.hpp"
 
 namespace duckdb {
 
@@ -47,42 +46,21 @@ void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
 }
 
 bool Index::MergeIndexes(Index &other_index) {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().MergeIndexes(state, other_index);
-	default:
-		throw InternalException("Unimplemented index type for merge");
-	}
+	return MergeIndexes(state, other_index);
 }
 
 string Index::VerifyAndToString(const bool only_verify) {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().VerifyAndToString(state, only_verify);
-	default:
-		throw InternalException("Unimplemented index type for VerifyAndToString");
-	}
+	return VerifyAndToString(state, only_verify);
 }
 
 void Index::Vacuum() {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().Vacuum(state);
-	default:
-		throw InternalException("Unimplemented index type for vacuum");
-	}
+	Vacuum(state);
 }
 
 void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {
@@ -108,7 +86,7 @@ bool Index::IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const {
 	return false;
 }
 
-BlockPointer Index::Serialize(MetaBlockWriter &writer) {
+BlockPointer Index::Serialize(MetadataWriter &writer) {
 	throw NotImplementedException("The implementation of this index serialization does not exist.");
 }
 

package/src/duckdb/src/storage/local_storage.cpp

@@ -25,7 +25,6 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 	table.info->indexes.Scan([&](Index &index) {
 		D_ASSERT(index.type == IndexType::ART);
 		auto &art = index.Cast<ART>();
-		;
 		if (art.constraint_type != IndexConstraintType::NONE) {
 			// unique index: create a local ART index that maintains the same unique constraint
 			vector<unique_ptr<Expression>> unbound_expressions;
@@ -61,11 +60,11 @@ LocalTableStorage::LocalTableStorage(DataTable &new_dt, LocalTableStorage &paren
 }
 
 LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     ColumnDefinition &new_column, optional_ptr<Expression> default_value)
+                                     ColumnDefinition &new_column, Expression &default_value)
     : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
       optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)),
       merged_storage(parent.merged_storage) {
-	row_groups = parent.row_groups->AddColumn(context, new_column, default_value.get());
+	row_groups = parent.row_groups->AddColumn(context, new_column, default_value);
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
@@ -508,7 +507,7 @@ void LocalStorage::MoveStorage(DataTable &old_dt, DataTable &new_dt) {
 }
 
 void LocalStorage::AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
-                             optional_ptr<Expression> default_value) {
+                             Expression &default_value) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
 	if (!storage) {