duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2700"
+#define DUCKDB_VERSION "0.8.2-dev2842"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "acbbfe0e79"
+#define DUCKDB_SOURCE_ID "6421a36e94"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
@@ -95,6 +95,9 @@ string DuckDB::Platform() {
 		postfix = "_gcc4";
 	}
 #endif
+#if defined(__ANDROID__)
+	postfix += "_android"; // using + because it may also be gcc4
+#endif
 #ifdef __MINGW32__
 	postfix = "_mingw";
 #endif

package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp

@@ -88,4 +88,6 @@ void SetError(struct AdbcError *error, const std::string &message);
 
 void InitiliazeADBCError(AdbcError *error);
 
+AdbcStatusCode SetErrorMaybe(const void *result, AdbcError *error, const std::string &error_message);
+
 } // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/enums/pending_execution_result.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-enum class PendingExecutionResult : uint8_t { RESULT_READY, RESULT_NOT_READY, EXECUTION_ERROR };
+enum class PendingExecutionResult : uint8_t { RESULT_READY, RESULT_NOT_READY, EXECUTION_ERROR, NO_TASKS_AVAILABLE };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/index_vector.hpp

@@ -62,12 +62,12 @@ public:
 	}
 
 	void FormatSerialize(FormatSerializer &serializer) const {
-		serializer.WriteProperty("internal_vector", internal_vector);
+		serializer.WriteProperty(100, "internal_vector", internal_vector);
 	}
 
 	static IndexVector<T, INDEX_TYPE> FormatDeserialize(FormatDeserializer &deserializer) {
 		IndexVector<T, INDEX_TYPE> result;
-		deserializer.ReadProperty("internal_vector", result.internal_vector);
+		deserializer.ReadProperty(100, "internal_vector", result.internal_vector);
 		return result;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -45,13 +45,17 @@ private:
 	struct State {
 		uint32_t expected_field_count;
 		idx_t expected_size;
+		field_id_t expected_field_id;
 		uint32_t read_field_count;
-		State(uint32_t expected_field_count, idx_t expected_size)
-		    : expected_field_count(expected_field_count), expected_size(expected_size), read_field_count(0) {
+
+		State(uint32_t expected_field_count, idx_t expected_size, field_id_t expected_field_id)
+		    : expected_field_count(expected_field_count), expected_size(expected_size),
+		      expected_field_id(expected_field_id), read_field_count(0) {
 		}
 	};
 
 	const char *current_tag = nullptr;
+	field_id_t current_field_id = 0;
 	data_ptr_t ptr;
 	data_ptr_t end_ptr;
 	vector<State> stack;
@@ -72,7 +76,7 @@ private:
 	}
 
 	// Set the 'tag' of the property to read
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -24,6 +24,7 @@ private:
 	};
 
 	const char *current_tag;
+	field_id_t current_field_id = 0;
 
 	vector<data_t> data;
 	vector<State> stack;
@@ -55,7 +56,7 @@ public:
 		return std::move(serializer.data);
 	}
 
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -30,22 +30,22 @@ protected:
 public:
 	// Read into an existing value
 	template <typename T>
