duckdb 0.4.1-dev2230.0 → 0.4.1-dev2256.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "8da46a992"
-#define DUCKDB_VERSION "v0.4.1-dev2230"
+#define DUCKDB_SOURCE_ID "895f02f49"
+#define DUCKDB_VERSION "v0.4.1-dev2256"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -7823,6 +7823,8 @@ public:
 	virtual void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const;
 
+	idx_t GetDistinctCount();
+
 	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
 
 	//! Verify that a vector does not violate the statistics
@@ -8694,116 +8696,10 @@ DUCKDB_API TypeCatalogEntry *Catalog::GetEntry(ClientContext &context, const str
 
 } // namespace duckdb
 
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/logical_operator_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Logical Operator Types
-//===--------------------------------------------------------------------===//
-enum class LogicalOperatorType : uint8_t {
-	LOGICAL_INVALID = 0,
-	LOGICAL_PROJECTION = 1,
-	LOGICAL_FILTER = 2,
-	LOGICAL_AGGREGATE_AND_GROUP_BY = 3,
-	LOGICAL_WINDOW = 4,
-	LOGICAL_UNNEST = 5,
-	LOGICAL_LIMIT = 6,
-	LOGICAL_ORDER_BY = 7,
-	LOGICAL_TOP_N = 8,
-	LOGICAL_COPY_TO_FILE = 10,
-	LOGICAL_DISTINCT = 11,
-	LOGICAL_SAMPLE = 12,
-	LOGICAL_LIMIT_PERCENT = 13,
-
-	// -----------------------------
-	// Data sources
-	// -----------------------------
-	LOGICAL_GET = 25,
-	LOGICAL_CHUNK_GET = 26,
-	LOGICAL_DELIM_GET = 27,
-	LOGICAL_EXPRESSION_GET = 28,
-	LOGICAL_DUMMY_SCAN = 29,
-	LOGICAL_EMPTY_RESULT = 30,
-	LOGICAL_CTE_REF = 31,
-	// -----------------------------
-	// Joins
-	// -----------------------------
-	LOGICAL_JOIN = 50,
-	LOGICAL_DELIM_JOIN = 51,
-	LOGICAL_COMPARISON_JOIN = 52,
-	LOGICAL_ANY_JOIN = 53,
-	LOGICAL_CROSS_PRODUCT = 54,
-	// -----------------------------
-	// SetOps
-	// -----------------------------
-	LOGICAL_UNION = 75,
-	LOGICAL_EXCEPT = 76,
-	LOGICAL_INTERSECT = 77,
-	LOGICAL_RECURSIVE_CTE = 78,
-
-	// -----------------------------
-	// Updates
-	// -----------------------------
-	LOGICAL_INSERT = 100,
-	LOGICAL_DELETE = 101,
-	LOGICAL_UPDATE = 102,
-
-	// -----------------------------
-	// Schema
-	// -----------------------------
-	LOGICAL_ALTER = 125,
-	LOGICAL_CREATE_TABLE = 126,
-	LOGICAL_CREATE_INDEX = 127,
-	LOGICAL_CREATE_SEQUENCE = 128,
-	LOGICAL_CREATE_VIEW = 129,
-	LOGICAL_CREATE_SCHEMA = 130,
-	LOGICAL_CREATE_MACRO = 131,
-	LOGICAL_DROP = 132,
-	LOGICAL_PRAGMA = 133,
-	LOGICAL_TRANSACTION = 134,
-	LOGICAL_CREATE_TYPE = 135,
-
-	// -----------------------------
-	// Explain
-	// -----------------------------
-	LOGICAL_EXPLAIN = 150,
-
-	// -----------------------------
-	// Show
-	// -----------------------------
-	LOGICAL_SHOW = 160,
-
-	// -----------------------------
-	// Helpers
-	// -----------------------------
-	LOGICAL_PREPARE = 175,
-	LOGICAL_EXECUTE = 176,
-	LOGICAL_EXPORT = 177,
-	LOGICAL_VACUUM = 178,
-	LOGICAL_SET = 179,
-	LOGICAL_LOAD = 180
-};
-
-DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
-
-} // namespace duckdb
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/expression.hpp
+// duckdb/optimizer/estimated_properties.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -8815,7 +8711,7 @@ DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/plan_serialization.hpp
+// duckdb/optimizer/join_order/join_relation.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -8824,122 +8720,98 @@ DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/bound_parameter_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
 
 
 namespace duckdb {
+class LogicalOperator;
 
-struct BoundParameterData;
-
-using bound_parameter_map_t = unordered_map<idx_t, shared_ptr<BoundParameterData>>;
+//! Represents a single relation and any metadata accompanying that relation
+struct SingleJoinRelation {
+	LogicalOperator *op;
+	LogicalOperator *parent;
 
-} // namespace duckdb
+	SingleJoinRelation() {
+	}
+	SingleJoinRelation(LogicalOperator *op, LogicalOperator *parent) : op(op), parent(parent) {
+	}
+};
 
