duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

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

@@ -8,12 +8,18 @@
 
 #pragma once
 
-#include <string>
 #include "duckdb.hpp"
 #include "duckdb/main/extension_entries.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+
+#include <string>
+
+#include <string>
 
 namespace duckdb {
+
 class DuckDB;
+class HTTPLogger;
 
 enum class ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0, EXTENSION_UNKNOWN = 1, NOT_LOADED = 2 };
 
@@ -31,11 +37,47 @@ struct ExtensionAlias {
 struct ExtensionInitResult {
 	string filename;
 	string filebase;
-	string extension_version;
+
+	// The deserialized install from the `<ext>.duckdb_extension.info` file
+	unique_ptr<ExtensionInstallInfo> install_info;
 
 	void *lib_hdl;
 };
 
+// Tags describe what happened during the updating process
+enum class ExtensionUpdateResultTag : uint8_t {
+	// Fallback for when installation information is missing
+	UNKNOWN = 0,
+
+	// Either a fresh file was downloaded and versions are identical
+	NO_UPDATE_AVAILABLE = 1,
+	// Only extensions from repositories can be updated
+	NOT_A_REPOSITORY = 2,
+	// Only known, currently installed extensions can be updated
+	NOT_INSTALLED = 3,
+	// Statically loaded extensions can not be updated; they are baked into the DuckDB executable
+	STATICALLY_LOADED = 4,
+	// This means the .info file written during installation was missing or malformed
+	MISSING_INSTALL_INFO = 5,
+
+	// The extension was re-downloaded from the repository, but due to a lack of version information
+	// its impossible to tell if the extension is actually updated
+	REDOWNLOADED = 254,
+	// The version was updated to a new version
+	UPDATED = 255,
+};
+
+struct ExtensionUpdateResult {
+	ExtensionUpdateResultTag tag = ExtensionUpdateResultTag::UNKNOWN;
+
+	string extension_name;
+	string repository;
+
+	string extension_version;
+	string prev_version;
+	string installed_version;
+};
+
 class ExtensionHelper {
 public:
 	static void LoadAllExtensions(DuckDB &db);
@@ -43,10 +85,14 @@ public:
 	static ExtensionLoadResult LoadExtension(DuckDB &db, const std::string &extension);
 
 	//! Install an extension
-	static void InstallExtension(ClientContext &context, const string &extension, bool force_install,
-	                             const string &respository = "");
-	static void InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install,
-	                             const string &respository = "");
+	static unique_ptr<ExtensionInstallInfo> InstallExtension(ClientContext &context, const string &extension,
+	                                                         bool force_install,
+	                                                         optional_ptr<ExtensionRepository> repository = nullptr,
+	                                                         const string &version = "");
+	static unique_ptr<ExtensionInstallInfo> InstallExtension(DBConfig &config, FileSystem &fs, const string &extension,
+	                                                         bool force_install,
+	                                                         optional_ptr<ExtensionRepository> repository = nullptr,
+	                                                         const string &version = "");
 	//! Load an extension
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
 	static void LoadExternalExtension(DatabaseInstance &db, FileSystem &fs, const string &extension);
@@ -58,12 +104,25 @@ public:
 	//! Autoload an extension (depending on config, potentially a nop. Returns false on failure)
 	DUCKDB_API static bool TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept;
 
+	//! Update all extensions, return a vector of extension names that were updated;
+	static vector<ExtensionUpdateResult> UpdateExtensions(ClientContext &context);
+	static vector<ExtensionUpdateResult> UpdateExtensions(DatabaseInstance &db, FileSystem &fs);
+	//! Update a specific extension
+	static ExtensionUpdateResult UpdateExtension(ClientContext &context, const string &extension_name);
+	static ExtensionUpdateResult UpdateExtension(DatabaseInstance &db, FileSystem &fs, const string &extension_name);
+
 	//! Get the extension directory base on the current config
 	static string ExtensionDirectory(ClientContext &context);
 	static string ExtensionDirectory(DBConfig &config, FileSystem &fs);
 
+	static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata,
+	                                    const bool allow_community_extensions);
+	static ParsedExtensionMetaData ParseExtensionMetaData(const char *metadata);
+	static ParsedExtensionMetaData ParseExtensionMetaData(FileHandle &handle);
+
 	//! Get the extension url template, containing placeholders for version, platform and extension name
