duckdb 0.8.1-dev0.0 → 0.8.1-dev111.0

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -78,7 +78,7 @@ struct LikeMatcher : public FunctionData {
 	}
 
 	bool Match(string_t &str) {
-		auto str_data = (const unsigned char *)str.GetData();
+		auto str_data = const_uchar_ptr_cast(str.GetData());
 		auto str_len = str.GetSize();
 		idx_t segment_idx = 0;
 		idx_t end_idx = segments.size() - 1;
@@ -105,7 +105,7 @@ struct LikeMatcher : public FunctionData {
 		for (; segment_idx < end_idx; segment_idx++) {
 			auto &segment = segments[segment_idx];
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
+			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
 			                                      segment.pattern.size());
 			if (next_offset == DConstants::INVALID_INDEX) {
 				// could not find this pattern in the string: no match
@@ -130,7 +130,7 @@ struct LikeMatcher : public FunctionData {
 		} else {
 			auto &segment = segments.back();
 			// find the pattern of the current segment
-			idx_t next_offset = ContainsFun::Find(str_data, str_len, (const unsigned char *)segment.pattern.c_str(),
+			idx_t next_offset = ContainsFun::Find(str_data, str_len, const_uchar_ptr_cast(segment.pattern.c_str()),
 			                                      segment.pattern.size());
 			return next_offset != DConstants::INVALID_INDEX;
 		}
@@ -179,7 +179,7 @@ struct LikeMatcher : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const LikeMatcher &)other_p;
+		auto &other = other_p.Cast<LikeMatcher>();
 		return like_pattern == other.like_pattern;
 	}
 
@@ -491,7 +491,7 @@ template <class OP, bool INVERT>
 static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	if (func_expr.bind_info) {
-		auto &matcher = (LikeMatcher &)*func_expr.bind_info;
+		auto &matcher = func_expr.bind_info->Cast<LikeMatcher>();
 		// use fast like matcher
 		UnaryExecutor::Execute<string_t, bool>(input.data[0], result, input.size(), [&](string_t input) {
 			return INVERT ? !matcher.Match(input) : matcher.Match(input);

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -94,7 +94,7 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 		} else {
 			// Every group is a substring of the original, we can find out the offset using the pointer
 			// the 'match_group' address is guaranteed to be bigger than that of the source
-			D_ASSERT((const char *)match_group.begin() >= string.GetData());
+			D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData());
 			idx_t offset = match_group.begin() - string.GetData();
 			list_content[child_idx] = string_t(string.GetData() + offset, match_group.size());
 		}
@@ -119,7 +119,7 @@ int32_t GetGroupIndex(DataChunk &args, idx_t row, int32_t &result) {
 	if (!format.validity.RowIsValid(index)) {
 		return false;
 	}
-	result = ((int32_t *)format.data)[index];
+	result = UnifiedVectorFormat::GetData<int32_t>(format)[index];
 	return true;
 }
 
@@ -188,7 +188,7 @@ void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &
 			if (!pattern_data.validity.RowIsValid(pattern_idx)) {
 				pattern_valid = false;
 			} else {
-				auto &pattern_p = ((string_t *)pattern_data.data)[pattern_idx];
+				auto &pattern_p = UnifiedVectorFormat::GetData<string_t>(pattern_data)[pattern_idx];
 				auto pattern_strpiece = CreateStringPiece(pattern_p);
 				stored_re = make_uniq<duckdb_re2::RE2>(pattern_strpiece, info.options);
 
@@ -216,7 +216,7 @@ void RegexpExtractAll::Execute(DataChunk &args, ExpressionState &state, Vector &
 
 		auto &re = GetPattern(info, state, stored_re);
 		auto &groups = GetGroupsBuffer(info, state, non_const_args);
-		auto &string = ((string_t *)strings_data.data)[string_idx];
+		auto &string = UnifiedVectorFormat::GetData<string_t>(strings_data)[string_idx];
 		ExtractSingleTuple(string, re, group_index, groups, result, row);
 	}
 

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -146,7 +146,7 @@ unique_ptr<FunctionData> RegexpReplaceBindData::Copy() const {
 }
 
 bool RegexpReplaceBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpReplaceBindData &)other_p;
+	auto &other = other_p.Cast<RegexpReplaceBindData>();
 	return RegexpBaseBindData::Equals(other) && global_replace == other.global_replace;
 }
 
@@ -214,7 +214,7 @@ unique_ptr<FunctionData> RegexpExtractBindData::Copy() const {
 }
 
 bool RegexpExtractBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const RegexpExtractBindData &)other_p;
+	auto &other = other_p.Cast<RegexpExtractBindData>();
 	return RegexpBaseBindData::Equals(other) && group_string == other.group_string;
 }
 
