duckdb 0.8.0 → 0.8.1-dev111.0

package/src/duckdb/src/main/capi/result-c.cpp

@@ -19,10 +19,10 @@ struct CStandardConverter : public CBaseConverter {
 struct CStringConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
-		auto result = (char *)duckdb_malloc(input.GetSize() + 1);
+		auto result = char_ptr_cast(duckdb_malloc(input.GetSize() + 1));
 		assert(result);
 		memcpy((void *)result, input.GetData(), input.GetSize());
-		auto write_arr = (char *)result;
+		auto write_arr = char_ptr_cast(result);
 		write_arr[input.GetSize()] = '\0';
 		return result;
 	}
@@ -37,10 +37,10 @@ struct CBlobConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
 		duckdb_blob result;
-		result.data = (char *)duckdb_malloc(input.GetSize());
+		result.data = char_ptr_cast(duckdb_malloc(input.GetSize()));
 		result.size = input.GetSize();
 		assert(result.data);
-		memcpy((void *)result.data, input.GetData(), input.GetSize());
+		memcpy(result.data, input.GetData(), input.GetSize());
 		return result;
 	}
 
@@ -266,7 +266,7 @@ duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result_p, duckdb_re
 
 	if (result.HasError()) {
 		// write the error message
-		out->__deprecated_error_message = (char *)result.GetError().c_str();
+		out->__deprecated_error_message = (char *)result.GetError().c_str(); // NOLINT
 		return DuckDBError;
 	}
 	// copy the data
@@ -280,7 +280,7 @@ bool deprecated_materialize_result(duckdb_result *result) {
 	if (!result) {
 		return false;
 	}
-	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
+	auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
 	if (result_data->result->HasError()) {
 		return false;
 	}
@@ -310,14 +310,14 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		result_data->result = stream_result.Materialize();
 	}
 	D_ASSERT(result_data->result->type == QueryResultType::MATERIALIZED_RESULT);
-	auto &materialized = (MaterializedQueryResult &)*result_data->result;
+	auto &materialized = reinterpret_cast<MaterializedQueryResult &>(*result_data->result);
 
 	// convert the result to a materialized result
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
 	memset(result->__deprecated_columns, 0, sizeof(duckdb_column) * column_count);
 	for (idx_t i = 0; i < column_count; i++) {
 		result->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
-		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str();
+		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str(); // NOLINT
 	}
 	result->__deprecated_row_count = materialized.RowCount();
 	if (result->__deprecated_row_count > 0 &&
@@ -344,7 +344,7 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.__deprecated_data) {
 		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
-			auto data = (char **)column.__deprecated_data;
+			auto data = reinterpret_cast<char **>(column.__deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i]) {
 					duckdb_free(data[i]);
@@ -352,7 +352,7 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 			}
 		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
 			// blob, delete individual blobs
-			auto data = (duckdb_blob *)column.__deprecated_data;
+			auto data = reinterpret_cast<duckdb_blob *>(column.__deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i].data) {
 					duckdb_free((void *)data[i].data);
@@ -374,7 +374,7 @@ void duckdb_destroy_result(duckdb_result *result) {
 		duckdb_free(result->__deprecated_columns);
 	}
 	if (result->internal_data) {
-		auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
+		auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
 		delete result_data;
 	}
 	memset(result, 0, sizeof(duckdb_result));
@@ -384,7 +384,7 @@ const char *duckdb_column_name(duckdb_result *result, idx_t col) {
 	if (!result || col >= duckdb_column_count(result)) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return result_data.result->names[col].c_str();
 }
 
@@ -392,7 +392,7 @@ duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
 	if (!result || col >= duckdb_column_count(result)) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return duckdb::ConvertCPPTypeToC(result_data.result->types[col]);
 }
 
@@ -400,7 +400,7 @@ duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col)
 	if (!result || col >= duckdb_column_count(result)) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(result_data.result->types[col]));
 }
 
@@ -408,7 +408,7 @@ idx_t duckdb_column_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return result_data.result->ColumnCount();
 }
 