-	static string ExtensionUrlTemplate(optional_ptr<const DBConfig> config, const string &repository);
+	static string ExtensionUrlTemplate(optional_ptr<const DBConfig> config, const ExtensionRepository &repository,
+	                                   const string &version);
 	//! Return the extension url template with the variables replaced
 	static string ExtensionFinalizeUrlTemplate(const string &url, const string &name);
 
@@ -77,11 +136,14 @@ public:
 	static ExtensionAlias GetExtensionAlias(idx_t index);
 
 	//! Get public signing keys for extension signing
-	static const vector<string> GetPublicKeys();
+	static const vector<string> GetPublicKeys(bool allow_community_extension = false);
 
 	// Returns extension name, or empty string if not a replacement open path
 	static string ExtractExtensionPrefixFromPath(const string &path);
 
+	// Returns the user-readable name of a repository URL
+	static string GetRepositoryName(const string &repository_base_url);
+
 	//! Apply any known extension aliases, return the lowercase name
 	static string ApplyExtensionAlias(const string &extension_name);
 
@@ -147,9 +209,16 @@ public:
 	//! For tagged releases we use the tag, else we use the git commit hash
 	static const string GetVersionDirectoryName();
 
+	static bool IsRelease(const string &version_tag);
+	static bool CreateSuggestions(const string &extension_name, string &message);
+
 private:
-	static void InstallExtensionInternal(DBConfig &config, FileSystem &fs, const string &local_path,
-	                                     const string &extension, bool force_install, const string &repository);
+	static unique_ptr<ExtensionInstallInfo> InstallExtensionInternal(DBConfig &config, FileSystem &fs,
+	                                                                 const string &local_path, const string &extension,
+	                                                                 bool force_install, const string &version,
+	                                                                 optional_ptr<ExtensionRepository> repository,
+	                                                                 optional_ptr<HTTPLogger> http_logger = nullptr,
+	                                                                 optional_ptr<ClientContext> context = nullptr);
 	static const vector<string> PathComponents();
 	static string DefaultExtensionFolder(FileSystem &fs);
 	static bool AllowAutoInstall(const string &extension);
@@ -158,8 +227,6 @@ private:
 	                           string &error);
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'
 	static const string NormalizeVersionTag(const string &version_tag);
-	static bool IsRelease(const string &version_tag);
-	static bool CreateSuggestions(const string &extension_name, string &message);
 
 private:
 	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);

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

@@ -0,0 +1,89 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension_install_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/main/config.hpp"
+
+#pragma once
+
+namespace duckdb {
+class FileSystem;
+
+enum class ExtensionInstallMode : uint8_t {
+	// Fallback for when install info is missing
+	UNKNOWN = 0,
+	//! Extension was installed using a url deduced from a repository base url
+	REPOSITORY = 1,
+	//! Extension was install from a custom path, this could be either local or remote
+	CUSTOM_PATH = 2,
+	//! Extension was statically linked
+	STATICALLY_LINKED = 3,
+	//! Extension is not installed, for example the extension might be directly loaded without installing
+	NOT_INSTALLED = 4
+};
+
+class ExtensionInstallInfo {
+public:
+	//! How the extension was installed
+	ExtensionInstallMode mode = ExtensionInstallMode::UNKNOWN;
+	//! (optional) Full path where the extension came from
+	string full_path;
+	//! (optional) Repository url where the extension came from
+	string repository_url;
+	//! (optional) Version of the extension
+	string version;
+
+	void Serialize(Serializer &serializer) const;
+
+	//! Try to read install info. returns ExtensionInstallMode::UNKNOWN on missing file, and throws on corrupt file
+	static unique_ptr<ExtensionInstallInfo> TryReadInfoFile(FileSystem &fs, const string &info_file_path,
+	                                                        const string &extension_name);
+
+	static unique_ptr<ExtensionInstallInfo> Deserialize(Deserializer &deserializer);
+};
+
+struct ExtensionRepository {
+	//! All currently available repositories
+	static constexpr const char *CORE_REPOSITORY_URL = "http://extensions.duckdb.org";
+	static constexpr const char *CORE_NIGHTLY_REPOSITORY_URL = "http://nightly-extensions.duckdb.org";
+	static constexpr const char *COMMUNITY_REPOSITORY_URL = "http://community-extensions.duckdb.org";
+
+	//! Debugging repositories (target local, relative paths that are produced by DuckDB's build system)
+	static constexpr const char *BUILD_DEBUG_REPOSITORY_PATH = "./build/debug/repository";
+	static constexpr const char *BUILD_RELEASE_REPOSITORY_PATH = "./build/release/repository";
+
+	//! The default is CORE
+	static constexpr const char *DEFAULT_REPOSITORY_URL = CORE_REPOSITORY_URL;
+
+	//! Returns the repository name is this is a known repository, or the full url if it is not
+	static string GetRepository(const string &repository_url);
+	//! Try to convert a repository to a url, will return empty string if the repository is unknown
+	static string TryGetRepositoryUrl(const string &repository);
+	//! Try to convert a url to a known repository name, will return empty string if the repository is unknown
+	static string TryConvertUrlToKnownRepository(const string &url);
+
+	//! Get the default repository, optionally passing a config to allow
+	static ExtensionRepository GetDefaultRepository(optional_ptr<DBConfig> config);
+	static ExtensionRepository GetDefaultRepository(ClientContext &context);
+
+	static ExtensionRepository GetCoreRepository();
+	static ExtensionRepository GetRepositoryByUrl(const string &url);
+
+	ExtensionRepository();
+	ExtensionRepository(const string &name, const string &url);
+
+	//! Print the name if it has one, or the full path if not
+	string ToReadableString();
+
+	//! Repository name
+	string name;
+	//! Repository path/url
+	string path;
+};
+
+} // namespace duckdb

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