@@ -286,7 +286,7 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state,
 		input.ToUnifiedFormat(count, iunified);
 
 		const auto &ivalidity = iunified.validity;
-		auto idata = (const string_t *)iunified.data;
+		auto idata = UnifiedVectorFormat::GetData<string_t>(iunified);
 
 		// Start with a valid flat vector
 		result.SetVectorType(VectorType::FLAT_VECTOR);

package/src/duckdb/src/function/scalar/string/strip_accents.cpp

@@ -23,7 +23,7 @@ struct StripAccentsOperator {
 
 		// non-ascii, perform collation
 		auto stripped = utf8proc_remove_accents((const utf8proc_uint8_t *)input.GetData(), input.GetSize());
-		auto result_str = StringVector::AddString(result, (const char *)stripped);
+		auto result_str = StringVector::AddString(result, const_char_ptr_cast(stripped));
 		free(stripped);
 		return result_str;
 	}

package/src/duckdb/src/function/scalar/struct/struct_extract.cpp

@@ -21,7 +21,7 @@ public:
 		return make_uniq<StructExtractBindData>(key, index, type);
 	}
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const StructExtractBindData &)other_p;
+		auto &other = other_p.Cast<StructExtractBindData>();
 		return key == other.key && index == other.index && type == other.type;
 	}
 };

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -23,7 +23,7 @@ struct ExportAggregateBindData : public FunctionData {
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ExportAggregateBindData &)other_p;
+		auto &other = other_p.Cast<ExportAggregateBindData>();
 		return aggr == other.aggr && state_size == other.state_size;
 	}
 
@@ -42,14 +42,14 @@ struct CombineState : public FunctionLocalState {
 	explicit CombineState(idx_t state_size_p)
 	    : state_size(state_size_p), state_buffer0(make_unsafe_uniq_array<data_t>(state_size_p)),
 	      state_buffer1(make_unsafe_uniq_array<data_t>(state_size_p)),
-	      state_vector0(Value::POINTER((uintptr_t)state_buffer0.get())),
-	      state_vector1(Value::POINTER((uintptr_t)state_buffer1.get())) {
+	      state_vector0(Value::POINTER(CastPointerToValue(state_buffer0.get()))),
+	      state_vector1(Value::POINTER(CastPointerToValue(state_buffer1.get()))) {
 	}
 };
 
 static unique_ptr<FunctionLocalState> InitCombineState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                        FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
+	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<CombineState>(bind_data.state_size);
 }
 
@@ -67,13 +67,13 @@ struct FinalizeState : public FunctionLocalState {
 
 static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state, const BoundFunctionExpression &expr,
                                                         FunctionData *bind_data_p) {
-	auto &bind_data = *(ExportAggregateBindData *)bind_data_p;
+	auto &bind_data = bind_data_p->Cast<ExportAggregateBindData>();
 	return make_uniq<FinalizeState>(bind_data.state_size);
 }
 
 static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (FinalizeState &)*((ExecuteFunctionState &)state_p).local_state;
+	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 	D_ASSERT(input.data.size() == 1);
@@ -86,8 +86,8 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 	input.data[0].ToUnifiedFormat(input.size(), state_data);
 	for (idx_t i = 0; i < input.size(); i++) {
 		auto state_idx = state_data.sel->get_index(i);
-		auto state_entry = &((string_t *)state_data.data)[state_idx];
-		auto target_ptr = (const char *)local_state.state_buffer.get() + aligned_state_size * i;
+		auto state_entry = UnifiedVectorFormat::GetData<string_t>(state_data) + state_idx;
+		auto target_ptr = char_ptr_cast(local_state.state_buffer.get()) + aligned_state_size * i;
 
 		if (state_data.validity.RowIsValid(state_idx)) {
 			D_ASSERT(state_entry->GetSize() == bind_data.state_size);
@@ -95,9 +95,9 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 		} else {
 			// create a dummy state because finalize does not understand NULLs in its input
 			// we put the NULL back in explicitly below
-			bind_data.aggr.initialize((data_ptr_t)target_ptr);
+			bind_data.aggr.initialize(data_ptr_cast(target_ptr));
 		}
-		state_vec_ptr[i] = (data_ptr_t)target_ptr;
+		state_vec_ptr[i] = data_ptr_cast(target_ptr);
 	}
 
 	AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
@@ -113,7 +113,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 
 static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
-	auto &local_state = (CombineState &)*((ExecuteFunctionState &)state_p).local_state;
+	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 
@@ -136,8 +136,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		auto state0_idx = state0_data.sel->get_index(i);
 		auto state1_idx = state1_data.sel->get_index(i);
 