+//! Set of relations, used in the join graph.
+struct JoinRelationSet {
+	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(move(relations)), count(count) {
+	}
 
-namespace duckdb {
-class ClientContext;
-class LogicalOperator;
-struct BoundParameterData;
+	string ToString() const;
 
-struct PlanDeserializationState {
-	PlanDeserializationState(ClientContext &context);
-	~PlanDeserializationState();
+	unique_ptr<idx_t[]> relations;
+	idx_t count;
 
-	ClientContext &context;
-	bound_parameter_map_t parameter_data;
+	static bool IsSubset(JoinRelationSet *super, JoinRelationSet *sub);
 };
 
-struct LogicalDeserializationState {
-	LogicalDeserializationState(PlanDeserializationState &gstate, LogicalOperatorType type,
-	                            vector<unique_ptr<LogicalOperator>> &children);
-
-	PlanDeserializationState &gstate;
-	LogicalOperatorType type;
-	vector<unique_ptr<LogicalOperator>> &children;
-};
+//! The JoinRelationTree is a structure holding all the created JoinRelationSet objects and allowing fast lookup on to
+//! them
+class JoinRelationSetManager {
+public:
+	//! Contains a node with a JoinRelationSet and child relations
+	// FIXME: this structure is inefficient, could use a bitmap for lookup instead (todo: profile)
+	struct JoinRelationTreeNode {
+		unique_ptr<JoinRelationSet> relation;
+		unordered_map<idx_t, unique_ptr<JoinRelationTreeNode>> children;
+	};
 
-struct ExpressionDeserializationState {
-	ExpressionDeserializationState(PlanDeserializationState &gstate, ExpressionType type);
+public:
+	//! Create or get a JoinRelationSet from a single node with the given index
+	JoinRelationSet *GetJoinRelation(idx_t index);
+	//! Create or get a JoinRelationSet from a set of relation bindings
+	JoinRelationSet *GetJoinRelation(unordered_set<idx_t> &bindings);
+	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
+	JoinRelationSet *GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
+	//! Union two sets of relations together and create a new relation set
+	JoinRelationSet *Union(JoinRelationSet *left, JoinRelationSet *right);
+	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)
+	// JoinRelationSet *Difference(JoinRelationSet *left, JoinRelationSet *right);
 
-	PlanDeserializationState &gstate;
-	ExpressionType type;
+private:
+	JoinRelationTreeNode root;
 };
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression_map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-namespace duckdb {
-class BaseStatistics;
-class FieldWriter;
-class FieldReader;
-class ClientContext;
-
-//!  The Expression class represents a bound Expression with a return type
-class Expression : public BaseExpression {
-public:
-	Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type);
-	~Expression() override;
 
-	//! The return type of the expression
-	LogicalType return_type;
-	//! Expression statistics (if any) - ONLY USED FOR VERIFICATION
-	unique_ptr<BaseStatistics> verification_stats;
 
-public:
-	bool IsAggregate() const override;
-	bool IsWindow() const override;
-	bool HasSubquery() const override;
-	bool IsScalar() const override;
-	bool HasParameter() const override;
-	virtual bool HasSideEffects() const;
-	virtual bool PropagatesNullValues() const;
-	virtual bool IsFoldable() const;
 
-	hash_t Hash() const override;
 
-	bool Equals(const BaseExpression *other) const override {
-		if (!BaseExpression::Equals(other)) {
-			return false;
-		}
-		return return_type == ((Expression *)other)->return_type;
-	}
 
-	static bool Equals(Expression *left, Expression *right) {
-		return BaseExpression::Equals((BaseExpression *)left, (BaseExpression *)right);
-	}
-	//! Create a copy of this expression
-	virtual unique_ptr<Expression> Copy() = 0;
 
-	//! Serializes an Expression to a stand-alone binary blob
-	void Serialize(Serializer &serializer) const;
-	//! Serializes an Expression to a stand-alone binary blob
-	virtual void Serialize(FieldWriter &writer) const = 0;
+namespace duckdb {
+class Expression;
 
-	//! Deserializes a blob back into an Expression [CAN THROW:
-	//! SerializationException]
-	static unique_ptr<Expression> Deserialize(Deserializer &source, PlanDeserializationState &state);
+struct ExpressionHashFunction {
+	uint64_t operator()(const BaseExpression *const &expr) const {
+		return (uint64_t)expr->Hash();
+	}
+};
 
-protected:
-	//! Copy base Expression properties from another expression to this one,
-	//! used in Copy method
-	void CopyProperties(Expression &other) {
-		type = other.type;
-		expression_class = other.expression_class;
-		alias = other.alias;
-		return_type = other.return_type;
+struct ExpressionEquality {
+	bool operator()(const BaseExpression *const &a, const BaseExpression *const &b) const {
+		return a->Equals(b);
 	}
 };
 
+template <typename T>
+using expression_map_t = unordered_map<BaseExpression *, T, ExpressionHashFunction, ExpressionEquality>;
+
+using expression_set_t = unordered_set<BaseExpression *, ExpressionHashFunction, ExpressionEquality>;
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -9118,7 +8990,7 @@ protected:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/column_binding.hpp
+// duckdb/storage/statistics/distinct_statistics.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -9126,30 +8998,920 @@ protected:
 
 
 
-#include <functional>
-
-namespace duckdb {
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/hyperloglog.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-struct ColumnBinding {
-	idx_t table_index;
-	idx_t column_index;
 
-	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {
-	}
-	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
-	}
 
-	bool operator==(const ColumnBinding &rhs) const {
-		return table_index == rhs.table_index && column_index == rhs.column_index;
-	}
-};
 
-} // namespace duckdb
 
 
 
-#include <functional>
-#include <algorithm>
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
+// See the end of this file for a list
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// third_party/hyperloglog/hyperloglog.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <stdint.h>
+#include <string.h>
+
+namespace duckdb_hll {
+
+/* Error codes */
+#define HLL_C_OK  0
+#define HLL_C_ERR -1
+
+typedef struct {
+	void *ptr;
+} robj;
+
+//! Create a new empty HyperLogLog object
+robj *hll_create(void);
+//! Convert hll from sparse to dense
+int hllSparseToDense(robj *o);
+//! Destroy the specified HyperLogLog object
+void hll_destroy(robj *obj);
+//! Add an element with the specified amount of bytes to the HyperLogLog. Returns C_ERR on failure, otherwise returns 0
+//! if the cardinality did not change, and 1 otherwise.
+int hll_add(robj *o, unsigned char *ele, size_t elesize);
+//! Returns the estimated amount of unique elements seen by the HyperLogLog. Returns C_OK on success, or C_ERR on
+//! failure.
+int hll_count(robj *o, size_t *result);
+//! Merge hll_count HyperLogLog objects into a single one. Returns NULL on failure, or the new HLL object on success.
+robj *hll_merge(robj **hlls, size_t hll_count);
+//! Get size (in bytes) of the HLL
+uint64_t get_size();
+
+uint64_t MurmurHash64A(const void *key, int len, unsigned int seed);
+
+} // namespace duckdb_hll
+
+namespace duckdb {
+
+void AddToLogsInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void ***logs[],
+                       const SelectionVector *log_sel);
+
+void AddToSingleLogInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[], void *log);
+
+} // namespace duckdb
+
+
+// LICENSE_CHANGE_END
+
+
+namespace duckdb {
+
+enum class HLLStorageType { UNCOMPRESSED = 1 };
+
+class FieldWriter;
+class FieldReader;
+
+//! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
+class HyperLogLog {
+public:
+	HyperLogLog();
+	~HyperLogLog();
+	// implicit copying of HyperLogLog is not allowed
+	HyperLogLog(const HyperLogLog &) = delete;
+
+	//! Adds an element of the specified size to the HyperLogLog counter
+	void Add(data_ptr_t element, idx_t size);
+	//! Return the count of this HyperLogLog counter
+	idx_t Count() const;
+	//! Merge this HyperLogLog counter with another counter to create a new one
+	unique_ptr<HyperLogLog> Merge(HyperLogLog &other);
+	HyperLogLog *MergePointer(HyperLogLog &other);
+	//! Merge a set of HyperLogLogs to create one big one
+	static unique_ptr<HyperLogLog> Merge(HyperLogLog logs[], idx_t count);
+	//! Get the size (in bytes) of a HLL
+	static idx_t GetSize();
+	//! Get pointer to the HLL
+	data_ptr_t GetPtr() const;
+	//! Get copy of the HLL
+	unique_ptr<HyperLogLog> Copy();
+	//! (De)Serialize the HLL
+	void Serialize(FieldWriter &writer) const;
+	static unique_ptr<HyperLogLog> Deserialize(FieldReader &reader);
+
+public:
+	//! Compute HLL hashes over vdata, and store them in 'hashes'
+	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t
+	static void ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
+	                           idx_t count);
+	//! Add the indices and counts to the logs
+	static void AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
+	                      HyperLogLog **logs[], const SelectionVector *log_sel);
+	//! Add the indices and counts to THIS log
+	void AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
+
+private:
+	explicit HyperLogLog(void *hll);
+
+	void *hll;
+	mutex lock;
+};
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class Serializer;
+class Deserializer;
+class Vector;
+
+class DistinctStatistics : public BaseStatistics {
+public:
+	DistinctStatistics();
+	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
+
+	//! The HLL of the table
+	unique_ptr<HyperLogLog> log;
+	//! How many values have been sampled into the HLL
+	atomic<idx_t> sample_count;
+	//! How many values have been inserted (before sampling)
+	atomic<idx_t> total_count;
+
+public:
+	void Merge(const BaseStatistics &other) override;
+
+	unique_ptr<BaseStatistics> Copy() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	void Serialize(FieldWriter &writer) const override;
+
+	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
+	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
+
+	void Update(Vector &update, idx_t count, bool sample = true);
+	void Update(UnifiedVectorFormat &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
+
+	string ToString() const override;
+	idx_t GetCount() const;
+
+private:
+	//! For distinct statistics we sample the input to speed up insertions
+	static constexpr const double SAMPLE_RATE = 0.1;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/table_filter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/filter_propagate_result.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class FilterPropagateResult : uint8_t {
+	NO_PRUNING_POSSIBLE = 0,
+	FILTER_ALWAYS_TRUE = 1,
+	FILTER_ALWAYS_FALSE = 2,
+	FILTER_TRUE_OR_NULL = 3,
+	FILTER_FALSE_OR_NULL = 4
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+
+enum class TableFilterType : uint8_t {
+	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
+	IS_NULL = 1,
+	IS_NOT_NULL = 2,
+	CONJUNCTION_OR = 3,
+	CONJUNCTION_AND = 4
+};
+
+//! TableFilter represents a filter pushed down into the table scan.
+class TableFilter {
+public:
+	TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
+	}
+	virtual ~TableFilter() {
+	}
+
+	TableFilterType filter_type;
+
+public:
+	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
+	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
+	virtual string ToString(const string &column_name) = 0;
+	virtual bool Equals(const TableFilter &other) const {
+		return filter_type != other.filter_type;
+	}
+
+	void Serialize(Serializer &serializer) const;
+	virtual void Serialize(FieldWriter &writer) const = 0;
+	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
+};
+
+class TableFilterSet {
+public:
+	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
+
+public:
+	void PushFilter(idx_t table_index, unique_ptr<TableFilter> filter);
+
+	bool Equals(TableFilterSet &other) {
+		if (filters.size() != other.filters.size()) {
+			return false;
+		}
+		for (auto &entry : filters) {
+			auto other_entry = other.filters.find(entry.first);
+			if (other_entry == other.filters.end()) {
+				return false;
+			}
+			if (!entry.second->Equals(*other_entry->second)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	static bool Equals(TableFilterSet *left, TableFilterSet *right) {
+		if (left == right) {
+			return true;
+		}
+		if (!left || !right) {
+			return false;
+		}
+		return left->Equals(*right);
+	}
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<TableFilterSet> Deserialize(Deserializer &source);
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/table_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/standard_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class SchemaCatalogEntry;
+
+//! A StandardEntry is a catalog entry that is a member of a schema
+class StandardEntry : public CatalogEntry {
+public:
+	StandardEntry(CatalogType type, SchemaCatalogEntry *schema, Catalog *catalog, string name)
+	    : CatalogEntry(type, catalog, name), schema(schema) {
+	}
+	~StandardEntry() override {
+	}
+
+	//! The schema the entry belongs to
+	SchemaCatalogEntry *schema;
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class Serializer;
+class Deserializer;
+class FieldWriter;
+class FieldReader;
+
+//===--------------------------------------------------------------------===//
+// Constraint Types
+//===--------------------------------------------------------------------===//
+enum class ConstraintType : uint8_t {
+	INVALID = 0,     // invalid constraint type
+	NOT_NULL = 1,    // NOT NULL constraint
+	CHECK = 2,       // CHECK constraint
+	UNIQUE = 3,      // UNIQUE constraint
+	FOREIGN_KEY = 4, // FOREIGN KEY constraint
+};
+
+enum class ForeignKeyType : uint8_t {
+	FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
+	FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
+	FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
+};
+
+struct ForeignKeyInfo {
+	ForeignKeyType type;
+	string schema;
+	//! if type is FK_TYPE_FOREIGN_KEY_TABLE, means main key table, if type is FK_TYPE_PRIMARY_KEY_TABLE, means foreign
+	//! key table
+	string table;
+	//! The set of main key table's column's index
+	vector<storage_t> pk_keys;
+	//! The set of foreign key table's column's index
+	vector<idx_t> fk_keys;
+};
+
+//! Constraint is the base class of any type of table constraint.
+class Constraint {
+public:
+	DUCKDB_API explicit Constraint(ConstraintType type);
+	DUCKDB_API virtual ~Constraint();
+
+	ConstraintType type;
+
+public:
+	DUCKDB_API virtual string ToString() const = 0;
+	DUCKDB_API void Print() const;
+
+	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
+	//! Serializes a Constraint to a stand-alone binary blob
+	DUCKDB_API void Serialize(Serializer &serializer) const;
+	//! Serializes a Constraint to a stand-alone binary blob
+	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
+	//! Deserializes a blob back into a Constraint
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/bound_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+//! Bound equivalent of Constraint
+class BoundConstraint {
+public:
+	explicit BoundConstraint(ConstraintType type) : type(type) {};
+	virtual ~BoundConstraint() {
+	}
+
+	void Serialize(Serializer &serializer) const {
+		serializer.Write(type);
+	}
+
+	static unique_ptr<BoundConstraint> Deserialize(Deserializer &source) {
+		return make_unique<BoundConstraint>(source.Read<ConstraintType>());
+	}
+
+	ConstraintType type;
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/plan_serialization.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/logical_operator_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Logical Operator Types
+//===--------------------------------------------------------------------===//
+enum class LogicalOperatorType : uint8_t {
+	LOGICAL_INVALID = 0,
+	LOGICAL_PROJECTION = 1,
+	LOGICAL_FILTER = 2,
+	LOGICAL_AGGREGATE_AND_GROUP_BY = 3,
+	LOGICAL_WINDOW = 4,
+	LOGICAL_UNNEST = 5,
+	LOGICAL_LIMIT = 6,
+	LOGICAL_ORDER_BY = 7,
+	LOGICAL_TOP_N = 8,
+	LOGICAL_COPY_TO_FILE = 10,
+	LOGICAL_DISTINCT = 11,
+	LOGICAL_SAMPLE = 12,
+	LOGICAL_LIMIT_PERCENT = 13,
+
+	// -----------------------------
+	// Data sources
+	// -----------------------------
+	LOGICAL_GET = 25,
+	LOGICAL_CHUNK_GET = 26,
+	LOGICAL_DELIM_GET = 27,
+	LOGICAL_EXPRESSION_GET = 28,
+	LOGICAL_DUMMY_SCAN = 29,
+	LOGICAL_EMPTY_RESULT = 30,
+	LOGICAL_CTE_REF = 31,
+	// -----------------------------
+	// Joins
+	// -----------------------------
+	LOGICAL_JOIN = 50,
+	LOGICAL_DELIM_JOIN = 51,
+	LOGICAL_COMPARISON_JOIN = 52,
+	LOGICAL_ANY_JOIN = 53,
+	LOGICAL_CROSS_PRODUCT = 54,
+	// -----------------------------
+	// SetOps
+	// -----------------------------
+	LOGICAL_UNION = 75,
+	LOGICAL_EXCEPT = 76,
+	LOGICAL_INTERSECT = 77,
+	LOGICAL_RECURSIVE_CTE = 78,
+
+	// -----------------------------
+	// Updates
+	// -----------------------------
+	LOGICAL_INSERT = 100,
+	LOGICAL_DELETE = 101,
+	LOGICAL_UPDATE = 102,
+
+	// -----------------------------
+	// Schema
+	// -----------------------------
+	LOGICAL_ALTER = 125,
+	LOGICAL_CREATE_TABLE = 126,
+	LOGICAL_CREATE_INDEX = 127,
+	LOGICAL_CREATE_SEQUENCE = 128,
+	LOGICAL_CREATE_VIEW = 129,
+	LOGICAL_CREATE_SCHEMA = 130,
+	LOGICAL_CREATE_MACRO = 131,
+	LOGICAL_DROP = 132,
+	LOGICAL_PRAGMA = 133,
+	LOGICAL_TRANSACTION = 134,
+	LOGICAL_CREATE_TYPE = 135,
+
+	// -----------------------------
+	// Explain
+	// -----------------------------
+	LOGICAL_EXPLAIN = 150,
+
+	// -----------------------------
+	// Show
+	// -----------------------------
+	LOGICAL_SHOW = 160,
+
+	// -----------------------------
+	// Helpers
+	// -----------------------------
+	LOGICAL_PREPARE = 175,
+	LOGICAL_EXECUTE = 176,
+	LOGICAL_EXPORT = 177,
+	LOGICAL_VACUUM = 178,
+	LOGICAL_SET = 179,
+	LOGICAL_LOAD = 180
+};
+
+DUCKDB_API string LogicalOperatorToString(LogicalOperatorType type);
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/bound_parameter_map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct BoundParameterData;
+
+using bound_parameter_map_t = unordered_map<idx_t, shared_ptr<BoundParameterData>>;
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class ClientContext;
+class LogicalOperator;
+struct BoundParameterData;
+
+struct PlanDeserializationState {
+	PlanDeserializationState(ClientContext &context);
+	~PlanDeserializationState();
+
+	ClientContext &context;
+	bound_parameter_map_t parameter_data;
+};
+
+struct LogicalDeserializationState {
+	LogicalDeserializationState(PlanDeserializationState &gstate, LogicalOperatorType type,
+	                            vector<unique_ptr<LogicalOperator>> &children);
+
+	PlanDeserializationState &gstate;
+	LogicalOperatorType type;
+	vector<unique_ptr<LogicalOperator>> &children;
+};
+
+struct ExpressionDeserializationState {
+	ExpressionDeserializationState(PlanDeserializationState &gstate, ExpressionType type);
+
+	PlanDeserializationState &gstate;
+	ExpressionType type;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+class ClientContext;
+
+//!  The Expression class represents a bound Expression with a return type
+class Expression : public BaseExpression {
+public:
+	Expression(ExpressionType type, ExpressionClass expression_class, LogicalType return_type);
+	~Expression() override;
+
+	//! The return type of the expression
+	LogicalType return_type;
+	//! Expression statistics (if any) - ONLY USED FOR VERIFICATION
+	unique_ptr<BaseStatistics> verification_stats;
+
+public:
+	bool IsAggregate() const override;
+	bool IsWindow() const override;
+	bool HasSubquery() const override;
+	bool IsScalar() const override;
+	bool HasParameter() const override;
+	virtual bool HasSideEffects() const;
+	virtual bool PropagatesNullValues() const;
+	virtual bool IsFoldable() const;
+
+	hash_t Hash() const override;
+
+	bool Equals(const BaseExpression *other) const override {
+		if (!BaseExpression::Equals(other)) {
+			return false;
+		}
+		return return_type == ((Expression *)other)->return_type;
+	}
+
+	static bool Equals(Expression *left, Expression *right) {
+		return BaseExpression::Equals((BaseExpression *)left, (BaseExpression *)right);
+	}
+	//! Create a copy of this expression
+	virtual unique_ptr<Expression> Copy() = 0;
+
+	//! Serializes an Expression to a stand-alone binary blob
+	void Serialize(Serializer &serializer) const;
+	//! Serializes an Expression to a stand-alone binary blob
+	virtual void Serialize(FieldWriter &writer) const = 0;
+
+	//! Deserializes a blob back into an Expression [CAN THROW:
+	//! SerializationException]
+	static unique_ptr<Expression> Deserialize(Deserializer &source, PlanDeserializationState &state);
+
+protected:
+	//! Copy base Expression properties from another expression to this one,
+	//! used in Copy method
+	void CopyProperties(Expression &other) {
+		type = other.type;
+		expression_class = other.expression_class;
+		alias = other.alias;
+		return_type = other.return_type;
+	}
+};
+
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/column_dependency_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/set.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <set>
+
+namespace duckdb {
+using std::set;
+}
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/stack.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <stack>
+
+namespace duckdb {
+using std::stack;
+}
+
+
+namespace duckdb {
+
+//! Dependency Manager local to a table, responsible for keeping track of generated column dependencies
+
+class ColumnDependencyManager {
+public:
+	DUCKDB_API ColumnDependencyManager();
+	DUCKDB_API ~ColumnDependencyManager();
+	DUCKDB_API ColumnDependencyManager(ColumnDependencyManager &&other) = default;
+	ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
+
+public:
+	//! Get the bind order that ensures dependencies are resolved before dependents are
+	stack<column_t> GetBindOrder(const vector<ColumnDefinition> &columns);
+
+	//! Adds a connection between the dependent and its dependencies
+	void AddGeneratedColumn(column_t index, const vector<column_t> &indices, bool root = true);
+	//! Add a generated column from a column definition
+	void AddGeneratedColumn(const ColumnDefinition &column, const case_insensitive_map_t<column_t> &name_map);
+
+	//! Removes the column(s) and outputs the new column indices
+	vector<column_t> RemoveColumn(column_t index, column_t column_amount);
+
+	bool IsDependencyOf(column_t dependent, column_t dependency) const;
+	bool HasDependencies(column_t index) const;
+	const unordered_set<column_t> &GetDependencies(column_t index) const;
+
+	bool HasDependents(column_t index) const;
+	const unordered_set<column_t> &GetDependents(column_t index) const;
+
+private:
+	void RemoveStandardColumn(column_t index);
+	void RemoveGeneratedColumn(column_t index);
+
+	void AdjustSingle(column_t idx, idx_t offset);
+	// Clean up the gaps created by a Remove operation
+	vector<column_t> CleanupInternals(column_t column_amount);
+
+private:
+	//! A map of column dependency to generated column(s)
+	unordered_map<column_t, unordered_set<column_t>> dependencies_map;
+	//! A map of generated column name to (potentially generated)column dependencies
+	unordered_map<column_t, unordered_set<column_t>> dependents_map;
+	//! For resolve-order purposes, keep track of the 'direct' (not inherited) dependencies of a generated column
+	unordered_map<column_t, unordered_set<column_t>> direct_dependencies;
+	set<column_t> deleted_columns;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class DataTable;
+struct CreateTableInfo;
+struct BoundCreateTableInfo;
+
+struct RenameColumnInfo;
+struct AddColumnInfo;
+struct RemoveColumnInfo;
+struct SetDefaultInfo;
+struct ChangeColumnTypeInfo;
+struct AlterForeignKeyInfo;
+struct SetNotNullInfo;
+struct DropNotNullInfo;
+
+//! A table catalog entry
+class TableCatalogEntry : public StandardEntry {
+public:
+	//! Create a real TableCatalogEntry and initialize storage for it
+	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
+	                  std::shared_ptr<DataTable> inherited_storage = nullptr);
+
+	//! A reference to the underlying storage unit used for this table
+	std::shared_ptr<DataTable> storage;
+	//! A list of columns that are part of this table
+	vector<ColumnDefinition> columns;
+	//! A list of constraints that are part of this table
+	vector<unique_ptr<Constraint>> constraints;
+	//! A list of constraints that are part of this table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	ColumnDependencyManager column_dependency_manager;
+	//! A map of column name to column index
+	case_insensitive_map_t<column_t> name_map;
+
+public:
+	//! For debugging purposes, count how many columns are STANDARD
+	idx_t StandardColumnCount() const;
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	//! Returns whether or not a column with the given name exists
+	DUCKDB_API bool ColumnExists(const string &name);
+	//! Returns a reference to the column of the specified name. Throws an
+	//! exception if the column does not exist.
+	ColumnDefinition &GetColumn(const string &name);
+	//! Returns a list of types of the table
+	vector<LogicalType> GetTypes();
+	string ToSQL() override;
+
+	//! Serialize the meta information of the TableCatalogEntry a serializer
+	virtual void Serialize(Serializer &serializer);
+	//! Deserializes to a CreateTableInfo
+	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
+
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
+
+	void SetAsRoot() override;
+
+	void CommitAlter(AlterInfo &info);
+	void CommitDrop();
+
+	//! Returns the column index of the specified column name.
+	//! If the column does not exist:
+	//! If if_exists is true, returns DConstants::INVALID_INDEX
+	//! If if_exists is false, throws an exception
+	column_t GetColumnIndex(string &name, bool if_exists = false);
+
+private:
+	const string &GetColumnName(column_t index);
+	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
+	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
+	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
+	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
+	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
+	unique_ptr<CatalogEntry> SetNotNull(ClientContext &context, SetNotNullInfo &info);
+	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
+	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class EstimatedProperties {
+public:
+	EstimatedProperties(double cardinality, double cost) : cardinality(cardinality), cost(cost) {};
+	EstimatedProperties() : cardinality(0), cost(0) {};
+
+	double GetCardinality();
+	double GetCost();
+	void SetCost(double new_cost);
+	void SetCardinality(double cardinality);
+
+private:
+	double cardinality;
+	double cost;
+
+public:
+	unique_ptr<EstimatedProperties> Copy();
+};
+} // namespace duckdb
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/column_binding.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+#include <functional>
+
+namespace duckdb {
+
+struct ColumnBinding {
+	idx_t table_index;
+	idx_t column_index;
+
+	ColumnBinding() : table_index(DConstants::INVALID_INDEX), column_index(DConstants::INVALID_INDEX) {
+	}
+	ColumnBinding(idx_t table, idx_t column) : table_index(table), column_index(column) {
+	}
+
+	bool operator==(const ColumnBinding &rhs) const {
+		return table_index == rhs.table_index && column_index == rhs.column_index;
+	}
+};
+
+} // namespace duckdb
+
+
+
+#include <functional>
+#include <algorithm>
 
 namespace duckdb {
 
@@ -9177,7 +9939,10 @@ public:
 	//! The types returned by this logical operator. Set by calling LogicalOperator::ResolveTypes.
 	vector<LogicalType> types;
 	//! Estimated Cardinality
-	idx_t estimated_cardinality = 0;
+	idx_t estimated_cardinality;
+	bool has_estimated_cardinality;
+
+	unique_ptr<EstimatedProperties> estimated_props;
 
 public:
 	virtual vector<ColumnBinding> GetColumnBindings();
@@ -9196,7 +9961,6 @@ public:
 	virtual void Verify(ClientContext &context);
 
 	void AddChild(unique_ptr<LogicalOperator> child);
-
 	virtual idx_t EstimateCardinality(ClientContext &context);
 
 	//! Serializes a LogicalOperator to a stand-alone binary blob
@@ -11023,45 +11787,202 @@ private:
 
 
 
-namespace duckdb {
+namespace duckdb {
+
+enum class PendingExecutionResult : uint8_t { RESULT_READY, RESULT_NOT_READY, EXECUTION_ERROR };
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/executor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parallel/pipeline.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/physical_operator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_node.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/query_graph.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/pair.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <utility>
+
+namespace duckdb {
+using std::make_pair;
+using std::pair;
+} // namespace duckdb
+
+
+
+
+
+
+
+#include <functional>
+
+namespace duckdb {
+class Expression;
+class LogicalOperator;
+
+struct FilterInfo {
+	idx_t filter_index;
+	JoinRelationSet *left_set = nullptr;
+	JoinRelationSet *right_set = nullptr;
+	ColumnBinding left_binding;
+	ColumnBinding right_binding;
+	JoinRelationSet *set = nullptr;
+};
+
+struct FilterNode {
+	vector<FilterInfo *> filters;
+	unordered_map<idx_t, unique_ptr<FilterNode>> children;
+};
+
+struct NeighborInfo {
+	JoinRelationSet *neighbor;
+	vector<FilterInfo *> filters;
+};
+
+//! The QueryGraph contains edges between relations and allows edges to be created/queried
+class QueryGraph {
+public:
+	//! Contains a node with info about neighboring relations and child edge infos
+	struct QueryEdge {
+		vector<unique_ptr<NeighborInfo>> neighbors;
+		unordered_map<idx_t, unique_ptr<QueryEdge>> children;
+	};
+
+public:
+	string ToString() const;
+	void Print();
+
+	//! Create an edge in the edge_set
+	void CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *info);
+	//! Returns a connection if there is an edge that connects these two sets, or nullptr otherwise
+	vector<NeighborInfo *> GetConnections(JoinRelationSet *node, JoinRelationSet *other);
+	//! Enumerate the neighbors of a specific node that do not belong to any of the exclusion_set. Note that if a
+	//! neighbor has multiple nodes, this function will return the lowest entry in that set.
+	vector<idx_t> GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	//! Enumerate all neighbors of a given JoinRelationSet node
+	void EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback);
+
+private:
+	//! Get the QueryEdge of a specific node
+	QueryEdge *GetQueryEdge(JoinRelationSet *left);
+
+	QueryEdge root;
+};
+
+} // namespace duckdb
+
+
+
 
-enum class PendingExecutionResult : uint8_t { RESULT_READY, RESULT_NOT_READY, EXECUTION_ERROR };
 
-} // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/executor.hpp
-//
-//
-//===----------------------------------------------------------------------===//
 
 
 
+namespace duckdb {
 
+class JoinOrderOptimizer;
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+class JoinNode {
+public:
+	//! Represents a node in the join plan
+	JoinRelationSet *set;
+	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;
+	JoinNode *left;
+	JoinNode *right;
 
+	unique_ptr<EstimatedProperties> estimated_props;
 
+	//! 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, NeighborInfo *info, JoinNode *left, JoinNode *right, const double base_cardinality,
+	         double cost);
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_operator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+	bool operator==(const JoinNode &other) {
+		return other.set->ToString().compare(set->ToString()) == 0;
+	}
 
+private:
+	double base_cardinality;
 
+public:
+	double GetCardinality() const;
+	double GetCost();
+	void SetCost(double cost);
+	double GetBaseTableCardinality();
+	void SetBaseTableCardinality(double base_card);
+	void SetEstimatedCardinality(double estimated_card);
+	void PrintJoinNode();
+	string ToString();
+};
 
+} // namespace duckdb
 
 
 //===----------------------------------------------------------------------===//
@@ -11309,7 +12230,9 @@ class PhysicalOperator {
 public:
 	PhysicalOperator(PhysicalOperatorType type, vector<LogicalType> types, idx_t estimated_cardinality)
 	    : type(type), types(std::move(types)), estimated_cardinality(estimated_cardinality) {
+		estimated_props = make_unique<EstimatedProperties>(estimated_cardinality, 0);
 	}
+
 	virtual ~PhysicalOperator() {
 	}
 
@@ -11321,6 +12244,8 @@ 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;
 	//! The global state of this operator
@@ -11864,22 +12789,6 @@ private:
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pair.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <utility>
-
-namespace duckdb {
-using std::make_pair;
-using std::pair;
-} // namespace duckdb
 
 
 
@@ -12107,256 +13016,68 @@ public:
 public:
 	//! Returns the stored error message
 	const string &GetError();
-	//! Returns whether or not an error occurred
-	bool HasError() const;
-	//! Returns the number of columns in the result
-	idx_t ColumnCount();
-	//! Returns the statement type of the underlying prepared statement object
-	StatementType GetStatementType();
-	//! Returns the underlying statement properties
-	StatementProperties GetStatementProperties();
-	//! Returns the result SQL types of the prepared statement
-	const vector<LogicalType> &GetTypes();
-	//! Returns the result names of the prepared statement
-	const vector<string> &GetNames();
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<PendingQueryResult> PendingQuery(Args... args) {
-		vector<Value> values;
-		return PendingQueryRecursive(values, args...);
-	}
-
-	//! Execute the prepared statement with the given set of arguments
-	template <typename... Args>
-	unique_ptr<QueryResult> Execute(Args... args) {
-		vector<Value> values;
-		return ExecuteRecursive(values, args...);
-	}
-
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
-
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
-
-private:
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {
-		return PendingQuery(values);
-	}
-
-	template <typename T, typename... Args>
-	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, Args... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return PendingQueryRecursive(values, args...);
-	}
-
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values) {
-		return Execute(values);
-	}
-
-	template <typename T, typename... Args>
-	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, Args... args) {
-		values.push_back(Value::CreateValue<T>(value));
-		return ExecuteRecursive(values, args...);
-	}
-};
-
-} // namespace duckdb
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/join_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Join Types
-//===--------------------------------------------------------------------===//
-enum class JoinType : uint8_t {
-	INVALID = 0, // invalid join type
-	LEFT = 1,    // left
-	RIGHT = 2,   // right
-	INNER = 3,   // inner
-	OUTER = 4,   // outer
-	SEMI = 5,    // SEMI join returns left side row ONLY if it has a join partner, no duplicates
-	ANTI = 6,    // ANTI join returns left side row ONLY if it has NO join partner, no duplicates
-	MARK = 7,    // MARK join returns marker indicating whether or not there is a join partner (true), there is no join
-	             // partner (false)
-	SINGLE = 8   // SINGLE join is like LEFT OUTER JOIN, BUT returns at most one join partner per entry on the LEFT side
-	             // (and NULL if no partner is found)
-};
-
-//! Convert join type to string
-DUCKDB_API string JoinTypeToString(JoinType type);
-
-//! True if join is left or full outer join
-bool IsLeftOuterJoin(JoinType type);
-
-//! True if join is rght or full outer join
-bool IsRightOuterJoin(JoinType type);
-
-} // namespace duckdb
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/relation_type.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Catalog Types
-//===--------------------------------------------------------------------===//
-enum class RelationType : uint8_t {
-	INVALID_RELATION,
-	TABLE_RELATION,
-	PROJECTION_RELATION,
-	FILTER_RELATION,
-	EXPLAIN_RELATION,
-	CROSS_PRODUCT_RELATION,
-	JOIN_RELATION,
-	AGGREGATE_RELATION,
-	SET_OPERATION_RELATION,
-	DISTINCT_RELATION,
-	LIMIT_RELATION,
-	ORDER_RELATION,
-	CREATE_VIEW_RELATION,
-	CREATE_TABLE_RELATION,
-	INSERT_RELATION,
-	VALUE_LIST_RELATION,
-	DELETE_RELATION,
-	UPDATE_RELATION,
-	WRITE_CSV_RELATION,
-	READ_CSV_RELATION,
-	SUBQUERY_RELATION,
-	TABLE_FUNCTION_RELATION,
-	VIEW_RELATION,
-	QUERY_RELATION
-};
-
-string RelationTypeToString(RelationType type);
-
-} // namespace duckdb
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/main/client_context.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_set.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/default/default_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
+	//! Returns whether or not an error occurred
+	bool HasError() const;
+	//! Returns the number of columns in the result
+	idx_t ColumnCount();
+	//! Returns the statement type of the underlying prepared statement object
+	StatementType GetStatementType();
+	//! Returns the underlying statement properties
+	StatementProperties GetStatementProperties();
+	//! Returns the result SQL types of the prepared statement
+	const vector<LogicalType> &GetTypes();
+	//! Returns the result names of the prepared statement
+	const vector<string> &GetNames();
 
+	//! Create a pending query result of the prepared statement with the given set of arguments
+	template <typename... Args>
+	unique_ptr<PendingQueryResult> PendingQuery(Args... args) {
+		vector<Value> values;
+		return PendingQueryRecursive(values, args...);
+	}
 
+	//! Execute the prepared statement with the given set of arguments
+	template <typename... Args>
+	unique_ptr<QueryResult> Execute(Args... args) {
+		vector<Value> values;
+		return ExecuteRecursive(values, args...);
+	}
 
+	//! Create a pending query result of the prepared statement with the given set of arguments
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
 
-namespace duckdb {
-class ClientContext;
+	//! Execute the prepared statement with the given set of values
+	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
 
-class DefaultGenerator {
-public:
-	explicit DefaultGenerator(Catalog &catalog) : catalog(catalog), created_all_entries(false) {
+private:
+	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {
+		return PendingQuery(values);
 	}
-	virtual ~DefaultGenerator() {
+
+	template <typename T, typename... Args>
+	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values, T value, Args... args) {
+		values.push_back(Value::CreateValue<T>(value));
+		return PendingQueryRecursive(values, args...);
 	}
 
-	Catalog &catalog;
-	atomic<bool> created_all_entries;
+	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values) {
+		return Execute(values);
+	}
 
-public:
-	//! Creates a default entry with the specified name, or returns nullptr if no such entry can be generated
-	virtual unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) = 0;
-	//! Get a list of all default entries in the generator
-	virtual vector<string> GetDefaultEntries() = 0;
+	template <typename T, typename... Args>
+	unique_ptr<QueryResult> ExecuteRecursive(vector<Value> &values, T value, Args... args) {
+		values.push_back(Value::CreateValue<T>(value));
+		return ExecuteRecursive(values, args...);
+	}
 };
 
 } // namespace duckdb
 
 
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/catalog/catalog_entry/table_catalog_entry.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/catalog/standard_entry.hpp
+// duckdb/main/relation.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -12364,30 +13085,10 @@ public:
 
 
 
-
-namespace duckdb {
-class SchemaCatalogEntry;
-
-//! A StandardEntry is a catalog entry that is a member of a schema
-class StandardEntry : public CatalogEntry {
-public:
-	StandardEntry(CatalogType type, SchemaCatalogEntry *schema, Catalog *catalog, string name)
-	    : CatalogEntry(type, catalog, name), schema(schema) {
-	}
-	~StandardEntry() override {
-	}
-
-	//! The schema the entry belongs to
-	SchemaCatalogEntry *schema;
-};
-} // namespace duckdb
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/constraint.hpp
+// duckdb/common/enums/join_type.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -12396,69 +13097,40 @@ public:
 
 
 
-
 namespace duckdb {
 
-class Serializer;
-class Deserializer;
-class FieldWriter;
-class FieldReader;
-
 //===--------------------------------------------------------------------===//
-// Constraint Types
+// Join Types
 //===--------------------------------------------------------------------===//
-enum class ConstraintType : uint8_t {
-	INVALID = 0,     // invalid constraint type
-	NOT_NULL = 1,    // NOT NULL constraint
-	CHECK = 2,       // CHECK constraint
-	UNIQUE = 3,      // UNIQUE constraint
-	FOREIGN_KEY = 4, // FOREIGN KEY constraint
-};
-
-enum class ForeignKeyType : uint8_t {
-	FK_TYPE_PRIMARY_KEY_TABLE = 0,   // main table
-	FK_TYPE_FOREIGN_KEY_TABLE = 1,   // referencing table
-	FK_TYPE_SELF_REFERENCE_TABLE = 2 // self refrencing table
-};
-
-struct ForeignKeyInfo {
-	ForeignKeyType type;
-	string schema;
-	//! if type is FK_TYPE_FOREIGN_KEY_TABLE, means main key table, if type is FK_TYPE_PRIMARY_KEY_TABLE, means foreign
-	//! key table
-	string table;
-	//! The set of main key table's column's index
-	vector<storage_t> pk_keys;
-	//! The set of foreign key table's column's index
-	vector<idx_t> fk_keys;
+enum class JoinType : uint8_t {
+	INVALID = 0, // invalid join type
+	LEFT = 1,    // left
+	RIGHT = 2,   // right
+	INNER = 3,   // inner
+	OUTER = 4,   // outer
+	SEMI = 5,    // SEMI join returns left side row ONLY if it has a join partner, no duplicates
+	ANTI = 6,    // ANTI join returns left side row ONLY if it has NO join partner, no duplicates
+	MARK = 7,    // MARK join returns marker indicating whether or not there is a join partner (true), there is no join
+	             // partner (false)
+	SINGLE = 8   // SINGLE join is like LEFT OUTER JOIN, BUT returns at most one join partner per entry on the LEFT side
+	             // (and NULL if no partner is found)
 };
 
-//! Constraint is the base class of any type of table constraint.
-class Constraint {
-public:
-	DUCKDB_API explicit Constraint(ConstraintType type);
-	DUCKDB_API virtual ~Constraint();
+//! Convert join type to string
+DUCKDB_API string JoinTypeToString(JoinType type);
 
-	ConstraintType type;
+//! True if join is left or full outer join
+bool IsLeftOuterJoin(JoinType type);
 
-public:
-	DUCKDB_API virtual string ToString() const = 0;
-	DUCKDB_API void Print() const;
+//! True if join is rght or full outer join
+bool IsRightOuterJoin(JoinType type);
 
-	DUCKDB_API virtual unique_ptr<Constraint> Copy() const = 0;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) const;
-	//! Serializes a Constraint to a stand-alone binary blob
-	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
-	//! Deserializes a blob back into a Constraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
-};
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/bound_constraint.hpp
+// duckdb/common/enums/relation_type.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -12467,206 +13139,119 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Bound equivalent of Constraint
-class BoundConstraint {
-public:
-	explicit BoundConstraint(ConstraintType type) : type(type) {};
-	virtual ~BoundConstraint() {
-	}
 
-	void Serialize(Serializer &serializer) const {
-		serializer.Write(type);
-	}
+//===--------------------------------------------------------------------===//
+// Catalog Types
+//===--------------------------------------------------------------------===//
+enum class RelationType : uint8_t {
+	INVALID_RELATION,
+	TABLE_RELATION,
+	PROJECTION_RELATION,
+	FILTER_RELATION,
+	EXPLAIN_RELATION,
+	CROSS_PRODUCT_RELATION,
+	JOIN_RELATION,
+	AGGREGATE_RELATION,
+	SET_OPERATION_RELATION,
+	DISTINCT_RELATION,
+	LIMIT_RELATION,
+	ORDER_RELATION,
+	CREATE_VIEW_RELATION,
+	CREATE_TABLE_RELATION,
+	INSERT_RELATION,
+	VALUE_LIST_RELATION,
+	DELETE_RELATION,
+	UPDATE_RELATION,
+	WRITE_CSV_RELATION,
+	READ_CSV_RELATION,
+	SUBQUERY_RELATION,
+	TABLE_FUNCTION_RELATION,
+	VIEW_RELATION,
+	QUERY_RELATION
+};
 
-	static unique_ptr<BoundConstraint> Deserialize(Deserializer &source) {
-		return make_unique<BoundConstraint>(source.Read<ConstraintType>());
-	}
+string RelationTypeToString(RelationType type);
 
-	ConstraintType type;
-};
 } // namespace duckdb
 
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/catalog/catalog_entry/column_dependency_manager.hpp
+// duckdb/main/client_context.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/set.hpp
+// duckdb/catalog/catalog_entry/schema_catalog_entry.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-#include <set>
-
-namespace duckdb {
-using std::set;
-}
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/stack.hpp
+// duckdb/catalog/catalog_set.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-#include <stack>
-
-namespace duckdb {
-using std::stack;
-}
-
-
-namespace duckdb {
-
-//! Dependency Manager local to a table, responsible for keeping track of generated column dependencies
-
-class ColumnDependencyManager {
-public:
-	DUCKDB_API ColumnDependencyManager();
-	DUCKDB_API ~ColumnDependencyManager();
-	DUCKDB_API ColumnDependencyManager(ColumnDependencyManager &&other) = default;
-	ColumnDependencyManager(const ColumnDependencyManager &other) = delete;
-
-public:
-	//! Get the bind order that ensures dependencies are resolved before dependents are
-	stack<column_t> GetBindOrder(const vector<ColumnDefinition> &columns);
-
-	//! Adds a connection between the dependent and its dependencies
-	void AddGeneratedColumn(column_t index, const vector<column_t> &indices, bool root = true);
-	//! Add a generated column from a column definition
-	void AddGeneratedColumn(const ColumnDefinition &column, const case_insensitive_map_t<column_t> &name_map);
-
-	//! Removes the column(s) and outputs the new column indices
-	vector<column_t> RemoveColumn(column_t index, column_t column_amount);
-
-	bool IsDependencyOf(column_t dependent, column_t dependency) const;
-	bool HasDependencies(column_t index) const;
-	const unordered_set<column_t> &GetDependencies(column_t index) const;
 
-	bool HasDependents(column_t index) const;
-	const unordered_set<column_t> &GetDependents(column_t index) const;
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/default/default_generator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-private:
-	void RemoveStandardColumn(column_t index);
-	void RemoveGeneratedColumn(column_t index);
 
-	void AdjustSingle(column_t idx, idx_t offset);
-	// Clean up the gaps created by a Remove operation
-	vector<column_t> CleanupInternals(column_t column_amount);
 
-private:
-	//! A map of column dependency to generated column(s)
-	unordered_map<column_t, unordered_set<column_t>> dependencies_map;
-	//! A map of generated column name to (potentially generated)column dependencies
-	unordered_map<column_t, unordered_set<column_t>> dependents_map;
-	//! For resolve-order purposes, keep track of the 'direct' (not inherited) dependencies of a generated column
-	unordered_map<column_t, unordered_set<column_t>> direct_dependencies;
-	set<column_t> deleted_columns;
-};
 
-} // namespace duckdb
 
 
 namespace duckdb {
+class ClientContext;
 
-class DataTable;
-struct CreateTableInfo;
-struct BoundCreateTableInfo;
+class DefaultGenerator {
+public:
+	explicit DefaultGenerator(Catalog &catalog) : catalog(catalog), created_all_entries(false) {
+	}
+	virtual ~DefaultGenerator() {
+	}
 
-struct RenameColumnInfo;
-struct AddColumnInfo;
-struct RemoveColumnInfo;
-struct SetDefaultInfo;
-struct ChangeColumnTypeInfo;
-struct AlterForeignKeyInfo;
-struct SetNotNullInfo;
-struct DropNotNullInfo;
+	Catalog &catalog;
+	atomic<bool> created_all_entries;
 
-//! A table catalog entry
-class TableCatalogEntry : public StandardEntry {
 public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
-	                  std::shared_ptr<DataTable> inherited_storage = nullptr);
+	//! Creates a default entry with the specified name, or returns nullptr if no such entry can be generated
+	virtual unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) = 0;
+	//! Get a list of all default entries in the generator
+	virtual vector<string> GetDefaultEntries() = 0;
+};
 
-	//! A reference to the underlying storage unit used for this table
-	std::shared_ptr<DataTable> storage;
-	//! A list of columns that are part of this table
-	vector<ColumnDefinition> columns;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<Constraint>> constraints;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	ColumnDependencyManager column_dependency_manager;
-	//! A map of column name to column index
-	case_insensitive_map_t<column_t> name_map;
+} // namespace duckdb
 
-public:
-	//! For debugging purposes, count how many columns are STANDARD
-	idx_t StandardColumnCount() const;
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
-	//! Returns whether or not a column with the given name exists
-	DUCKDB_API bool ColumnExists(const string &name);
-	//! Returns a reference to the column of the specified name. Throws an
-	//! exception if the column does not exist.
-	ColumnDefinition &GetColumn(const string &name);
-	//! Returns a list of types of the table
-	vector<LogicalType> GetTypes();
-	string ToSQL() override;
 
-	//! Serialize the meta information of the TableCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
 
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
 
-	void SetAsRoot() override;
 
-	void CommitAlter(AlterInfo &info);
-	void CommitDrop();
 
-	//! Returns the column index of the specified column name.
-	//! If the column does not exist:
-	//! If if_exists is true, returns DConstants::INVALID_INDEX
-	//! If if_exists is false, throws an exception
-	column_t GetColumnIndex(string &name, bool if_exists = false);
 
-private:
-	const string &GetColumnName(column_t index);
-	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
-	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
-	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
-	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
-	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
-	unique_ptr<CatalogEntry> SetNotNull(ClientContext &context, SetNotNullInfo &info);
-	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
-	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
-	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
-};
-} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -23876,117 +24461,6 @@ private:
 	mutex lock;
 };
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/table_filter.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/enums/filter_propagate_result.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-enum class FilterPropagateResult : uint8_t {
-	NO_PRUNING_POSSIBLE = 0,
-	FILTER_ALWAYS_TRUE = 1,
-	FILTER_ALWAYS_FALSE = 2,
-	FILTER_TRUE_OR_NULL = 3,
-	FILTER_FALSE_OR_NULL = 4
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-class BaseStatistics;
-class FieldWriter;
-class FieldReader;
-
-enum class TableFilterType : uint8_t {
-	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
-	IS_NULL = 1,
-	IS_NOT_NULL = 2,
-	CONJUNCTION_OR = 3,
-	CONJUNCTION_AND = 4
-};
-
-//! TableFilter represents a filter pushed down into the table scan.
-class TableFilter {
-public:
-	TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
-	}
-	virtual ~TableFilter() {
-	}
-
-	TableFilterType filter_type;
-
-public:
-	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
-	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
-	virtual string ToString(const string &column_name) = 0;
-	virtual bool Equals(const TableFilter &other) const {
-		return filter_type != other.filter_type;
-	}
-
-	void Serialize(Serializer &serializer) const;
-	virtual void Serialize(FieldWriter &writer) const = 0;
-	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
-};
-
-class TableFilterSet {
-public:
-	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
-
-public:
-	void PushFilter(idx_t table_index, unique_ptr<TableFilter> filter);
-
-	bool Equals(TableFilterSet &other) {
-		if (filters.size() != other.filters.size()) {
-			return false;
-		}
-		for (auto &entry : filters) {
-			auto other_entry = other.filters.find(entry.first);
-			if (other_entry == other.filters.end()) {
-				return false;
-			}
-			if (!entry.second->Equals(*other_entry->second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	static bool Equals(TableFilterSet *left, TableFilterSet *right) {
-		if (left == right) {
-			return true;
-		}
-		if (!left || !right) {
-			return false;
-		}
-		return left->Equals(*right);
-	}
-
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<TableFilterSet> Deserialize(Deserializer &source);
-};
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -25017,41 +25491,6 @@ private:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-class Expression;
-
-struct ExpressionHashFunction {
-	uint64_t operator()(const BaseExpression *const &expr) const {
-		return (uint64_t)expr->Hash();
-	}
-};
-
-struct ExpressionEquality {
-	bool operator()(const BaseExpression *const &a, const BaseExpression *const &b) const {
-		return a->Equals(b);
-	}
-};
-
-template <typename T>
-using expression_map_t = unordered_map<BaseExpression *, T, ExpressionHashFunction, ExpressionEquality>;
-
-using expression_set_t = unordered_set<BaseExpression *, ExpressionHashFunction, ExpressionEquality>;
-
-} // namespace duckdb
 
 
 
@@ -25200,7 +25639,7 @@ public:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
 // See the end of this file for a list
 
 // Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
@@ -25404,7 +25843,7 @@ public:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
 // See the end of this file for a list
 
 // Copyright 2001-2010 The RE2 Authors.  All Rights Reserved.