@@ -12,6 +12,7 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/main/secret/secret.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
 
 namespace duckdb {
 struct CreateMacroInfo;
@@ -59,7 +60,8 @@ public:
 	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
 
 	//! Registers a new type
-	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type);
+	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
+	                                    bind_type_modifiers_function_t bind_type_modifiers = nullptr);
 
 	//! Registers a new secret type
 	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);

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

@@ -6,17 +6,59 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "duckdb/common/case_insensitive_map.hpp"
+#include <functional>
+
 #pragma once
 
 namespace duckdb {
 
-enum class ExternalDependenciesType : uint8_t { PYTHON_DEPENDENCY };
+class DependencyItem {
+public:
+	virtual ~DependencyItem() {};
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		DynamicCastCheck<TARGET>(this);
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+};
+
+using dependency_scan_t = std::function<void(const string &name, shared_ptr<DependencyItem> item)>;
 
 class ExternalDependency {
 public:
-	explicit ExternalDependency(ExternalDependenciesType type_p) : type(type_p) {};
-	virtual ~ExternalDependency() {};
-	ExternalDependenciesType type;
+	explicit ExternalDependency() {
+	}
+	~ExternalDependency() {
+	}
+
+public:
+	void AddDependency(const string &name, shared_ptr<DependencyItem> item) {
+		objects[name] = std::move(item);
+	}
+	shared_ptr<DependencyItem> GetDependency(const string &name) const {
+		auto it = objects.find(name);
+		if (it == objects.end()) {
+			return nullptr;
+		}
+		return it->second;
+	}
+	void ScanDependencies(const dependency_scan_t &callback) {
+		for (auto &kv : objects) {
+			callback(kv.first, kv.second);
+		}
+	}
+
+private:
+	//! The objects encompassed by this dependency
+	case_insensitive_map_t<shared_ptr<DependencyItem>> objects;
 };
 
 } // namespace duckdb

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

@@ -53,6 +53,9 @@ public:
 	//! Returns a reference to the underlying column data collection
 	ColumnDataCollection &Collection();
 
