duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -22,7 +22,7 @@ string BoundExpression::ToString() const {
 	return expr->ToString();
 }
 
-bool BoundExpression::Equals(const BaseExpression *other) const {
+bool BoundExpression::Equals(const BaseExpression &other) const {
 	return false;
 }
 hash_t BoundExpression::Hash() const {

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 
 namespace duckdb {
@@ -39,15 +38,15 @@ hash_t BoundFunctionExpression::Hash() const {
 	return CombineHash(result, function.Hash());
 }
 
-bool BoundFunctionExpression::Equals(const BaseExpression *other_p) const {
+bool BoundFunctionExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundFunctionExpression>();
+	auto &other = other_p.Cast<BoundFunctionExpression>();
 	if (other.function != function) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {

package/src/duckdb/src/planner/expression/bound_lambda_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -14,15 +13,15 @@ string BoundLambdaExpression::ToString() const {
 	return lambda_expr->ToString();
 }
 
-bool BoundLambdaExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaExpression>();
-	if (!Expression::Equals(lambda_expr.get(), other.lambda_expr.get())) {
+	auto &other = other_p.Cast<BoundLambdaExpression>();
+	if (!Expression::Equals(*lambda_expr, *other.lambda_expr)) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(captures, other.captures)) {
+	if (!Expression::ListEquals(captures, other.captures)) {
 		return false;
 	}
 	if (parameter_count != other.parameter_count) {

package/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp

@@ -30,11 +30,11 @@ hash_t BoundLambdaRefExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
 }
 
-bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaRefExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaRefExpression>();
+	auto &other = other_p.Cast<BoundLambdaRefExpression>();
 	return other.binding == binding && other.lambda_index == lambda_index && other.depth == depth;
 }
 

package/src/duckdb/src/planner/expression/bound_operator_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/common/field_writer.hpp"
 
@@ -14,12 +13,12 @@ string BoundOperatorExpression::ToString() const {
 	return OperatorExpression::ToString<BoundOperatorExpression, Expression>(*this);
 }
 
-bool BoundOperatorExpression::Equals(const BaseExpression *other_p) const {
+bool BoundOperatorExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundOperatorExpression>();
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	auto &other = other_p.Cast<BoundOperatorExpression>();
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -43,11 +43,11 @@ string BoundParameterExpression::ToString() const {
 	return "$" + to_string(parameter_nr);
 }
 
-bool BoundParameterExpression::Equals(const BaseExpression *other_p) const {
+bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundParameterExpression>();
+	auto &other = other_p.Cast<BoundParameterExpression>();
 	return parameter_nr == other.parameter_nr;
 }
 

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -28,11 +28,11 @@ string BoundReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool BoundReferenceExpression::Equals(const BaseExpression *other_p) const {
+bool BoundReferenceExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundReferenceExpression>();
+	auto &other = other_p.Cast<BoundReferenceExpression>();
 	return other.index == index;
 }
 

package/src/duckdb/src/planner/expression/bound_subquery_expression.cpp

@@ -12,7 +12,7 @@ string BoundSubqueryExpression::ToString() const {
 	return "SUBQUERY";
 }
 
-bool BoundSubqueryExpression::Equals(const BaseExpression *other_p) const {
+bool BoundSubqueryExpression::Equals(const BaseExpression &other_p) const {
 	// equality between bound subqueries not implemented currently
 	return false;
 }

package/src/duckdb/src/planner/expression/bound_unnest_expression.cpp

@@ -23,12 +23,12 @@ hash_t BoundUnnestExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash("unnest"));
 }
 
-bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
+bool BoundUnnestExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundUnnestExpression>();
-	if (!Expression::Equals(child.get(), other.child.get())) {
+	auto &other = other_p.Cast<BoundUnnestExpression>();
+	if (!Expression::Equals(*child, *other.child)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -21,11 +21,11 @@ string BoundWindowExpression::ToString() const {
 	                                                                                       function_name);
 }
 
-bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
+bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundWindowExpression>();
+	auto &other = other_p.Cast<BoundWindowExpression>();
 
 	if (ignore_nulls != other.ignore_nulls) {
 		return false;
@@ -34,24 +34,17 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 		return false;
 	}
 	// check if the child expressions are equivalent
-	if (other.children.size() != children.size()) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other.children[i].get())) {
-			return false;
-		}
-	}
 	// check if the filter expressions are equivalent
-	if (!Expression::Equals(filter_expr.get(), other.filter_expr.get())) {
+	if (!Expression::Equals(filter_expr, other.filter_expr)) {
 		return false;
 	}
 
 	// check if the framing expressions are equivalent
-	if (!Expression::Equals(start_expr.get(), other.start_expr.get()) ||
-	    !Expression::Equals(end_expr.get(), other.end_expr.get()) ||
-	    !Expression::Equals(offset_expr.get(), other.offset_expr.get()) ||
-	    !Expression::Equals(default_expr.get(), other.default_expr.get())) {
+	if (!Expression::Equals(start_expr, other.start_expr) || !Expression::Equals(end_expr, other.end_expr) ||
+	    !Expression::Equals(offset_expr, other.offset_expr) || !Expression::Equals(default_expr, other.default_expr)) {
 		return false;
 	}
 
@@ -60,14 +53,9 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 
 bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
 	// check if the partitions are equivalent
-	if (partitions.size() != other.partitions.size()) {
+	if (!Expression::ListEquals(partitions, other.partitions)) {
 		return false;
 	}
-	for (idx_t i = 0; i < partitions.size(); i++) {
-		if (!Expression::Equals(partitions[i].get(), other.partitions[i].get())) {
-			return false;
-		}
-	}
 	// check if the orderings are equivalent
 	if (orders.size() != other.orders.size()) {
 		return false;
@@ -76,8 +64,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 		if (orders[i].type != other.orders[i].type) {
 			return false;
 		}
-		if (!BaseExpression::Equals((BaseExpression *)orders[i].expression.get(),
-		                            (BaseExpression *)other.orders[i].expression.get())) {
+		if (!Expression::Equals(*orders[i].expression, *other.orders[i].expression)) {
 			return false;
 		}
 	}

package/src/duckdb/src/planner/expression.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/planner/expression/list.hpp"
+#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -165,4 +166,18 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	return result;
 }
 
+bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
+bool Expression::ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right) {
+	return ExpressionUtil::ListEquals(left, right);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -62,8 +62,8 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first.get().Equals(&expr));
-		D_ASSERT(!expr.Equals(&entry.first.get()));
+		D_ASSERT(!entry.first.get().Equals(expr));
+		D_ASSERT(!expr.Equals(entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;

package/src/duckdb/src/planner/expression_binder.cpp

@@ -64,8 +64,9 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
 	case ExpressionClass::PARAMETER:
 		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression(expr_ref.Cast<PositionalReferenceExpression>(), depth);
+	case ExpressionClass::POSITIONAL_REFERENCE: {
+		return BindPositionalReference(expr, depth, root_expression);
+	}
 	case ExpressionClass::STAR:
 		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
 	default:

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -230,12 +230,12 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : ((BoundDistinctModifier &)*node.modifiers[i]).target_distincts) {
+			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
 				EnumerateExpression(expr, callback);
 			}
 			break;
 		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : ((BoundOrderModifier &)*node.modifiers[i]).orders) {
+			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
 				EnumerateExpression(order.expression, callback);
 			}
 			break;

package/src/duckdb/src/planner/filter/conjunction_filter.cpp

@@ -35,7 +35,7 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionOrFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionOrFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}
@@ -90,7 +90,7 @@ bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
 	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConjunctionAndFilter &)other_p;
+	auto &other = other_p.Cast<ConjunctionAndFilter>();
 	if (other.child_filters.size() != child_filters.size()) {
 		return false;
 	}

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -39,7 +39,7 @@ bool ConstantFilter::Equals(const TableFilter &other_p) const {
 	if (!TableFilter::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (ConstantFilter &)other_p;
+	auto &other = other_p.Cast<ConstantFilter>();
 	return other.comparison_type == comparison_type && other.constant == constant;
 }
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -109,13 +109,12 @@ void LogicalOperator::Verify(ClientContext &context) {
 		// copy should be identical to original
 		D_ASSERT(expressions[expr_idx]->ToString() == copy->ToString());
 		D_ASSERT(original_hash == copy_hash);
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), copy.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], copy));
 
-		D_ASSERT(!Expression::Equals(expressions[expr_idx].get(), nullptr));
 		for (idx_t other_idx = 0; other_idx < expr_idx; other_idx++) {
 			// comparison with other expressions
 			auto other_hash = expressions[other_idx]->Hash();
-			bool expr_equal = Expression::Equals(expressions[expr_idx].get(), expressions[other_idx].get());
+			bool expr_equal = Expression::Equals(expressions[expr_idx], expressions[other_idx]);
 			if (original_hash != other_hash) {
 				// if the hashes are not equal the expressions should not be equal either
 				D_ASSERT(!expr_equal);
@@ -144,7 +143,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
-		D_ASSERT(Expression::Equals(expressions[expr_idx].get(), deserialized_expression.get()));
+		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));
 		D_ASSERT(expressions[expr_idx]->Hash() == deserialized_expression->Hash());
 	}
 	D_ASSERT(!ToString().empty());

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -97,7 +97,7 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT: {
-		auto &limit = (LogicalLimitPercent &)op;
+		auto &limit = op.Cast<LogicalLimitPercent>();
 		if (limit.limit) {
 			callback(&limit.limit);
 		}

package/src/duckdb/src/planner/planner.cpp

@@ -1,14 +1,15 @@
 #include "duckdb/planner/planner.hpp"
-#include "duckdb/main/query_profiler.hpp"
+
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
+#include "duckdb/main/query_profiler.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
 
 namespace duckdb {
@@ -142,23 +143,12 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 }
 
 static bool OperatorSupportsSerialization(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_PREPARE:
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		// unsupported (for now)
-		return false;
-	default:
-		break;
-	}
 	for (auto &child : op.children) {
 		if (!OperatorSupportsSerialization(*child)) {
 			return false;
 		}
 	}
-	return true;
+	return op.SupportSerialization();
 }
 
 void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op, bound_parameter_map_t *map) {

package/src/duckdb/src/planner/table_filter.cpp

@@ -14,7 +14,7 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	} else {
 		// there is already a filter: AND it together
 		if (entry->second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &and_filter = (ConjunctionAndFilter &)*entry->second;
+			auto &and_filter = entry->second->Cast<ConjunctionAndFilter>();
 			and_filter.child_filters.push_back(std::move(filter));
 		} else {
 			auto and_filter = make_uniq<ConjunctionAndFilter>();

package/src/duckdb/src/storage/arena_allocator.cpp

@@ -31,7 +31,7 @@ struct ArenaAllocatorData : public PrivateAllocatorData {
 };
 
 static data_ptr_t ArenaAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Allocate(size);
 }
 
@@ -41,7 +41,7 @@ static void ArenaAllocatorFree(PrivateAllocatorData *, data_ptr_t, idx_t) {
 
 static data_ptr_t ArenaAllocateReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
                                           idx_t size) {
-	auto &allocator_data = (ArenaAllocatorData &)*private_data;
+	auto &allocator_data = private_data->Cast<ArenaAllocatorData>();
 	return allocator_data.allocator.Reallocate(pointer, old_size, size);
 }
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/buffer/block_handle.cpp

@@ -49,7 +49,7 @@ unique_ptr<Block> AllocateBlock(BlockManager &block_manager, unique_ptr<FileBuff
 		// re-usable buffer: re-use it
 		if (reusable_buffer->type == FileBufferType::BLOCK) {
 			// we can reuse the buffer entirely
-			auto &block = (Block &)*reusable_buffer;
+			auto &block = reinterpret_cast<Block &>(*reusable_buffer);
 			block.id = block_id;
 			return unique_ptr_cast<FileBuffer, Block>(std::move(reusable_buffer));
 		}

package/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp

@@ -33,8 +33,8 @@ void WriteOverflowStringsToDisk::WriteString(string_t string, block_id_t &result
 	size_t compressed_size = 0;
 	compressed_size = s.MaxCompressedLength(uncompressed_size);
 	auto compressed_buf = make_unsafe_uniq_array<data_t>(compressed_size);
-	s.Compress((const char *)string.GetData(), uncompressed_size, (char *)compressed_buf.get(), &compressed_size);
-	string_t compressed_string((const char *)compressed_buf.get(), compressed_size);
+	s.Compress(string.GetData(), uncompressed_size, char_ptr_cast(compressed_buf.get()), &compressed_size);
+	string_t compressed_string(const_char_ptr_cast(compressed_buf.get()), compressed_size);
 
 	// store sizes
 	auto data_ptr = handle.Ptr();

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -41,7 +41,7 @@ SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, Blo
 }
 
 BlockManager &SingleFileCheckpointWriter::GetBlockManager() {
-	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
+	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
 	return *storage_manager.block_manager;
 }
 
@@ -55,7 +55,7 @@ unique_ptr<TableDataWriter> SingleFileCheckpointWriter::GetTableDataWriter(Table
 
 void SingleFileCheckpointWriter::CreateCheckpoint() {
 	auto &config = DBConfig::Get(db);
-	auto &storage_manager = (SingleFileStorageManager &)db.GetStorageManager();
+	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
 	if (storage_manager.InMemory()) {
 		return;
 	}
@@ -73,7 +73,7 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 
 	vector<reference<SchemaCatalogEntry>> schemas;
 	// we scan the set of committed schemas
-	auto &catalog = (DuckCatalog &)Catalog::GetCatalog(db);
+	auto &catalog = Catalog::GetCatalog(db).Cast<DuckCatalog>();
 	catalog.ScanSchemas([&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
 	// write the actual data into the database
 	// write the amount of schemas

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

@@ -68,7 +68,7 @@ static bitpacking_metadata_encoded_t EncodeMeta(bitpacking_metadata_t metadata)
 }
 static bitpacking_metadata_t DecodeMeta(bitpacking_metadata_encoded_t *metadata_encoded) {
 	bitpacking_metadata_t metadata;
-	metadata.mode = Load<BitpackingMode>((data_ptr_t)(metadata_encoded) + 3);
+	metadata.mode = Load<BitpackingMode>(data_ptr_cast(metadata_encoded) + 3);
 	metadata.offset = *metadata_encoded & 0x00FFFFFF;
 	return metadata;
 }
@@ -324,7 +324,7 @@ bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	auto data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (!analyze_state.state.template Update<EmptyBitpackingWriter>(data[idx], vdata.validity.RowIsValid(idx))) {
@@ -482,7 +482,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = (T *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<T>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
@@ -690,7 +690,7 @@ public:
 					idx_t decompress_offset = current_group_offset - extra_count;
 					bool skip_sign_extension = true;
 
-					BitpackingPrimitives::UnPackBuffer<T>((data_ptr_t)decompression_buffer,
+					BitpackingPrimitives::UnPackBuffer<T>(data_ptr_cast(decompression_buffer),
 					                                      current_group_ptr + decompress_offset, decompress_count,
 					                                      current_width, skip_sign_extension);
 
@@ -795,11 +795,11 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 
 		if (to_scan == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE && offset_in_compression_group == 0) {
 			// Decompress directly into result vector
-			BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)current_result_ptr, decompression_group_start_pointer,
+			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(current_result_ptr), decompression_group_start_pointer,
 			                                     scan_state.current_width, skip_sign_extend);
 		} else {
 			// Decompress compression algorithm to buffer
-			BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)scan_state.decompression_buffer,
+			BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
 			                                     decompression_group_start_pointer, scan_state.current_width,
 			                                     skip_sign_extend);
 
@@ -860,8 +860,8 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 	D_ASSERT(scan_state.current_group.mode == BitpackingMode::FOR ||
 	         scan_state.current_group.mode == BitpackingMode::DELTA_FOR);
 
-	BitpackingPrimitives::UnPackBlock<T>((data_ptr_t)scan_state.decompression_buffer, decompression_group_start_pointer,
-	                                     scan_state.current_width, skip_sign_extend);
+	BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
+	                                     decompression_group_start_pointer, scan_state.current_width, skip_sign_extend);
 
 	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
 	*current_result_ptr += scan_state.current_frame_of_reference;