-	inline void ReadProperty(const char *tag, T &ret) {
-		SetTag(tag);
+	inline void ReadProperty(const field_id_t field_id, const char *tag, T &ret) {
+		SetTag(field_id, tag);
 		ret = Read<T>();
 	}
 
 	// Read and return a value
 	template <typename T>
-	inline T ReadProperty(const char *tag) {
-		SetTag(tag);
+	inline T ReadProperty(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		return Read<T>();
 	}
 
 	// Read optional property and return a value, or forward a default value
 	template <typename T>
-	inline T ReadOptionalPropertyOrDefault(const char *tag, T &&default_value) {
-		SetTag(tag);
+	inline T ReadOptionalPropertyOrDefault(const field_id_t field_id, const char *tag, T &&default_value) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			auto item = Read<T>();
@@ -59,8 +59,8 @@ public:
 
 	// Read optional property into an existing value, or use a default value
 	template <typename T>
-	inline void ReadOptionalPropertyOrDefault(const char *tag, T &ret, T &&default_value) {
-		SetTag(tag);
+	inline void ReadOptionalPropertyOrDefault(const field_id_t field_id, const char *tag, T &ret, T &&default_value) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			ret = Read<T>();
@@ -74,8 +74,8 @@ public:
 	// Read optional property and return a value, or default construct it
 	template <typename T>
 	inline typename std::enable_if<std::is_default_constructible<T>::value, T>::type
-	ReadOptionalProperty(const char *tag) {
-		SetTag(tag);
+	ReadOptionalProperty(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			auto item = Read<T>();
@@ -90,8 +90,8 @@ public:
 	// Read optional property into an existing value, or default construct it
 	template <typename T>
 	inline typename std::enable_if<std::is_default_constructible<T>::value, void>::type
-	ReadOptionalProperty(const char *tag, T &ret) {
-		SetTag(tag);
+	ReadOptionalProperty(const field_id_t field_id, const char *tag, T &ret) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			ret = Read<T>();
@@ -104,8 +104,8 @@ public:
 
 	// Special case:
 	// Read into an existing data_ptr_t
-	inline void ReadProperty(const char *tag, data_ptr_t ret, idx_t count) {
-		SetTag(tag);
+	inline void ReadProperty(const field_id_t field_id, const char *tag, data_ptr_t ret, idx_t count) {
+		SetTag(field_id, tag);
 		ReadDataPtr(ret, count);
 	}
 
@@ -128,8 +128,8 @@ public:
 	}
 
 	// Manually begin an object - should be followed by EndObject
-	void BeginObject(const char *tag) {
-		SetTag(tag);
+	void BeginObject(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		OnObjectBegin();
 	}
 
@@ -392,7 +392,8 @@ private:
 	}
 
 protected:
-	virtual void SetTag(const char *tag) {
+	virtual void SetTag(const field_id_t field_id, const char *tag) {
+		(void)field_id;
 		(void)tag;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -28,15 +28,15 @@ protected:
 public:
 	// Serialize a value
 	template <class T>
-	void WriteProperty(const char *tag, const T &value) {
-		SetTag(tag);
+	void WriteProperty(const field_id_t field_id, const char *tag, const T &value) {
+		SetTag(field_id, tag);
 		WriteValue(value);
 	}
 
 	// Optional pointer
 	template <class POINTER>
-	void WriteOptionalProperty(const char *tag, POINTER &&ptr) {
-		SetTag(tag);
+	void WriteOptionalProperty(const field_id_t field_id, const char *tag, POINTER &&ptr) {
+		SetTag(field_id, tag);
 		if (ptr == nullptr) {
 			OnOptionalBegin(false);
 			OnOptionalEnd(false);
@@ -48,14 +48,14 @@ public:
 	}
 
 	// Special case: data_ptr_T
-	void WriteProperty(const char *tag, const_data_ptr_t ptr, idx_t count) {
-		SetTag(tag);
+	void WriteProperty(const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count) {
+		SetTag(field_id, tag);
 		WriteDataPtr(ptr, count);
 	}
 
 	// Manually begin an object - should be followed by EndObject
-	void BeginObject(const char *tag) {
-		SetTag(tag);
+	void BeginObject(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		OnObjectBegin();
 	}
 
@@ -196,7 +196,8 @@ protected:
 	}
 
 	// Handle setting a "tag" (optional)
-	virtual void SetTag(const char *tag) {
+	virtual void SetTag(const field_id_t field_id, const char *tag) {
+		(void)field_id;
 		(void)tag;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -1,5 +1,7 @@
 #pragma once
 #include <type_traits>
+#include <cstdint>
+
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
@@ -10,6 +12,8 @@ namespace duckdb {
 class FormatSerializer;   // Forward declare
 class FormatDeserializer; // Forward declare
 
+typedef uint32_t field_id_t;
+
 // Backport to c++11
 template <class...>
 using void_t = void;

package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp

@@ -50,6 +50,10 @@ public:
 	RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external,
 	                         bool flush = true);
 
+	//	Single block scan
+	RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external,
+	                         idx_t block_idx, bool flush);
+
 	//! The type layout of the payload
 	inline const vector<LogicalType> &GetTypes() const {
 		return layout.GetTypes();
@@ -93,7 +97,7 @@ private:
 	//! Read state
 	ScanState read_state;
 	//! The total count of sorted_data
-	const idx_t total_count;
+	idx_t total_count;
 	//! The number of rows scanned so far
 	idx_t total_scanned;
 	//! Addresses used to gather from the sorted data

package/src/duckdb/src/include/duckdb/execution/physical_operator.hpp

@@ -36,7 +36,6 @@ public:
 public:
 	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
 	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
-		estimated_props = make_uniq<EstimatedProperties>(estimated_cardinality, 0);
 	}
 
 	virtual ~PhysicalOperator() {
@@ -50,7 +49,6 @@ public:
 	vector<LogicalType> types;
 	//! The estimated cardinality of this physical operator
 	idx_t estimated_cardinality;
-	unique_ptr<EstimatedProperties> estimated_props;
 
 	//! The global sink state of this operator
 	unique_ptr<GlobalSinkState> sink_state;

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -104,13 +104,13 @@ public:
 	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
 	                            optional_ptr<FunctionData> bind_info) {
 		D_ASSERT(!function.name.empty());
-		serializer.WriteProperty("name", function.name);
-		serializer.WriteProperty("arguments", function.arguments);
-		serializer.WriteProperty("original_arguments", function.original_arguments);
+		serializer.WriteProperty(500, "name", function.name);
+		serializer.WriteProperty(501, "arguments", function.arguments);
+		serializer.WriteProperty(502, "original_arguments", function.original_arguments);
 		bool has_serialize = function.format_serialize;
-		serializer.WriteProperty("has_serialize", has_serialize);
+		serializer.WriteProperty(503, "has_serialize", has_serialize);
 		if (has_serialize) {
-			serializer.BeginObject("function_data");
+			serializer.BeginObject(504, "function_data");
 			function.format_serialize(serializer, bind_info, function);
 			serializer.EndObject();
 			D_ASSERT(function.format_deserialize);
@@ -135,12 +135,12 @@ public:
 	template <class FUNC, class CATALOG_ENTRY>
 	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto name = deserializer.ReadProperty<string>("name");
-		auto arguments = deserializer.ReadProperty<vector<LogicalType>>("arguments");
-		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>("original_arguments");
+		auto name = deserializer.ReadProperty<string>(500, "name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>(502, "original_arguments");
 		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
 		                                                         std::move(original_arguments));
-		auto has_serialize = deserializer.ReadProperty<bool>("has_serialize");
+		auto has_serialize = deserializer.ReadProperty<bool>(503, "has_serialize");
 		return make_pair(std::move(function), has_serialize);
 	}
 
@@ -150,7 +150,7 @@ public:
 			throw SerializationException("Function requires deserialization but no deserialization function for %s",
 			                             function.name);
 		}
-		deserializer.BeginObject("function_data");
+		deserializer.BeginObject(504, "function_data");
 		auto result = function.format_deserialize(deserializer, function);
 		deserializer.EndObject();
 		return result;

package/src/duckdb/src/include/duckdb/main/pending_query_result.hpp

@@ -34,6 +34,8 @@ public:
 	//! If this returns RESULT_READY, the Execute function can be called to obtain a pointer to the result.
 	//! If this returns RESULT_NOT_READY, the ExecuteTask function should be called again.
 	//! If this returns EXECUTION_ERROR, an error occurred during execution.
+	//! If this returns NO_TASKS_AVAILABLE, this means currently no meaningful work can be done by the current executor,
+	//!	    but tasks may become available in the future.
 	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
 	DUCKDB_API PendingExecutionResult ExecuteTask();
 
@@ -43,6 +45,9 @@ public:
 
 	DUCKDB_API void Close();
 
+	//! Function to determine whether execution is considered finished
+	DUCKDB_API static bool IsFinished(PendingExecutionResult result);
+
 private:
 	shared_ptr<ClientContext> context;
 	bool allow_stream_result;

package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp

@@ -10,17 +10,20 @@
 
 #include "duckdb/main/relation.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 
 namespace duckdb {
 
 class AggregateRelation : public Relation {
 public:
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                             GroupByNode groups);
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
 	                             vector<unique_ptr<ParsedExpression>> groups);
 
 	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> groups;
+	GroupByNode groups;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> child;
 

package/src/duckdb/src/include/duckdb/optimizer/join_order/cardinality_estimator.hpp

@@ -7,21 +7,14 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/planner/column_binding.hpp"
 #include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
+#include "duckdb/optimizer/join_order/query_graph.hpp"
+
+#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
 
 namespace duckdb {
 
-struct RelationAttributes {
-	string original_name;
-	// the relation columns used in join filters
-	// Needed when iterating over columns and initializing total domain values.
-	unordered_set<idx_t> columns;
-	double cardinality;
-};
+struct FilterInfo;
 
 struct RelationsToTDom {
 	//! column binding sets that are equivalent in a join plan.
@@ -33,19 +26,13 @@ struct RelationsToTDom {
 	idx_t tdom_no_hll;
 	bool has_tdom_hll;
 	vector<FilterInfo *> filters;
+	vector<string> column_names;
 
 	RelationsToTDom(const column_binding_set_t &column_binding_set)
 	    : equivalent_relations(column_binding_set), tdom_hll(0), tdom_no_hll(NumericLimits<idx_t>::Maximum()),
 	      has_tdom_hll(false) {};
 };
 
-struct NodeOp {
-	unique_ptr<JoinNode> node;
-	LogicalOperator &op;
-
-	NodeOp(unique_ptr<JoinNode> node, LogicalOperator &op) : node(std::move(node)), op(op) {};
-};
-
 struct Subgraph2Denominator {
 	unordered_set<idx_t> relations;
 	double denom;
@@ -53,69 +40,56 @@ struct Subgraph2Denominator {
 	Subgraph2Denominator() : relations(), denom(1) {};
 };
 
-class CardinalityEstimator {
+class CardinalityHelper {
 public:
-	explicit CardinalityEstimator(ClientContext &context) : context(context) {
+	CardinalityHelper() {
 	}
+	CardinalityHelper(double cardinality_before_filters, double filter_string)
+	    : cardinality_before_filters(cardinality_before_filters), filter_strength(filter_string) {};
 
-private:
-	ClientContext &context;
+public:
+	double cardinality_before_filters;
+	double filter_strength;
+
+	vector<string> table_names_joined;
+	vector<string> column_names;
+};
 
-	//! A mapping of relation id -> RelationAttributes
-	unordered_map<idx_t, RelationAttributes> relation_attributes;
-	//! A mapping of (relation, bound_column) -> (actual table, actual column)
-	column_binding_map_t<ColumnBinding> relation_column_to_original_column;
+class CardinalityEstimator {
+public:
+	explicit CardinalityEstimator() {};
 
+private:
 	vector<RelationsToTDom> relations_to_tdoms;
+	unordered_map<string, CardinalityHelper> relation_set_2_cardinality;
+	JoinRelationSetManager set_manager;
+	vector<RelationStats> relation_stats;
 
 public:
-	static constexpr double DEFAULT_SELECTIVITY = 0.2;
-
-	static void VerifySymmetry(JoinNode &result, JoinNode &entry);
-
-	//! given a binding of (relation, column) used for DP, and a (table, column) in that catalog
-	//! Add the key value entry into the relation_column_to_original_column
-	void AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value);
-	//! Add a column to the relation_to_columns map.
-	void AddColumnToRelationMap(idx_t table_index, idx_t column_index);
-	//! Dump all bindings in relation_column_to_original_column into the child_binding_map
-	// If you have a non-reorderable join, this function is used to keep track of bindings
-	// in the child join plan.
-	void CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map);
-	void MergeBindings(idx_t, idx_t relation_id, vector<column_binding_map_t<ColumnBinding>> &child_binding_maps);
-	void AddRelationColumnMapping(LogicalGet &get, idx_t relation_id);
-
-	void InitTotalDomains();
-	void UpdateTotalDomains(JoinNode &node, LogicalOperator &op);
-	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> &filter_infos);
-
-	void InitCardinalityEstimatorProps(vector<NodeOp> &node_ops, vector<unique_ptr<FilterInfo>> &filter_infos);
-	double EstimateCardinalityWithSet(JoinRelationSet &new_set);
-	void EstimateBaseTableCardinality(JoinNode &node, LogicalOperator &op);
-	double EstimateCrossProduct(const JoinNode &left, const JoinNode &right);
-	static double ComputeCost(JoinNode &left, JoinNode &right, double expected_cardinality);
+	void RemoveEmptyTotalDomains();
+	void UpdateTotalDomains(optional_ptr<JoinRelationSet> set, RelationStats &stats);
+	void InitEquivalentRelations(const vector<unique_ptr<FilterInfo>> &filter_infos);
+
+	void InitCardinalityEstimatorProps(optional_ptr<JoinRelationSet> set, RelationStats &stats);
+
+	//! cost model needs estimated cardinalities to the fraction since the formula captures
+	//! distinct count selectivities and multiplicities. Hence the template
+	template <class T>
+	T EstimateCardinalityWithSet(JoinRelationSet &new_set);
+
+	//! used for debugging.
+	void AddRelationNamesToTdoms(vector<RelationStats> &stats);
+	void PrintRelationToTdomInfo();
 
 private:
 	bool SingleColumnFilter(FilterInfo &filter_info);
-	//! Filter & bindings -> list of indexes into the equivalent_relations array.
-	// The column binding set at each index is an equivalence set.
 	vector<idx_t> DetermineMatchingEquivalentSets(FilterInfo *filter_info);
-
 	//! Given a filter, add the column bindings to the matching equivalent set at the index
 	//! given in matching equivalent sets.
 	//! If there are multiple equivalence sets, they are merged.
 	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
-
-	optional_ptr<TableFilterSet> GetTableFilters(LogicalOperator &op, idx_t table_index);
-
 	void AddRelationTdom(FilterInfo &filter_info);
 	bool EmptyFilter(FilterInfo &filter_info);
-
-	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &fil,
-	                            unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &fil,
-	                           unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator &op, TableFilterSet &table_filters, idx_t table_index);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/cost_model.hpp

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/cost_model.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+#pragma once
+
+#include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
+
+namespace duckdb {
+
+class QueryGraphManager;
+
+class CostModel {
+public:
+	CostModel(QueryGraphManager &query_graph_manager);
+
+private:
+	//! query graph storing relation manager information
+	QueryGraphManager &query_graph_manager;
+
+public:
+	void InitCostModel();
+
+	//! Compute cost of a join relation set
+	double ComputeCost(JoinNode &left, JoinNode &right);
+
+	//! Cardinality Estimator used to calculate cost
+	CardinalityEstimator cardinality_estimator;
+
+private:
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/join_node.hpp

@@ -5,62 +5,47 @@
 //
 //
 //===----------------------------------------------------------------------===//
-
 #pragma once
 
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/join_order/estimated_properties.hpp"
 #include "duckdb/optimizer/join_order/join_relation.hpp"
 #include "duckdb/optimizer/join_order/query_graph.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
 
-class JoinOrderOptimizer;
+struct NeighborInfo;
 
 class JoinNode {
 public:
 	//! Represents a node in the join plan
 	JoinRelationSet &set;
+	//! information on how left and right are connected
 	optional_ptr<NeighborInfo> info;
-	//! If the JoinNode is a base table, then base_cardinality is the cardinality before filters
-	//! estimated_props.cardinality will be the cardinality after filters. With no filters, the two are equal
-	bool has_filter;
+	//! left and right plans
 	optional_ptr<JoinNode> left;
 	optional_ptr<JoinNode> right;
 
-	unique_ptr<EstimatedProperties> estimated_props;
+	//! The cost of the join node. The cost is stored here so that the cost of
+	//! a join node stays in sync with how the join node is constructed. Storing the cost in an unordered_set
+	//! in the cost model is error prone. If the plan enumerator join node is updated and not the cost model
+	//! the whole Join Order Optimizer can start exhibiting undesired behavior.
+	double cost;
+	//! used only to populate logical operators with estimated caridnalities after the best join plan has been found.
+	idx_t cardinality;
+
+	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
+	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right, double cost);
 
 	//! Create a leaf node in the join tree
 	//! set cost to 0 for leaf nodes
 	//! cost will be the cost to *produce* an intermediate table
-	JoinNode(JoinRelationSet &set, const double base_cardinality);
-
-	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
-	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right,
-	         const double base_cardinality, double cost);
+	JoinNode(JoinRelationSet &set);
 
 	bool operator==(const JoinNode &other) {
 		return other.set.ToString().compare(set.ToString()) == 0;
 	}
 
 private:
-	double base_cardinality;
-
 public:
-	template <class CARDINALITY_TYPE>
-	CARDINALITY_TYPE GetCardinality() const {
-		return estimated_props->GetCardinality<CARDINALITY_TYPE>();
-	}
-	double GetCost();
-	void SetCost(double cost);
-	double GetBaseTableCardinality();
-	void SetBaseTableCardinality(double base_card);
-	void SetEstimatedCardinality(double estimated_card);
 	void PrintJoinNode();
 	string ToString();
 };