+	//! Takes ownership of the collection, 'collection' is null after this operation
+	unique_ptr<ColumnDataCollection> TakeCollection();
+
 private:
 	unique_ptr<ColumnDataCollection> collection;
 	//! Row collection, only created if GetValue is called

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

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/relation/materialized_relation.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/relation.hpp"
+#include "duckdb/parser/parsed_expression.hpp"
+
+namespace duckdb {
+
+class MaterializedRelation : public Relation {
+public:
+	MaterializedRelation(const shared_ptr<ClientContext> &context, unique_ptr<ColumnDataCollection> &&collection,
+	                     vector<string> names, string alias = "materialized");
+	MaterializedRelation(const shared_ptr<ClientContext> &context, const string &values, vector<string> names,
+	                     string alias = "materialized");
+
+	unique_ptr<ColumnDataCollection> collection;
+	vector<ColumnDefinition> columns;
+	string alias;
+
+public:
+	const vector<ColumnDefinition> &Columns() override;
+	string ToString(idx_t depth) override;
+	string GetAlias() override;
+	unique_ptr<TableRef> GetTableRef() override;
+	unique_ptr<QueryNode> GetQueryNode() override;
+};
+
+} // namespace duckdb

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

@@ -16,7 +16,7 @@ class SelectStatement;
 
 class QueryRelation : public Relation {
 public:
-	QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
+	QueryRelation(const shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
 	~QueryRelation() override;
 
 	unique_ptr<SelectStatement> select_stmt;

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

@@ -14,11 +14,11 @@ namespace duckdb {
 
 class TableFunctionRelation : public Relation {
 public:
-	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
 	                      bool auto_init = true);
 
-	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr, bool auto_init = true);
 	~TableFunctionRelation() override {
 	}

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

@@ -15,7 +15,7 @@ namespace duckdb {
 
 class TableRelation : public Relation {
 public:
-	TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
+	TableRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
 
 	unique_ptr<TableDescription> description;
 

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

@@ -15,9 +15,9 @@ namespace duckdb {
 
 class ValueRelation : public Relation {
 public:
-	ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
-	              vector<string> names, string alias = "values");
-	ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values, vector<string> names,
+	ValueRelation(const shared_ptr<ClientContext> &context, const vector<vector<Value>> &values, vector<string> names,
+	              string alias = "values");
+	ValueRelation(const shared_ptr<ClientContext> &context, const string &values, vector<string> names,
 	              string alias = "values");
 
 	vector<vector<unique_ptr<ParsedExpression>>> expressions;

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

@@ -14,7 +14,7 @@ namespace duckdb {
 
 class ViewRelation : public Relation {
 public:
-	ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name, string view_name);
+	ViewRelation(const shared_ptr<ClientContext> &context, string schema_name, string view_name);
 
 	string schema_name;
 	string view_name;

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

@@ -17,6 +17,7 @@
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/common/named_parameter_map.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/main/client_context_wrapper.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
@@ -28,15 +29,14 @@
 namespace duckdb {
 struct BoundStatement;
 
-class ClientContextWrapper;
 class Binder;
 class LogicalOperator;
 class QueryNode;
 class TableRef;
 
-class Relation : public std::enable_shared_from_this<Relation> {
+class Relation : public enable_shared_from_this<Relation> {
 public:
-	Relation(const std::shared_ptr<ClientContext> &context, RelationType type) : context(context), type(type) {
+	Relation(const shared_ptr<ClientContext> &context, RelationType type) : context(context), type(type) {
 	}
 	Relation(ClientContextWrapper &context, RelationType type) : context(context.GetContext()), type(type) {
 	}
@@ -44,10 +44,8 @@ public:
 	}
 
 	ClientContextWrapper context;
-
 	RelationType type;
-
-	shared_ptr<ExternalDependency> extra_dependencies;
+	vector<shared_ptr<ExternalDependency>> external_dependencies;
 
 public:
 	DUCKDB_API virtual const vector<ColumnDefinition> &Columns() = 0;
@@ -172,6 +170,7 @@ public:
 	virtual Relation *ChildRelation() {
 		return nullptr;
 	}
+	void AddExternalDependency(shared_ptr<ExternalDependency> dependency);
 	DUCKDB_API vector<shared_ptr<ExternalDependency>> GetAllDependencies();
 
 protected:

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

@@ -225,6 +225,15 @@ struct AllowUnsignedExtensionsSetting {
 	static Value GetSetting(const ClientContext &context);
 };
 
+struct AllowCommunityExtensionsSetting {
+	static constexpr const char *Name = "allow_community_extensions";
+	static constexpr const char *Description = "Allow to load community built extensions";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(const ClientContext &context);
+};
+
 struct AllowExtensionsMetadataMismatchSetting {
 	static constexpr const char *Name = "allow_extensions_metadata_mismatch";
 	static constexpr const char *Description = "Allow to load extensions with not compatible metadata";
@@ -291,6 +300,15 @@ struct EnableObjectCacheSetting {
 	static Value GetSetting(const ClientContext &context);
 };
 
+struct StorageCompatibilityVersion {
+	static constexpr const char *Name = "storage_compatibility_version";
+	static constexpr const char *Description = "Serialize on checkpoint with compatibility for a given duckdb version";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(const ClientContext &context);
+};
+
 struct EnableHTTPMetadataCacheSetting {
 	static constexpr const char *Name = "enable_http_metadata_cache";
 	static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata";
@@ -471,6 +489,16 @@ struct MaximumMemorySetting {
 	static Value GetSetting(const ClientContext &context);
 };
 
+struct MaximumTempDirectorySize {
+	static constexpr const char *Name = "max_temp_directory_size";
+	static constexpr const char *Description =
+	    "The maximum amount of data stored inside the 'temp_directory' (when set) (e.g. 1GB)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(const ClientContext &context);
+};
+
 struct OldImplicitCasting {
 	static constexpr const char *Name = "old_implicit_casting";
 	static constexpr const char *Description = "Allow implicit casting to/from VARCHAR";
@@ -661,4 +689,23 @@ struct CustomUserAgentSetting {
 	static Value GetSetting(const ClientContext &context);
 };
 
+struct EnableHTTPLoggingSetting {
+	static constexpr const char *Name = "enable_http_logging";
+	static constexpr const char *Description = "Enables HTTP logging";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(const ClientContext &context);
+};
+
+struct HTTPLoggingOutputSetting {
+	static constexpr const char *Name = "http_logging_output";
+	static constexpr const char *Description =
+	    "The file to which HTTP logging output should be saved, or empty to print to the terminal";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(const ClientContext &context);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/filter_pushdown.hpp

@@ -18,7 +18,7 @@ class Optimizer;
 
 class FilterPushdown {
 public:
-	explicit FilterPushdown(Optimizer &optimizer);
+	explicit FilterPushdown(Optimizer &optimizer, bool convert_mark_joins = true);
 
 	//! Perform filter pushdown
 	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
@@ -38,9 +38,11 @@ public:
 	};
 
 private:
-	vector<unique_ptr<Filter>> filters;
 	Optimizer &optimizer;
+	FilterCombiner combiner;
+	bool convert_mark_joins;
 
+	vector<unique_ptr<Filter>> filters;
 	//! Push down a LogicalAggregate op
 	unique_ptr<LogicalOperator> PushdownAggregate(unique_ptr<LogicalOperator> op);
 	//! Push down a distinct operator
@@ -90,8 +92,6 @@ private:
 	void GenerateFilters();
 	//! if there are filters in this FilterPushdown node, push them into the combiner
 	void PushFilters();
-
-	FilterCombiner combiner;
 };
 
 } // namespace duckdb

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

@@ -26,7 +26,7 @@ public:
 	void InitCostModel();
 
 	//! Compute cost of a join relation set
-	double ComputeCost(JoinNode &left, JoinNode &right);
+	double ComputeCost(DPJoinNode &left, DPJoinNode &right);
 
 	//! Cardinality Estimator used to calculate cost
 	CardinalityEstimator cardinality_estimator;

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

@@ -14,40 +14,33 @@ namespace duckdb {
 
 struct NeighborInfo;
 
-class JoinNode {
+class DPJoinNode {
 public:
 	//! Represents a node in the join plan
 	JoinRelationSet &set;
 	//! information on how left and right are connected
 	optional_ptr<NeighborInfo> info;
+	bool is_leaf;
 	//! left and right plans
-	optional_ptr<JoinNode> left;
-	optional_ptr<JoinNode> right;
+	JoinRelationSet &left_set;
+	JoinRelationSet &right_set;
 
 	//! 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.
+	//! used only to populate logical operators with estimated cardinalities 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);
+	DPJoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinRelationSet &left, JoinRelationSet &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
-	explicit JoinNode(JoinRelationSet &set);
-
-	bool operator==(const JoinNode &other) {
-		return other.set.ToString().compare(set.ToString()) == 0;
-	}
-
-private:
-public:
-	void Print();
-	string ToString();
+	explicit DPJoinNode(JoinRelationSet &set);
 };
 
 } // namespace duckdb