@@ -416,12 +416,12 @@ idx_t duckdb_row_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
 		// We can't know the row count beforehand
 		return 0;
 	}
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	return materialized.RowCount();
 }
 
@@ -459,7 +459,7 @@ const char *duckdb_result_error(duckdb_result *result) {
 	if (!result) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return !result_data.result->HasError() ? nullptr : result_data.result->GetError().c_str();
 }
 
@@ -467,7 +467,7 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (!result.internal_data) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return 0;
 	}
@@ -475,7 +475,7 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 		// Can't know beforehand how many chunks are returned.
 		return 0;
 	}
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	return materialized.Collection().ChunkCount();
 }
 
@@ -483,7 +483,7 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	if (!result.internal_data) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return nullptr;
 	}
@@ -492,7 +492,7 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 		return nullptr;
 	}
 	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	auto &collection = materialized.Collection();
 	if (chunk_idx >= collection.ChunkCount()) {
 		return nullptr;
@@ -510,6 +510,6 @@ bool duckdb_result_is_streaming(duckdb_result result) {
 	if (duckdb_result_error(&result) != nullptr) {
 		return false;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
 }

package/src/duckdb/src/main/capi/table_function-c.cpp

@@ -311,7 +311,7 @@ void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duck
 	}
 	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
 	bind_info->names.push_back(name);
-	bind_info->return_types.push_back(*((duckdb::LogicalType *)type));
+	bind_info->return_types.push_back(*(reinterpret_cast<duckdb::LogicalType *>(type)));
 }
 
 idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info) {

package/src/duckdb/src/main/client_context.cpp

@@ -774,8 +774,8 @@ void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
 #endif
 	}
 	// log query path is set: log the query
-	client_data->log_query_writer->WriteData((const_data_ptr_t)query.c_str(), query.size());
-	client_data->log_query_writer->WriteData((const_data_ptr_t) "\n", 1);
+	client_data->log_query_writer->WriteData(const_data_ptr_cast(query.c_str()), query.size());
+	client_data->log_query_writer->WriteData(const_data_ptr_cast("\n"), 1);
 	client_data->log_query_writer->Flush();
 	client_data->log_query_writer->Sync();
 }