-		auto &state0 = ((string_t *)state0_data.data)[state0_idx];
-		auto &state1 = ((string_t *)state1_data.data)[state1_idx];
+		auto &state0 = UnifiedVectorFormat::GetData<string_t>(state0_data)[state0_idx];
+		auto &state1 = UnifiedVectorFormat::GetData<string_t>(state1_data)[state1_idx];
 
 		// if both are NULL, we return NULL. If either of them is not, the result is that one
 		if (!state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
@@ -145,11 +145,13 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 			continue;
 		}
 		if (state0_data.validity.RowIsValid(state0_idx) && !state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state0.GetData(), bind_data.state_size);
+			result_ptr[i] =
+			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state0.GetData()), bind_data.state_size);
 			continue;
 		}
 		if (!state0_data.validity.RowIsValid(state0_idx) && state1_data.validity.RowIsValid(state1_idx)) {
-			result_ptr[i] = StringVector::AddStringOrBlob(result, (const char *)state1.GetData(), bind_data.state_size);
+			result_ptr[i] =
+			    StringVector::AddStringOrBlob(result, const_char_ptr_cast(state1.GetData()), bind_data.state_size);
 			continue;
 		}
 
@@ -165,8 +167,8 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
 
-		result_ptr[i] =
-		    StringVector::AddStringOrBlob(result, (const char *)local_state.state_buffer1.get(), bind_data.state_size);
+		result_ptr[i] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(local_state.state_buffer1.get()),
+		                                              bind_data.state_size);
 	}
 }
 
@@ -244,19 +246,19 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 static void ExportAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
                                     idx_t offset) {
 	D_ASSERT(offset == 0);
-	auto bind_data = (ExportAggregateFunctionBindData *)aggr_input_data.bind_data;
-	auto state_size = bind_data->aggregate->function.state_size();
+	auto &bind_data = aggr_input_data.bind_data->Cast<ExportAggregateFunctionBindData>();
+	auto state_size = bind_data.aggregate->function.state_size();
 	auto blob_ptr = FlatVector::GetData<string_t>(result);
 	auto addresses_ptr = FlatVector::GetData<data_ptr_t>(state);
 	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 		auto data_ptr = addresses_ptr[row_idx];
-		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, (const char *)data_ptr, state_size);
+		blob_ptr[row_idx] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(data_ptr), state_size);
 	}
 }
 
 ExportAggregateFunctionBindData::ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p) {
 	D_ASSERT(aggregate_p->type == ExpressionType::BOUND_AGGREGATE);
-	aggregate = unique_ptr<BoundAggregateExpression>((BoundAggregateExpression *)aggregate_p.release());
+	aggregate = unique_ptr_cast<Expression, BoundAggregateExpression>(std::move(aggregate_p));
 }
 
 unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
@@ -264,8 +266,8 @@ unique_ptr<FunctionData> ExportAggregateFunctionBindData::Copy() const {
 }
 
 bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const {
-	auto &other = (const ExportAggregateFunctionBindData &)other_p;
-	return aggregate->Equals(other.aggregate.get());
+	auto &other = other_p.Cast<ExportAggregateFunctionBindData>();
+	return aggregate->Equals(*other.aggregate);
 }
 
 static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionData *bind_data_p,

package/src/duckdb/src/function/scalar_function.cpp

@@ -59,8 +59,8 @@ bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
 bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) const {
 	typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
 
-	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>();
-	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();
+	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>(); // NOLINT
+	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();   // NOLINT
 
 	// Case the functions were created from lambdas the target will return a nullptr
 	if (!func_ptr && !other_ptr) {
@@ -70,7 +70,7 @@ bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) cons
 		// scalar_function_t (std::functions) from lambdas cannot be compared
 		return false;
 	}
-	return ((size_t)*func_ptr == (size_t)*other_ptr);
+	return CastPointerToValue(*func_ptr) == CastPointerToValue(*other_ptr);
 }
 
 void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {

package/src/duckdb/src/function/table/arrow.cpp

@@ -193,8 +193,8 @@ void ArrowTableFunction::RenameArrowColumns(vector<string> &names) {
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
 	auto stream_factory_ptr = input.inputs[0].GetPointer();
-	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();
-	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer();
+	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
+	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT
 
 	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
 
@@ -269,7 +269,7 @@ bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, cons
 
 unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
                                                                              TableFunctionInitInput &input) {
-	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<ArrowScanFunctionData>();
 	auto result = make_uniq<ArrowScanGlobalState>();
 	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters.get());
 	result->max_threads = ArrowScanMaxThreads(context, input.bind_data.get());
@@ -314,7 +314,7 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 	if (!data_p.local_state) {
 		return;
 	}
-	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
+	auto &data = data_p.bind_data->CastNoConst<ArrowScanFunctionData>(); // FIXME
 	auto &state = data_p.local_state->Cast<ArrowScanLocalState>();
 	auto &global_state = data_p.global_state->Cast<ArrowScanGlobalState>();