@@ -918,7 +918,7 @@ void ClientContext::RegisterFunction(CreateFunctionInfo &info) {
 		auto existing_function = Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info.schema,
 		                                                                       info.name, OnEntryNotFound::RETURN_NULL);
 		if (existing_function) {
-			auto &new_info = (CreateScalarFunctionInfo &)info;
+			auto &new_info = info.Cast<CreateScalarFunctionInfo>();
 			if (new_info.functions.MergeFunctionSet(existing_function->functions)) {
 				// function info was updated from catalog entry, rewrite is needed
 				info.on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;

package/src/duckdb/src/main/database_manager.cpp

@@ -27,7 +27,7 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
 		return context.client_data->temporary_objects.get();
 	}
-	return (AttachedDatabase *)databases->GetEntry(context, name).get();
+	return reinterpret_cast<AttachedDatabase *>(databases->GetEntry(context, name).get());
 }
 
 void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db_instance) {

package/src/duckdb/src/main/error_manager.cpp

@@ -37,7 +37,7 @@ string ErrorManager::FormatExceptionRecursive(ErrorType error_type, vector<Excep
 string ErrorManager::InvalidUnicodeError(const string &input, const string &context) {
 	UnicodeInvalidReason reason;
 	size_t pos;
-	auto unicode = Utf8Proc::Analyze((const char *)input.c_str(), input.size(), &reason, &pos);
+	auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(input.c_str()), input.size(), &reason, &pos);
 	if (unicode != UnicodeType::INVALID) {
 		return "Invalid unicode error thrown but no invalid unicode detected in " + context;
 	}

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -86,7 +86,7 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 
 		auto signature_offset = handle->GetFileSize() - signature.size();
 
-		const idx_t maxLenChunks = 1024 * 1024;
+		const idx_t maxLenChunks = 1024ULL * 1024ULL;
 		const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
 		std::vector<std::string> hash_chunks(numChunks);
 		std::vector<idx_t> splits(numChunks + 1);

package/src/duckdb/src/main/relation/create_table_relation.cpp

@@ -23,7 +23,7 @@ BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	info->query = std::move(select);
 	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 	stmt.info = std::move(info);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &CreateTableRelation::Columns() {

package/src/duckdb/src/main/relation/create_view_relation.cpp

@@ -32,7 +32,7 @@ BoundStatement CreateViewRelation::Bind(Binder &binder) {
 	info->schema = schema_name;
 	info->on_conflict = replace ? OnCreateConflict::REPLACE_ON_CONFLICT : OnCreateConflict::ERROR_ON_CONFLICT;
 	stmt.info = std::move(info);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &CreateViewRelation::Columns() {

package/src/duckdb/src/main/relation/delete_relation.cpp

@@ -21,7 +21,7 @@ BoundStatement DeleteRelation::Bind(Binder &binder) {
 	DeleteStatement stmt;
 	stmt.condition = condition ? condition->Copy() : nullptr;
 	stmt.table = std::move(basetable);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &DeleteRelation::Columns() {

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -16,7 +16,7 @@ BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 	ExplainStatement explain(std::move(select), type);
-	return binder.Bind((SQLStatement &)explain);
+	return binder.Bind(explain.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &ExplainRelation::Columns() {

package/src/duckdb/src/main/relation/insert_relation.cpp

@@ -21,7 +21,7 @@ BoundStatement InsertRelation::Bind(Binder &binder) {
 	stmt.schema = schema_name;
 	stmt.table = table_name;
 	stmt.select_statement = std::move(select);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &InsertRelation::Columns() {

package/src/duckdb/src/main/relation/update_relation.cpp

@@ -30,7 +30,7 @@ BoundStatement UpdateRelation::Bind(Binder &binder) {
 	for (auto &expr : expressions) {
 		stmt.set_info->expressions.push_back(expr->Copy());
 	}
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &UpdateRelation::Columns() {

package/src/duckdb/src/main/relation/write_csv_relation.cpp

@@ -22,7 +22,7 @@ BoundStatement WriteCSVRelation::Bind(Binder &binder) {
 	info->format = "csv";
 	info->options = options;
 	copy.info = std::move(info);
-	return binder.Bind((SQLStatement &)copy);
+	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &WriteCSVRelation::Columns() {

package/src/duckdb/src/main/relation/write_parquet_relation.cpp

@@ -22,7 +22,7 @@ BoundStatement WriteParquetRelation::Bind(Binder &binder) {
 	info->format = "parquet";
 	info->options = options;
 	copy.info = std::move(info);
-	return binder.Bind((SQLStatement &)copy);
+	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &WriteParquetRelation::Columns() {

package/src/duckdb/src/main/relation.cpp

@@ -209,7 +209,7 @@ unique_ptr<QueryResult> Relation::ExecuteOrThrow() {
 BoundStatement Relation::Bind(Binder &binder) {
 	SelectStatement stmt;
 	stmt.node = GetQueryNode();
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 shared_ptr<Relation> Relation::InsertRel(const string &schema_name, const string &table_name) {

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -67,7 +67,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 	VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && DelimGetCount(op) == 0) {
 		auto &delim_join = op.Cast<LogicalDelimJoin>();
-		auto decs = &delim_join.duplicate_eliminated_columns;
+		auto &decs = delim_join.duplicate_eliminated_columns;
 		for (auto &cond : delim_join.conditions) {
 			if (!IsEqualityJoinCondition(cond)) {
 				continue;
@@ -83,10 +83,10 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 			auto &colref = rhs->Cast<BoundColumnRefExpression>();
 			if (projection_map.find(colref.binding) != projection_map.end()) {
 				// value on the right is a projection of removed DelimGet
-				for (idx_t i = 0; i < decs->size(); i++) {
-					if (decs->at(i)->Equals(cond.left.get())) {
+				for (idx_t i = 0; i < decs.size(); i++) {
+					if (decs[i]->Equals(*cond.left)) {
 						// the value on the left no longer needs to be a duplicate-eliminated column
-						decs->erase(decs->begin() + i);
+						decs.erase(decs.begin() + i);
 						break;
 					}
 				}
@@ -95,7 +95,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 			}
 		}
 		// change type if there are no more duplicate-eliminated columns
-		if (decs->empty()) {
+		if (decs.empty()) {
 			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
 			// sub-plans with DelimGets are not re-orderable (yet), however, we removed all DelimGet of this DelimJoin
 			// the DelimGets are on the RHS of the DelimJoin, so we can call the JoinOrderOptimizer on the RHS now
@@ -198,9 +198,9 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 	idx_t delim_idx = OperatorIsDelimGet(*join.children[0]) ? 0 : 1;
 	D_ASSERT(OperatorIsDelimGet(*join.children[delim_idx]));
 	// get the filter (if any)
-	LogicalFilter *filter = nullptr;
+	optional_ptr<LogicalFilter> filter;
 	if (join.children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
-		filter = (LogicalFilter *)join.children[delim_idx].get();
+		filter = &join.children[delim_idx]->Cast<LogicalFilter>();
 	}
 	auto &delim_get = (filter ? filter->children[0] : join.children[delim_idx])->Cast<LogicalDelimGet>();
 	if (join.conditions.size() != delim_get.chunk_types.size()) {
@@ -231,7 +231,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 			updater.projection_map[cb] = true;
 			updater.reverse_proj_or_agg_map[cb] = proj_or_agg.expressions[cb.column_index].get();
 			for (auto &expr : nulls_are_not_equal_exprs) {
-				if (proj_or_agg.expressions[cb.column_index]->Equals(&expr.get())) {
+				if (proj_or_agg.expressions[cb.column_index]->Equals(expr.get())) {
 					updater.projection_map[cb] = false;
 					break;
 				}
@@ -254,8 +254,8 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 			updater.projection_map[cb] = true;
 			updater.reverse_proj_or_agg_map[cb] = all_agg_exprs[cb.column_index];
 			for (auto &expr : nulls_are_not_equal_exprs) {
-				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(&expr.get())) ||
-				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(&expr.get()))) {
+				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(expr.get())) ||
+				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(expr.get()))) {
 					updater.projection_map[cb] = false;
 					break;
 				}
@@ -386,7 +386,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 		}
 		// try to find the corresponding child condition
 		// TODO: can be more flexible - allow CAST
-		auto child_expr = it->second;
+		auto &child_expr = *it->second;
 		bool found = false;
 		for (auto &child_cond : join.conditions) {
 			if (child_cond.left->Equals(child_expr) || child_cond.right->Equals(child_expr)) {
@@ -418,7 +418,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 		auto &parent_expr = parent_delim_get_side == 0 ? parent_cond.left : parent_cond.right;
 		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
 		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
-		auto child_expr = it->second;
+		auto &child_expr = *it->second;
 		for (auto &child_cond : join.conditions) {
 			if (!child_cond.left->Equals(child_expr) && !child_cond.right->Equals(child_expr)) {
 				continue;

package/src/duckdb/src/optimizer/expression_heuristics.cpp

@@ -42,6 +42,7 @@ void ExpressionHeuristics::ReorderExpressions(vector<unique_ptr<Expression>> &ex
 	};
 
 	vector<ExpressionCosts> expression_costs;
+	expression_costs.reserve(expressions.size());
 	// iterate expressions, get cost for each one
 	for (idx_t i = 0; i < expressions.size(); i++) {
 		idx_t cost = Cost(*expressions[i]);

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -635,7 +635,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		// get the LHS and RHS nodes
 		auto &left_node = GetNode(*comparison.left);
 		auto &right_node = GetNode(*comparison.right);
-		if (left_node.Equals(&right_node)) {
+		if (left_node.Equals(right_node)) {
 			return FilterResult::UNSUPPORTED;
 		}
 		// get the equivalence sets of the LHS and RHS
@@ -806,7 +806,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 		}
 	}
 
-	if (left_node.Equals(&right_node.get())) {
+	if (left_node.Equals(right_node)) {
 		return FilterResult::UNSUPPORTED;
 	}
 	// get the equivalence sets of the LHS and RHS
@@ -903,7 +903,7 @@ unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression &expr) {
 	for (idx_t i = 0; i < remaining_filters.size(); i++) {
 		if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
 			auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
-			if (expr.Equals(comparison.right.get()) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
+			if (expr.Equals(*comparison.right) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
 				auto filter = std::move(remaining_filters[i]);
 				remaining_filters.erase(remaining_filters.begin() + i);
 				return filter;

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -479,15 +479,15 @@ optional_ptr<TableFilterSet> CardinalityEstimator::GetTableFilters(LogicalOperat
 	return get ? &get->table_filters : nullptr;
 }
 
-idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *filter,
+idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &filter,
                                                   unique_ptr<BaseStatistics> base_stats) {
 	auto has_equality_filter = false;
 	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter->child_filters) {
+	for (auto &child_filter : filter.child_filters) {
 		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
 			continue;
 		}
-		auto comparison_filter = (ConstantFilter &)*child_filter;
+		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
 		if (comparison_filter.comparison_type != ExpressionType::COMPARE_EQUAL) {
 			continue;
 		}
@@ -510,15 +510,15 @@ idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t colum
 	return cardinality_after_filters;
 }
 
-idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *filter,
+idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter,
                                                  unique_ptr<BaseStatistics> base_stats) {
 	auto has_equality_filter = false;
 	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter->child_filters) {
+	for (auto &child_filter : filter.child_filters) {
 		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
 			continue;
 		}
-		auto comparison_filter = (ConstantFilter &)*child_filter;
+		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
 		if (comparison_filter.comparison_type == ExpressionType::COMPARE_EQUAL) {
 			auto column_count = cardinality_after_filters;
 			if (base_stats) {
@@ -549,14 +549,14 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 			column_statistics = get->function.statistics(context, &table_scan_bind_data, it.first);
 		}
 		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &filter = (ConjunctionAndFilter &)*it.second;
+			auto &filter = it.second->Cast<ConjunctionAndFilter>();
 			idx_t cardinality_with_and_filter =
-			    InspectConjunctionAND(cardinality, it.first, &filter, std::move(column_statistics));
+			    InspectConjunctionAND(cardinality, it.first, filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_and_filter);
 		} else if (it.second->filter_type == TableFilterType::CONJUNCTION_OR) {
-			auto &filter = (ConjunctionOrFilter &)*it.second;
+			auto &filter = it.second->Cast<ConjunctionOrFilter>();
 			idx_t cardinality_with_or_filter =
-			    InspectConjunctionOR(cardinality, it.first, &filter, std::move(column_statistics));
+			    InspectConjunctionOR(cardinality, it.first, filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_or_filter);
 		}
 	}

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -24,13 +24,10 @@ namespace duckdb {
 
 //! Returns true if A and B are disjoint, false otherwise
 template <class T>
-static bool Disjoint(unordered_set<T> &a, unordered_set<T> &b) {
-	for (auto &entry : a) {
-		if (b.find(entry) != b.end()) {
-			return false;
-		}
-	}
-	return true;
+static bool Disjoint(const unordered_set<T> &a, const unordered_set<T> &b) {
+	return std::all_of(a.begin(), a.end(), [&b](typename std::unordered_set<T>::const_reference entry) {
+		return b.find(entry) == b.end();
+	});
 }
 
 //! Extract the set of relations referred to inside an expression

package/src/duckdb/src/optimizer/matcher/expression_matcher.cpp

@@ -19,7 +19,7 @@ bool ExpressionMatcher::Match(Expression &expr, vector<reference<Expression>> &b
 }
 
 bool ExpressionEqualityMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
-	if (!expr.Equals(&expression)) {
+	if (!expr.Equals(expression)) {
 		return false;
 	}
 	bindings.push_back(expr);

package/src/duckdb/src/optimizer/pullup/pullup_projection.cpp

@@ -24,8 +24,8 @@ static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expres
 		BoundColumnRefExpression &colref = expr.Cast<BoundColumnRefExpression>();
 		// find the corresponding column index in the projection expressions
 		for (idx_t proj_idx = 0; proj_idx < proj_expressions.size(); proj_idx++) {
-			auto proj_expr = proj_expressions[proj_idx].get();
-			if (proj_expr->type == ExpressionType::BOUND_COLUMN_REF) {
+			auto &proj_expr = *proj_expressions[proj_idx];
+			if (proj_expr.type == ExpressionType::BOUND_COLUMN_REF) {
 				if (colref.Equals(proj_expr)) {
 					colref.binding.table_index = proj_table_idx;
 					colref.binding.column_index = proj_idx;

package/src/duckdb/src/optimizer/regex_range_filter.cpp

@@ -39,12 +39,10 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 			}
 			auto filter_left = make_uniq<BoundComparisonExpression>(
 			    ExpressionType::COMPARE_GREATERTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_min.c_str(), info.range_min.size())));
+			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_min)));
 			auto filter_right = make_uniq<BoundComparisonExpression>(
 			    ExpressionType::COMPARE_LESSTHANOREQUALTO, func.children[0]->Copy(),
-			    make_uniq<BoundConstantExpression>(
-			        Value::BLOB((const_data_ptr_t)info.range_max.c_str(), info.range_max.size())));
+			    make_uniq<BoundConstantExpression>(Value::BLOB_RAW(info.range_max)));
 			auto filter_expr = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
 			                                                         std::move(filter_left), std::move(filter_right));
 

package/src/duckdb/src/optimizer/rule/distributivity.cpp

@@ -33,7 +33,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 		// AND, remove expression from the list
 		auto &and_expr = child->Cast<BoundConjunctionExpression>();
 		for (idx_t i = 0; i < and_expr.children.size(); i++) {
-			if (Expression::Equals(and_expr.children[i].get(), &expr)) {
+			if (and_expr.children[i]->Equals(expr)) {
 				result = std::move(and_expr.children[i]);
 				and_expr.children.erase(and_expr.children.begin() + i);
 				break;
@@ -45,7 +45,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 	} else {
 		// not an AND node! remove the entire expression
 		// this happens in the case of e.g. (X AND B) OR X
-		D_ASSERT(Expression::Equals(child.get(), &expr));
+		D_ASSERT(child->Equals(expr));
 		result = std::move(child);
 		conj.children[idx] = nullptr;
 	}

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -161,15 +161,15 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 		SetStatisticsNotNull((right.Cast<BoundColumnRefExpression>()).binding);
 	}
 	// check if this is a comparison between a constant and a column ref
-	BoundConstantExpression *constant = nullptr;
-	BoundColumnRefExpression *columnref = nullptr;
+	optional_ptr<BoundConstantExpression> constant;
+	optional_ptr<BoundColumnRefExpression> columnref;
 	if (left.type == ExpressionType::VALUE_CONSTANT && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		constant = (BoundConstantExpression *)&left;
-		columnref = (BoundColumnRefExpression *)&right;
+		constant = &left.Cast<BoundConstantExpression>();
+		columnref = &right.Cast<BoundColumnRefExpression>();
 		comparison_type = FlipComparisonExpression(comparison_type);
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::VALUE_CONSTANT) {
-		columnref = (BoundColumnRefExpression *)&left;
-		constant = (BoundConstantExpression *)&right;
+		columnref = &left.Cast<BoundColumnRefExpression>();
+		constant = &right.Cast<BoundConstantExpression>();
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::BOUND_COLUMN_REF) {
 		// comparison between two column refs
 		auto &left_column_ref = left.Cast<BoundColumnRefExpression>();

package/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp

@@ -14,14 +14,14 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi
 	// FIXME: update stats...
 	switch (filter.filter_type) {
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (ConjunctionAndFilter &)filter;
+		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction_and.child_filters) {
 			UpdateFilterStatistics(input, *child_filter);
 		}
 		break;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant);
 		break;
 	}