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

package/src/duckdb.cpp

@@ -9579,7 +9579,7 @@ ParameterNotResolvedException::ParameterNotResolvedException()
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 /*
@@ -9621,7 +9621,7 @@ ParameterNotResolvedException::ParameterNotResolvedException()
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 // Formatting library for C++ - the core API
@@ -14405,7 +14405,7 @@ FMT_END_NAMESPACE
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 // Formatting library for C++ - legacy printf implementation
@@ -14424,7 +14424,7 @@ FMT_END_NAMESPACE
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 // Formatting library for C++ - std::ostream support
@@ -15613,7 +15613,7 @@ public:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
 // See the end of this file for a list
 
 /*
@@ -16977,7 +16977,7 @@ static constexpr const unsigned char GZIP_FLAG_UNSUPPORTED =
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
 // See the end of this file for a list
 
 /* miniz.c 2.0.8 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
@@ -18275,7 +18275,7 @@ void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const ch
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
 // See the end of this file for a list
 
 //===----------------------------------------------------------------------===//
@@ -22447,7 +22447,7 @@ struct IntervalToStringCast {
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
 // See the end of this file for a list
 
 // duckdb_fast_float by Daniel Lemire
@@ -29342,7 +29342,7 @@ private:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
 // See the end of this file for a list
 
 /*
@@ -29469,7 +29469,7 @@ private:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
 // See the end of this file for a list
 
 /*
@@ -29558,7 +29558,7 @@ private:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #6
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
 // See the end of this file for a list
 
 /*
@@ -39300,7 +39300,7 @@ public:
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
 // See the end of this file for a list
 
 
@@ -44128,133 +44128,6 @@ string hugeint_t::ToString() const {
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/types/hyperloglog.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
-// 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
 
 
 
@@ -68769,60 +68642,6 @@ public:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/distinct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-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
 
 
 namespace duckdb {
@@ -70011,6 +69830,8 @@ string PhysicalComparisonJoin::ParamsToString() const {
 		string op = ExpressionTypeToOperator(it.comparison);
 		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
 	}
+	extra_info += "\nEC = " + std::to_string(estimated_props->GetCardinality()) + "\n";
+	extra_info += "COST = " + std::to_string(estimated_props->GetCost()) + "\n";
 	return extra_info;
 }
 
@@ -79729,6 +79550,7 @@ string PhysicalTableScan::ParamsToString() const {
 			}
 		}
 	}
+	result += "\nEC=" + to_string(estimated_cardinality) + "\n";
 	return result;
 }
 
@@ -85254,98 +85076,149 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(unique_ptr<Logica
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &op) {
 	op.estimated_cardinality = op.EstimateCardinality(context);
+	unique_ptr<PhysicalOperator> plan = nullptr;
+
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_GET:
-		return CreatePlan((LogicalGet &)op);
+		plan = CreatePlan((LogicalGet &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return CreatePlan((LogicalProjection &)op);
+		plan = CreatePlan((LogicalProjection &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		return CreatePlan((LogicalEmptyResult &)op);
+		plan = CreatePlan((LogicalEmptyResult &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
-		return CreatePlan((LogicalFilter &)op);
+		plan = CreatePlan((LogicalFilter &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return CreatePlan((LogicalAggregate &)op);
+		plan = CreatePlan((LogicalAggregate &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_WINDOW:
-		return CreatePlan((LogicalWindow &)op);
+		plan = CreatePlan((LogicalWindow &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_UNNEST:
-		return CreatePlan((LogicalUnnest &)op);
+		plan = CreatePlan((LogicalUnnest &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_LIMIT:
-		return CreatePlan((LogicalLimit &)op);
+		plan = CreatePlan((LogicalLimit &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		return CreatePlan((LogicalLimitPercent &)op);
+		plan = CreatePlan((LogicalLimitPercent &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_SAMPLE:
-		return CreatePlan((LogicalSample &)op);
+		plan = CreatePlan((LogicalSample &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return CreatePlan((LogicalOrder &)op);
+		plan = CreatePlan((LogicalOrder &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_TOP_N:
-		return CreatePlan((LogicalTopN &)op);
+		plan = CreatePlan((LogicalTopN &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		return CreatePlan((LogicalCopyToFile &)op);
+		plan = CreatePlan((LogicalCopyToFile &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		return CreatePlan((LogicalDummyScan &)op);
+		plan = CreatePlan((LogicalDummyScan &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		return CreatePlan((LogicalAnyJoin &)op);
+		plan = CreatePlan((LogicalAnyJoin &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return CreatePlan((LogicalDelimJoin &)op);
+		plan = CreatePlan((LogicalDelimJoin &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		return CreatePlan((LogicalComparisonJoin &)op);
+		plan = CreatePlan((LogicalComparisonJoin &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return CreatePlan((LogicalCrossProduct &)op);
+		plan = CreatePlan((LogicalCrossProduct &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return CreatePlan((LogicalSetOperation &)op);
+		plan = CreatePlan((LogicalSetOperation &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
-		return CreatePlan((LogicalInsert &)op);
+		plan = CreatePlan((LogicalInsert &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_DELETE:
-		return CreatePlan((LogicalDelete &)op);
+		plan = CreatePlan((LogicalDelete &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		return CreatePlan((LogicalColumnDataGet &)op);
+		plan = CreatePlan((LogicalColumnDataGet &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		return CreatePlan((LogicalDelimGet &)op);
+		plan = CreatePlan((LogicalDelimGet &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		return CreatePlan((LogicalExpressionGet &)op);
+		plan = CreatePlan((LogicalExpressionGet &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_UPDATE:
-		return CreatePlan((LogicalUpdate &)op);
+		plan = CreatePlan((LogicalUpdate &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		return CreatePlan((LogicalCreateTable &)op);
+		plan = CreatePlan((LogicalCreateTable &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		return CreatePlan((LogicalCreateIndex &)op);
+		plan = CreatePlan((LogicalCreateIndex &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		return CreatePlan((LogicalExplain &)op);
+		plan = CreatePlan((LogicalExplain &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_SHOW:
-		return CreatePlan((LogicalShow &)op);
+		plan = CreatePlan((LogicalShow &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_DISTINCT:
-		return CreatePlan((LogicalDistinct &)op);
+		plan = CreatePlan((LogicalDistinct &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_PREPARE:
-		return CreatePlan((LogicalPrepare &)op);
+		plan = CreatePlan((LogicalPrepare &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EXECUTE:
-		return CreatePlan((LogicalExecute &)op);
+		plan = CreatePlan((LogicalExecute &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
 	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		return CreatePlan((LogicalCreate &)op);
+		plan = CreatePlan((LogicalCreate &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_PRAGMA:
-		return CreatePlan((LogicalPragma &)op);
+		plan = CreatePlan((LogicalPragma &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 	case LogicalOperatorType::LOGICAL_ALTER:
 	case LogicalOperatorType::LOGICAL_DROP:
 	case LogicalOperatorType::LOGICAL_VACUUM:
 	case LogicalOperatorType::LOGICAL_LOAD:
-		return CreatePlan((LogicalSimple &)op);
+		plan = CreatePlan((LogicalSimple &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		return CreatePlan((LogicalRecursiveCTE &)op);
+		plan = CreatePlan((LogicalRecursiveCTE &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_CTE_REF:
-		return CreatePlan((LogicalCTERef &)op);
+		plan = CreatePlan((LogicalCTERef &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EXPORT:
-		return CreatePlan((LogicalExport &)op);
+		plan = CreatePlan((LogicalExport &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_SET:
-		return CreatePlan((LogicalSet &)op);
-	default:
+		plan = CreatePlan((LogicalSet &)op);
+		break;
+	default: {
 		throw NotImplementedException("Unimplemented logical operator type!");
 	}
+	}
+
+	if (op.estimated_props) {
+		plan->estimated_cardinality = op.estimated_props->GetCardinality();
+		plan->estimated_props = op.estimated_props->Copy();
+	} else {
+		plan->estimated_props = make_unique<EstimatedProperties>();
+	}
+
+	return plan;
 }
 
 } // namespace duckdb
@@ -141712,6 +141585,786 @@ void StreamQueryResult::Close() {
 	context.reset();
 }
 
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order_optimizer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/cardinality_estimator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct RelationAttributes {
+	string original_name;
+	// the relation columns used in join filters
+	// Needed when iterating over columns and initializing total domain values.
+	unordered_set<idx_t> columns;
+	double cardinality;
+};
+
+struct RelationsToTDom {
+	//! column binding sets that are equivalent in a join plan.
+	//! if you have A.x = B.y and B.y = C.z, then one set is {A.x, B.y, C.z}.
+	column_binding_set_t equivalent_relations;
+	//!	the estimated total domains of the equivalent relations determined using HLL
+	idx_t tdom_hll;
+	//! the estimated total domains of each relation without using HLL
+	idx_t tdom_no_hll;
+	bool has_tdom_hll;
+	vector<FilterInfo *> filters;
+
+	RelationsToTDom(column_binding_set_t column_binding_set)
+	    : equivalent_relations(column_binding_set), tdom_hll(0), tdom_no_hll(NumericLimits<idx_t>::Maximum()),
+	      has_tdom_hll(false) {};
+};
+
+struct NodeOp {
+	unique_ptr<JoinNode> node;
+	LogicalOperator *op;
+
+	NodeOp(unique_ptr<JoinNode> node, LogicalOperator *op) : node(move(node)), op(op) {};
+};
+
+struct Subgraph2Denominator {
+	unordered_set<idx_t> relations;
+	double denom;
+
+	Subgraph2Denominator() : relations(), denom(1) {};
+};
+
+class CardinalityEstimator {
+public:
+	explicit CardinalityEstimator(ClientContext &context) : context(context) {
+	}
+
+private:
+	ClientContext &context;
+
+	//! A mapping of relation id -> RelationAttributes
+	unordered_map<idx_t, RelationAttributes> relation_attributes;
+	//! A mapping of (relation, bound_column) -> (actual table, actual column)
+	column_binding_map_t<ColumnBinding> relation_column_to_original_column;
+
+	vector<RelationsToTDom> relations_to_tdoms;
+
+	static constexpr double DEFAULT_SELECTIVITY = 0.2;
+
+public:
+	static void VerifySymmetry(JoinNode *result, JoinNode *entry);
+
+	void AssertEquivalentRelationSize();
+
+	//! given a binding of (relation, column) used for DP, and a (table, column) in that catalog
+	//! Add the key value entry into the relation_column_to_original_column
+	void AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value);
+	//! Add a column to the relation_to_columns map.
+	void AddColumnToRelationMap(idx_t table_index, idx_t column_index);
+	//! Dump all bindings in relation_column_to_original_column into the child_binding_map
+	// If you have a non-reorderable join, this function is used to keep track of bindings
+	// in the child join plan.
+	void CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map);
+	void MergeBindings(idx_t, idx_t relation_id, vector<column_binding_map_t<ColumnBinding>> &child_binding_maps);
+	void AddRelationColumnMapping(LogicalGet *get, idx_t relation_id);
+
+	void InitTotalDomains();
+	void UpdateTotalDomains(JoinNode *node, LogicalOperator *op);
+	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos);
+
+	void InitCardinalityEstimatorProps(vector<struct NodeOp> *node_ops, vector<unique_ptr<FilterInfo>> *filter_infos);
+	double EstimateCardinalityWithSet(JoinRelationSet *new_set);
+	void EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op);
+	double EstimateCrossProduct(const JoinNode *left, const JoinNode *right);
+	static double ComputeCost(JoinNode *left, JoinNode *right, double expected_cardinality);
+
+private:
+	bool SingleColumnFilter(FilterInfo *filter_info);
+	//! Filter & bindings -> list of indexes into the equivalent_relations array.
+	// The column binding set at each index is an equivalence set.
+	vector<idx_t> DetermineMatchingEquivalentSets(FilterInfo *filter_info);
+
+	//! Given a filter, add the column bindings to the matching equivalent set at the index
+	//! given in matching equivalent sets.
+	//! If there are multiple equivalence sets, they are merged.
+	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
+
+	TableFilterSet *GetTableFilters(LogicalOperator *op);
+
+	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *fil,
+	                            unique_ptr<BaseStatistics> base_stats);
+	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *fil,
+	                           unique_ptr<BaseStatistics> base_stats);
+	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters);
+};
+
+} // namespace duckdb
+
+
+#include <functional>
+
+namespace duckdb {
+
+class JoinOrderOptimizer {
+public:
+	explicit JoinOrderOptimizer(ClientContext &context)
+	    : context(context), cardinality_estimator(context), full_plan_found(false), must_update_full_plan(false) {
+	}
+
+	//! Perform join reordering inside a plan
+	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
+
+	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet *set, const vector<NeighborInfo *> &possible_connections,
+	                                    JoinNode *left, JoinNode *right);
+
+private:
+	ClientContext &context;
+	//! The total amount of join pairs that have been considered
+	idx_t pairs = 0;
+	//! Set of all relations considered in the join optimizer
+	vector<unique_ptr<SingleJoinRelation>> relations;
+	//! A mapping of base table index -> index into relations array (relation number)
+	unordered_map<idx_t, idx_t> relation_mapping;
+	//! A structure holding all the created JoinRelationSet objects
+	JoinRelationSetManager set_manager;
+	//! The set of edges used in the join optimizer
+	QueryGraph query_graph;
+	//! The optimal join plan found for the specific JoinRelationSet*
+	unordered_map<JoinRelationSet *, unique_ptr<JoinNode>> plans;
+
+	//! The set of filters extracted from the query graph
+	vector<unique_ptr<Expression>> filters;
+	//! The set of filter infos created from the extracted filters
+	vector<unique_ptr<FilterInfo>> filter_infos;
+	//! A map of all expressions a given expression has to be equivalent to. This is used to add "implied join edges".
+	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A <->
+	//! C}
+	expression_map_t<vector<FilterInfo *>> equivalence_sets;
+
+	CardinalityEstimator cardinality_estimator;
+
+	bool full_plan_found;
+	bool must_update_full_plan;
+	unordered_set<JoinNode *> join_nodes_in_full_plan;
+
+	//! Extract the bindings referred to by an Expression
+	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
+
+	//! Get column bindings from a filter
+	void GetColumnBindings(Expression &expression, ColumnBinding &left_binding, ColumnBinding &right_binding);
+
+	//! Traverse the query tree to find (1) base relations, (2) existing join conditions and (3) filters that can be
+	//! rewritten into joins. Returns true if there are joins in the tree that can be reordered, false otherwise.
+	bool ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
+	                          LogicalOperator *parent = nullptr);
+
+	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
+	//! the newly created plan, or an existing plan)
+	JoinNode *EmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
+	//! cancelling the dynamic programming step.
+	bool TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+
+	bool EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right, unordered_set<idx_t> exclusion_set);
+	//! Emit a relation set node
+	bool EmitCSG(JoinRelationSet *node);
+	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
+	bool EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	//! Rewrite a logical query plan given the join plan
+	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node);
+	//! Generate cross product edges inside the side
+	void GenerateCrossProducts();
+	//! Perform the join order solving
+	void SolveJoinOrder();
+	//! Solve the join order exactly using dynamic programming. Returns true if it was completed successfully (i.e. did
+	//! not time-out)
+	bool SolveJoinOrderExactly();
+	//! Solve the join order approximately using a greedy algorithm
+	void SolveJoinOrderApproximately();
+
+	void UpdateDPTree(JoinNode *new_plan);
+
+	void UpdateJoinNodesInFullPlan(JoinNode *node);
+
+	std::pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
+	GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node);
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+static TableCatalogEntry *GetCatalogTableEntry(LogicalOperator *op) {
+	if (op->type == LogicalOperatorType::LOGICAL_GET) {
+		auto get = (LogicalGet *)op;
+		TableCatalogEntry *entry = get->GetTable();
+		return entry;
+	}
+	for (auto &child : op->children) {
+		TableCatalogEntry *entry = GetCatalogTableEntry(child.get());
+		if (entry != nullptr) {
+			return entry;
+		}
+	}
+	return nullptr;
+}
+
+bool CardinalityEstimator::SingleColumnFilter(FilterInfo *filter_info) {
+	if (filter_info->left_set && filter_info->right_set) {
+		// Both set
+		return false;
+	}
+	// Filter on one relation, (i.e string or range filter on a column).
+	// Grab the first relation and add it to the the equivalence_relations
+	D_ASSERT(filter_info->set->count >= 1);
+	for (const RelationsToTDom &r2tdom : relations_to_tdoms) {
+		auto &i_set = r2tdom.equivalent_relations;
+		if (i_set.find(filter_info->left_binding) != i_set.end()) {
+			// found an equivalent filter
+			return true;
+		}
+	}
+	auto key = ColumnBinding(filter_info->left_binding.table_index, filter_info->left_binding.column_index);
+	column_binding_set_t tmp({key});
+	relations_to_tdoms.emplace_back(RelationsToTDom(tmp));
+	return true;
+}
+
+vector<idx_t> CardinalityEstimator::DetermineMatchingEquivalentSets(FilterInfo *filter_info) {
+	vector<idx_t> matching_equivalent_sets;
+	auto equivalent_relation_index = 0;
+
+	for (const RelationsToTDom &r2tdom : relations_to_tdoms) {
+		auto &i_set = r2tdom.equivalent_relations;
+		if (i_set.find(filter_info->left_binding) != i_set.end()) {
+			matching_equivalent_sets.push_back(equivalent_relation_index);
+		} else if (i_set.find(filter_info->right_binding) != i_set.end()) {
+			// don't add both left and right to the matching_equivalent_sets
+			// since both left and right get added to that index anyway.
+			matching_equivalent_sets.push_back(equivalent_relation_index);
+		}
+		equivalent_relation_index++;
+	}
+	return matching_equivalent_sets;
+}
+
+void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets) {
+	D_ASSERT(matching_equivalent_sets.size() <= 2);
+	if (matching_equivalent_sets.size() > 1) {
+		// an equivalence relation is connecting to sets of equivalence relations
+		// so push all relations from the second set into the first. Later we will delete
+		// the second set.
+		for (ColumnBinding i : relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations) {
+			relations_to_tdoms.at(matching_equivalent_sets[0]).equivalent_relations.insert(i);
+		}
+		relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations.clear();
+		relations_to_tdoms.at(matching_equivalent_sets[0]).filters.push_back(filter_info);
+		// add all values of one set to the other, delete the empty one
+	} else if (matching_equivalent_sets.size() == 1) {
+		auto &tdom_i = relations_to_tdoms.at(matching_equivalent_sets.at(0));
+		tdom_i.equivalent_relations.insert(filter_info->left_binding);
+		tdom_i.equivalent_relations.insert(filter_info->right_binding);
+		tdom_i.filters.push_back(filter_info);
+	} else if (matching_equivalent_sets.empty()) {
+		column_binding_set_t tmp;
+		tmp.insert(filter_info->left_binding);
+		tmp.insert(filter_info->right_binding);
+		relations_to_tdoms.emplace_back(RelationsToTDom(tmp));
+		relations_to_tdoms.back().filters.push_back(filter_info);
+	}
+}
+
+void CardinalityEstimator::AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value) {
+	relation_column_to_original_column[key] = value;
+}
+
+void CardinalityEstimator::CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map) {
+	for (auto &binding_map : relation_column_to_original_column) {
+		child_binding_map[binding_map.first] = binding_map.second;
+	}
+}
+
+void CardinalityEstimator::AddColumnToRelationMap(idx_t table_index, idx_t column_index) {
+	relation_attributes[table_index].columns.insert(column_index);
+}
+
+void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos) {
+	// For each filter, we fill keep track of the index of the equivalent relation set
+	// the left and right relation needs to be added to.
+	for (auto &filter : *filter_infos) {
+		if (SingleColumnFilter(filter.get())) {
+			continue;
+		}
+		D_ASSERT(filter->left_set->count >= 1);
+		D_ASSERT(filter->right_set->count >= 1);
+
+		auto matching_equivalent_sets = DetermineMatchingEquivalentSets(filter.get());
+		AddToEquivalenceSets(filter.get(), matching_equivalent_sets);
+	}
+}
+
+void CardinalityEstimator::VerifySymmetry(JoinNode *result, JoinNode *entry) {
+	if (result->GetCardinality() != entry->GetCardinality()) {
+		// Currently it's possible that some entries are cartesian joins.
+		// When this is the case, you don't always have symmetry, but
+		// if the cost of the result is less, then just assure the cardinality
+		// is also less, then you have the same effect of symmetry.
+		D_ASSERT(ceil(result->GetCardinality()) <= ceil(entry->GetCardinality()) ||
+		         floor(result->GetCardinality()) <= floor(entry->GetCardinality()));
+	}
+}
+
+void CardinalityEstimator::InitTotalDomains() {
+	auto remove_start = std::remove_if(relations_to_tdoms.begin(), relations_to_tdoms.end(),
+	                                   [](RelationsToTDom &r_2_tdom) { return r_2_tdom.equivalent_relations.empty(); });
+	relations_to_tdoms.erase(remove_start, relations_to_tdoms.end());
+}
+
+double CardinalityEstimator::ComputeCost(JoinNode *left, JoinNode *right, double expected_cardinality) {
+	return expected_cardinality + left->GetCost() + right->GetCost();
+}
+
+double CardinalityEstimator::EstimateCrossProduct(const JoinNode *left, const JoinNode *right) {
+	// need to explicity use double here, otherwise auto converts it to an int, then
+	// there is an autocast in the return.
+	return left->GetCardinality() >= (NumericLimits<double>::Maximum() / right->GetCardinality())
+	           ? NumericLimits<double>::Maximum()
+	           : left->GetCardinality() * right->GetCardinality();
+}
+
+void CardinalityEstimator::AddRelationColumnMapping(LogicalGet *get, idx_t relation_id) {
+	for (idx_t it = 0; it < get->column_ids.size(); it++) {
+		auto key = ColumnBinding(relation_id, it);
+		auto value = ColumnBinding(get->table_index, get->column_ids[it]);
+		AddRelationToColumnMapping(key, value);
+	}
+}
+
+void UpdateDenom(Subgraph2Denominator *relation_2_denom, RelationsToTDom *relation_to_tdom) {
+	relation_2_denom->denom *=
+	    relation_to_tdom->has_tdom_hll ? relation_to_tdom->tdom_hll : relation_to_tdom->tdom_no_hll;
+}
+
+void FindSubgraphMatchAndMerge(Subgraph2Denominator &merge_to, idx_t find_me,
+                               vector<Subgraph2Denominator>::iterator subgraph,
+                               vector<Subgraph2Denominator>::iterator end) {
+	for (; subgraph != end; subgraph++) {
+		if (subgraph->relations.count(find_me) >= 1) {
+			for (auto &relation : subgraph->relations) {
+				merge_to.relations.insert(relation);
+			}
+			subgraph->relations.clear();
+			merge_to.denom *= subgraph->denom;
+			return;
+		}
+	}
+}
+
+double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set) {
+	double numerator = 1;
+	unordered_set<idx_t> actual_set;
+	for (idx_t i = 0; i < new_set->count; i++) {
+		numerator *= relation_attributes[new_set->relations[i]].cardinality;
+		actual_set.insert(new_set->relations[i]);
+	}
+	vector<Subgraph2Denominator> subgraphs;
+	bool done = false;
+	bool found_match = false;
+
+	// Finding the denominator is tricky. You need to go through the tdoms in decreasing order
+	// Then loop through all filters in the equivalence set of the tdom to see if both the
+	// left and right relations are in the new set, if so you can use that filter.
+	// You must also make sure that the filters all relations in the given set, so we use subgraphs
+	// that should eventually merge into one connected graph that joins all the relations
+	// TODO: Don't implement a method to cache subgraphs so you don't have to build them up every
+	// time the cardinality of a new set is requested
+
+	// relations_to_tdoms has already been sorted.
+	for (auto &relation_2_tdom : relations_to_tdoms) {
+		// loop through each filter in the tdom.
+		if (done) {
+			break;
+		}
+		for (auto &filter : relation_2_tdom.filters) {
+			if (actual_set.count(filter->left_binding.table_index) == 0 ||
+			    actual_set.count(filter->right_binding.table_index) == 0) {
+				continue;
+			}
+			// the join filter is on relations in the new set.
+			found_match = false;
+			vector<Subgraph2Denominator>::iterator it;
+			for (it = subgraphs.begin(); it != subgraphs.end(); it++) {
+				auto left_in = it->relations.count(filter->left_binding.table_index);
+				auto right_in = it->relations.count(filter->right_binding.table_index);
+				// if both left and right bindings are in the subgraph, continue
+				// if both left and right bindings are *not* in the subgraph, continue
+				if (!(left_in ^ right_in)) {
+					continue;
+				}
+				idx_t find_table;
+				if (left_in) {
+					find_table = filter->right_binding.table_index;
+				} else {
+					D_ASSERT(right_in);
+					find_table = filter->left_binding.table_index;
+				}
+				auto next_subgraph = it + 1;
+				// iterate through other subgraphs and merge.
+				FindSubgraphMatchAndMerge(*it, find_table, next_subgraph, subgraphs.end());
+				// Now insert the right binding and update denominator with the
+				// tdom of the filter
+				it->relations.insert(find_table);
+				UpdateDenom(&(*it), &relation_2_tdom);
+				found_match = true;
+				break;
+			}
+			// means that the filter joins relations in the given set, but there is no
+			// connection to any subgraph in subgraphs. Add a new subgraph, and maybe later there will be
+			// a connection.
+			if (!found_match) {
+				subgraphs.emplace_back(Subgraph2Denominator());
+				auto subgraph = &subgraphs.back();
+				subgraph->relations.insert(filter->left_binding.table_index);
+				subgraph->relations.insert(filter->right_binding.table_index);
+				UpdateDenom(subgraph, &relation_2_tdom);
+			}
+			auto remove_start = std::remove_if(subgraphs.begin(), subgraphs.end(),
+			                                   [](Subgraph2Denominator &s) { return s.relations.empty(); });
+			subgraphs.erase(remove_start, subgraphs.end());
+
+			if (subgraphs.size() == 1 && subgraphs.at(0).relations.size() == new_set->count) {
+				// You have found enough filters to connect the relations. These are guaranteed
+				// to be the filters with the highest Tdoms.
+				done = true;
+				break;
+			}
+		}
+	}
+	double denom = 1;
+	for (auto &match : subgraphs) {
+		if (match.relations.size() == new_set->count) {
+			denom = match.denom;
+		}
+	}
+	// can happen if a table has cardinality 0, or a tdom is set to 0
+	if (denom == 0) {
+		denom = 1;
+	}
+	return numerator / denom;
+}
+
+static bool IsLogicalFilter(LogicalOperator *op) {
+	return op->type == LogicalOperatorType::LOGICAL_FILTER;
+}
+
+static LogicalGet *GetLogicalGet(LogicalOperator *op) {
+	LogicalGet *get = nullptr;
+	switch (op->type) {
+	case LogicalOperatorType::LOGICAL_GET:
+		get = (LogicalGet *)op;
+		break;
+	case LogicalOperatorType::LOGICAL_FILTER:
+		get = GetLogicalGet(op->children.at(0).get());
+		break;
+	case LogicalOperatorType::LOGICAL_PROJECTION:
+		get = GetLogicalGet(op->children.at(0).get());
+		break;
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
+		LogicalComparisonJoin *join = (LogicalComparisonJoin *)op;
+		if (join->join_type == JoinType::MARK || join->join_type == JoinType::LEFT) {
+			auto child = join->children.at(0).get();
+			get = GetLogicalGet(child);
+		}
+		break;
+	}
+	default:
+		// return null pointer, maybe there is no logical get under this child
+		break;
+	}
+	return get;
+}
+
+void CardinalityEstimator::MergeBindings(idx_t binding_index, idx_t relation_id,
+                                         vector<column_binding_map_t<ColumnBinding>> &child_binding_maps) {
+	for (auto &map_set : child_binding_maps) {
+		for (auto &mapping : map_set) {
+			ColumnBinding relation_bindings = mapping.first;
+			ColumnBinding actual_bindings = mapping.second;
+
+			if (actual_bindings.table_index == binding_index) {
+				auto key = ColumnBinding(relation_id, relation_bindings.column_index);
+				AddRelationToColumnMapping(key, actual_bindings);
+			}
+		}
+	}
+}
+
+bool SortTdoms(const RelationsToTDom &a, const RelationsToTDom &b) {
+	if (a.has_tdom_hll && b.has_tdom_hll) {
+		return a.tdom_hll > b.tdom_hll;
+	}
+	if (a.has_tdom_hll) {
+		return a.tdom_hll > b.tdom_no_hll;
+	}
+	if (b.has_tdom_hll) {
+		return a.tdom_no_hll > b.tdom_hll;
+	}
+	return a.tdom_no_hll > b.tdom_no_hll;
+}
+
+void CardinalityEstimator::InitCardinalityEstimatorProps(vector<struct NodeOp> *node_ops,
+                                                         vector<unique_ptr<FilterInfo>> *filter_infos) {
+	InitEquivalentRelations(filter_infos);
+	InitTotalDomains();
+	for (idx_t i = 0; i < node_ops->size(); i++) {
+		auto join_node = (*node_ops)[i].node.get();
+		auto op = (*node_ops)[i].op;
+		join_node->SetBaseTableCardinality(op->EstimateCardinality(context));
+		if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+			auto &join = (LogicalComparisonJoin &)*op;
+			if (join.join_type == JoinType::LEFT) {
+				// TODO: inspect child operators to get a more accurate cost
+				// and cardinality estimation. If an base op is a Logical Comparison join
+				// it is probably a left join, so cost of the larger table is a fine
+				// estimate
+				// No need to update a mark join cost because I say so.
+				join_node->SetCost(join_node->GetBaseTableCardinality());
+			}
+		}
+		// update cardinality with filters
+		EstimateBaseTableCardinality(join_node, op);
+		UpdateTotalDomains(join_node, op);
+	}
+
+	// sort relations from greatest tdom to lowest tdom.
+	std::sort(relations_to_tdoms.begin(), relations_to_tdoms.end(), SortTdoms);
+}
+
+void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *op) {
+	auto relation_id = node->set->relations[0];
+	relation_attributes[relation_id].cardinality = node->GetCardinality();
+	TableCatalogEntry *catalog_table = nullptr;
+	auto get = GetLogicalGet(op);
+	if (get) {
+		catalog_table = GetCatalogTableEntry(get);
+	}
+
+	//! Initialize the tdoms for all columns the relation uses in join conditions.
+	unordered_set<idx_t>::iterator ite;
+	idx_t count = node->GetBaseTableCardinality();
+
+	bool direct_filter = false;
+	for (auto &column : relation_attributes[relation_id].columns) {
+		//! for every column in the relation, get the count via either HLL, or assume it to be
+		//! the cardinality
+		ColumnBinding key = ColumnBinding(relation_id, column);
+
+		if (catalog_table) {
+			relation_attributes[relation_id].original_name = catalog_table->name;
+			// Get HLL stats here
+			auto actual_binding = relation_column_to_original_column[key];
+
+			// sometimes base stats is null (test_709.test) returns null for base stats while
+			// there is still a catalog table. Anybody know anything about this?
+			auto base_stats = catalog_table->storage->GetStatistics(context, actual_binding.column_index);
+			if (base_stats) {
+				count = base_stats->GetDistinctCount();
+			}
+
+			// means you have a direct filter on a column. The count/total domain for the column
+			// should be decreased to match the predicted total domain matching the filter.
+			// We decrease the total domain for all columns in the equivalence set because filter pushdown
+			// will mean all columns are affected.
+			if (direct_filter) {
+				count = node->GetCardinality();
+			}
+
+			// HLL has estimation error, count can't be greater than cardinality of the table before filters
+			if (count > node->GetBaseTableCardinality()) {
+				count = node->GetBaseTableCardinality();
+			}
+		} else {
+			// No HLL. So if we know there is a direct filter, reduce count to cardinality with filter
+			// otherwise assume the total domain is still the cardinality
+			if (direct_filter) {
+				count = node->GetCardinality();
+			} else {
+				count = node->GetBaseTableCardinality();
+			}
+		}
+
+		for (auto &relation_to_tdom : relations_to_tdoms) {
+			column_binding_set_t i_set = relation_to_tdom.equivalent_relations;
+			if (i_set.count(key) != 1) {
+				continue;
+			}
+			if (catalog_table) {
+				if (relation_to_tdom.tdom_hll < count) {
+					relation_to_tdom.tdom_hll = count;
+					relation_to_tdom.has_tdom_hll = true;
+				}
+				if (relation_to_tdom.tdom_no_hll > count) {
+					relation_to_tdom.tdom_no_hll = count;
+				}
+			} else {
+				// Here we don't have catalog statistics, and the following is how we determine
+				// the tdom
+				// 1. If there is any hll data in the equivalence set, use that
+				// 2. Otherwise, use the table with the smallest cardinality
+				if (relation_to_tdom.tdom_no_hll > count && !relation_to_tdom.has_tdom_hll) {
+					relation_to_tdom.tdom_no_hll = count;
+				}
+			}
+			break;
+		}
+	}
+}
+
+TableFilterSet *CardinalityEstimator::GetTableFilters(LogicalOperator *op) {
+	// First check table filters
+	auto get = GetLogicalGet(op);
+	return get ? &get->table_filters : nullptr;
+}
+
+idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *filter,
+                                                  unique_ptr<BaseStatistics> base_stats) {
+	auto has_equality_filter = false;
+	auto cardinality_after_filters = cardinality;
+	for (auto &child_filter : filter->child_filters) {
+		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
+			continue;
+		}
+		auto comparison_filter = (ConstantFilter &)*child_filter;
+		if (comparison_filter.comparison_type != ExpressionType::COMPARE_EQUAL) {
+			continue;
+		}
+		auto column_count = 0;
+		if (base_stats) {
+			column_count = base_stats->GetDistinctCount();
+		}
+		auto filtered_card = cardinality;
+		// column_count = 0 when there is no column count (i.e parquet scans)
+		if (column_count > 0) {
+			// we want the ceil of cardinality/column_count. We also want to avoid compiler errors
+			filtered_card = (cardinality + column_count - 1) / column_count;
+			cardinality_after_filters = filtered_card;
+		}
+		if (has_equality_filter) {
+			cardinality_after_filters = MinValue(filtered_card, cardinality_after_filters);
+		}
+		has_equality_filter = true;
+	}
+	return cardinality_after_filters;
+}
+
+idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *filter,
+                                                 unique_ptr<BaseStatistics> base_stats) {
+	auto has_equality_filter = false;
+	auto cardinality_after_filters = cardinality;
+	for (auto &child_filter : filter->child_filters) {
+		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
+			continue;
+		}
+		auto comparison_filter = (ConstantFilter &)*child_filter;
+		if (comparison_filter.comparison_type == ExpressionType::COMPARE_EQUAL) {
+			auto column_count = cardinality_after_filters;
+			if (base_stats) {
+				column_count = base_stats->GetDistinctCount();
+			}
+			auto increment = MaxValue<idx_t>(((cardinality + column_count - 1) / column_count), 1);
+			if (has_equality_filter) {
+				cardinality_after_filters += increment;
+			} else {
+				cardinality_after_filters = increment;
+			}
+			has_equality_filter = true;
+		}
+	}
+	D_ASSERT(cardinality_after_filters > 0);
+	return cardinality_after_filters;
+}
+
+idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters) {
+	idx_t cardinality_after_filters = cardinality;
+	auto get = GetLogicalGet(op);
+	unique_ptr<BaseStatistics> column_statistics;
+	for (auto &it : table_filters->filters) {
+		column_statistics = nullptr;
+		if (get->bind_data && get->function.name.compare("seq_scan") == 0) {
+			auto &table_scan_bind_data = (TableScanBindData &)*get->bind_data;
+			column_statistics = get->function.statistics(context, &table_scan_bind_data, it.first);
+		}
+		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {
+			auto &filter = (ConjunctionAndFilter &)*it.second;
+			idx_t cardinality_with_and_filter =
+			    InspectConjunctionAND(cardinality, it.first, &filter, move(column_statistics));
+			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_and_filter);
+		} else if (it.second->filter_type == TableFilterType::CONJUNCTION_OR) {
+			auto &filter = (ConjunctionOrFilter &)*it.second;
+			idx_t cardinality_with_or_filter =
+			    InspectConjunctionOR(cardinality, it.first, &filter, move(column_statistics));
+			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_or_filter);
+		}
+	}
+	// if the above code didn't find an equality filter (i.e country_code = "[us]")
+	// and there are other table filters, use default selectivity.
+	bool has_equality_filter = (cardinality_after_filters != cardinality);
+	if (!has_equality_filter && !table_filters->filters.empty()) {
+		cardinality_after_filters = MaxValue<idx_t>(cardinality * DEFAULT_SELECTIVITY, 1);
+	}
+	return cardinality_after_filters;
+}
+
+void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op) {
+	auto has_logical_filter = IsLogicalFilter(op);
+	auto table_filters = GetTableFilters(op);
+
+	auto card_after_filters = node->GetBaseTableCardinality();
+	// Logical Filter on a seq scan
+	if (has_logical_filter) {
+		card_after_filters *= DEFAULT_SELECTIVITY;
+	} else if (table_filters) {
+		double inspect_result = (double)InspectTableFilters(card_after_filters, op, table_filters);
+		card_after_filters = MinValue(inspect_result, (double)card_after_filters);
+	}
+	node->SetEstimatedCardinality(card_after_filters);
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -142465,6 +143118,27 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, Deliminat
 }
 
 } // namespace duckdb
+
+
+
+namespace duckdb {
+
+double EstimatedProperties::GetCardinality() {
+	return cardinality;
+}
+double EstimatedProperties::GetCost() {
+	return cost;
+}
+
+void EstimatedProperties::SetCardinality(double new_card) {
+	cardinality = new_card;
+}
+
+void EstimatedProperties::SetCost(double new_cost) {
+	cost = new_cost;
+}
+
+} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -144528,13 +145202,44 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/join_relation.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -144543,59 +145248,73 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 
 
 namespace duckdb {
-class LogicalOperator;
 
-//! Represents a single relation and any metadata accompanying that relation
-struct SingleJoinRelation {
-	LogicalOperator *op;
-	LogicalOperator *parent;
+JoinNode::JoinNode(JoinRelationSet *set, const double base_cardinality)
+    : set(set), info(nullptr), has_filter(false), left(nullptr), right(nullptr), base_cardinality(base_cardinality) {
+	estimated_props = make_unique<EstimatedProperties>(base_cardinality, 0);
+}
 
-	SingleJoinRelation() {
-	}
-	SingleJoinRelation(LogicalOperator *op, LogicalOperator *parent) : op(op), parent(parent) {
-	}
-};
+JoinNode::JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right,
+                   const double base_cardinality, double cost)
+    : set(set), info(info), has_filter(false), left(left), right(right), base_cardinality(base_cardinality) {
+	estimated_props = make_unique<EstimatedProperties>(base_cardinality, cost);
+}
 
-//! Set of relations, used in the join graph.
-struct JoinRelationSet {
-	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(move(relations)), count(count) {
-	}
+unique_ptr<EstimatedProperties> EstimatedProperties::Copy() {
+	auto result = make_unique<EstimatedProperties>(cardinality, cost);
+	return result;
+}
 
-	string ToString() const;
+double JoinNode::GetCardinality() const {
+	return estimated_props->GetCardinality();
+}
 
-	unique_ptr<idx_t[]> relations;
-	idx_t count;
+double JoinNode::GetCost() {
+	return estimated_props->GetCost();
+}
 
-	static bool IsSubset(JoinRelationSet *super, JoinRelationSet *sub);
-};
+void JoinNode::SetCost(double cost) {
+	estimated_props->SetCost(cost);
+}
 
-//! 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;
-	};
+double JoinNode::GetBaseTableCardinality() {
+	if (set->count > 1) {
+		throw InvalidInputException("Cannot call get base table cardinality on intermediate join node");
+	}
+	return base_cardinality;
+}
 
-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);
+void JoinNode::SetBaseTableCardinality(double base_card) {
+	base_cardinality = base_card;
+}
 
-private:
-	JoinRelationTreeNode root;
-};
+void JoinNode::SetEstimatedCardinality(double estimated_card) {
+	estimated_props->SetCardinality(estimated_card);
+}
 
+string JoinNode::ToString() {
+	if (!set) {
+		return "";
+	}
+	string result = "-------------------------------\n";
+	result += set->ToString() + "\n";
+	result += "card = " + to_string(GetCardinality()) + "\n";
+	bool is_cartesian = false;
+	if (left && right) {
+		is_cartesian = (GetCardinality() == left->GetCardinality() * right->GetCardinality());
+	}
+	result += "cartesian = " + to_string(is_cartesian) + "\n";
+	result += "cost = " + to_string(estimated_props->GetCost()) + "\n";
+	result += "left = \n";
+	if (left) {
+		result += left->ToString();
+	}
+	result += "right = \n";
+	if (right) {
+		result += right->ToString();
+	}
+	return result;
+}
 } // namespace duckdb
 
 
@@ -144743,76 +145462,6 @@ JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelati
 // }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order/query_graph.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-
-#include <functional>
-
-namespace duckdb {
-class Expression;
-class LogicalOperator;
-
-struct FilterInfo {
-	idx_t filter_index;
-	JoinRelationSet *left_set = nullptr;
-	JoinRelationSet *right_set = nullptr;
-	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
-	NeighborInfo *GetConnection(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
 
 
 
@@ -144931,30 +145580,18 @@ vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet *node, unordered_set<idx_
 	return neighbors;
 }
 
-NeighborInfo *QueryGraph::GetConnection(JoinRelationSet *node, JoinRelationSet *other) {
-	NeighborInfo *connection = nullptr;
+vector<NeighborInfo *> QueryGraph::GetConnections(JoinRelationSet *node, JoinRelationSet *other) {
+	vector<NeighborInfo *> connections;
 	EnumerateNeighbors(node, [&](NeighborInfo *info) -> bool {
 		if (JoinRelationSet::IsSubset(other, info->neighbor)) {
-			connection = info;
-			return true;
+			connections.push_back(info);
 		}
 		return false;
 	});
-	return connection;
+	return connections;
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/optimizer/join_order_optimizer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
 
 
 
@@ -144962,152 +145599,22 @@ NeighborInfo *QueryGraph::GetConnection(JoinRelationSet *node, JoinRelationSet *
 
 
 
-#include <functional>
-
-namespace duckdb {
 
-class JoinOrderOptimizer {
-public:
-	//! Represents a node in the join plan
-	struct JoinNode {
-		JoinRelationSet *set;
-		NeighborInfo *info;
-		idx_t cardinality;
-		idx_t cost;
-		JoinNode *left;
-		JoinNode *right;
+#include <algorithm>
 
-		//! Create a leaf node in the join tree
-		JoinNode(JoinRelationSet *set, idx_t cardinality)
-		    : set(set), info(nullptr), cardinality(cardinality), cost(cardinality), left(nullptr), right(nullptr) {
-		}
-		//! Create an intermediate node in the join tree
-		JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right, idx_t cardinality,
-		         idx_t cost)
-		    : set(set), info(info), cardinality(cardinality), cost(cost), left(left), right(right) {
-		}
-	};
+namespace std {
 
-public:
-	explicit JoinOrderOptimizer(ClientContext &context) : context(context) {
+//! A JoinNode is defined by the relations it joins.
+template <>
+struct hash<duckdb::JoinNode> {
+	inline string operator()(const duckdb::JoinNode &join_node) const {
+		return join_node.set->ToString();
 	}
-
-	//! Perform join reordering inside a plan
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
-
-private:
-	ClientContext &context;
-	//! The total amount of join pairs that have been considered
-	idx_t pairs = 0;
-	//! Set of all relations considered in the join optimizer
-	vector<unique_ptr<SingleJoinRelation>> relations;
-	//! A mapping of base table index -> index into relations array (relation number)
-	unordered_map<idx_t, idx_t> relation_mapping;
-	//! A structure holding all the created JoinRelationSet objects
-	JoinRelationSetManager set_manager;
-	//! The set of edges used in the join optimizer
-	QueryGraph query_graph;
-	//! The optimal join plan found for the specific JoinRelationSet*
-	unordered_map<JoinRelationSet *, unique_ptr<JoinNode>> plans;
-	//! The set of filters extracted from the query graph
-	vector<unique_ptr<Expression>> filters;
-	//! The set of filter infos created from the extracted filters
-	vector<unique_ptr<FilterInfo>> filter_infos;
-	//! A map of all expressions a given expression has to be equivalent to. This is used to add "implied join edges".
-	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A <->
-	//! C}
-	expression_map_t<vector<FilterInfo *>> equivalence_sets;
-
-	//! Extract the bindings referred to by an Expression
-	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
-	//! Traverse the query tree to find (1) base relations, (2) existing join conditions and (3) filters that can be
-	//! rewritten into joins. Returns true if there are joins in the tree that can be reordered, false otherwise.
-	bool ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
-	                          LogicalOperator *parent = nullptr);
-	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
-	//! the newly created plan, or an existing plan)
-	JoinNode *EmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info);
-	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
-	//! cancelling the dynamic programming step.
-	bool TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info);
-
-	bool EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right, unordered_set<idx_t> exclusion_set);
-	//! Emit a relation set node
-	bool EmitCSG(JoinRelationSet *node);
-	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
-	bool EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
-	//! Rewrite a logical query plan given the join plan
-	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node);
-	//! Generate cross product edges inside the side
-	void GenerateCrossProducts();
-	//! Perform the join order solving
-	void SolveJoinOrder();
-	//! Solve the join order exactly using dynamic programming. Returns true if it was completed successfully (i.e. did
-	//! not time-out)
-	bool SolveJoinOrderExactly();
-	//! Solve the join order approximately using a greedy algorithm
-	void SolveJoinOrderApproximately();
-
-	unique_ptr<LogicalOperator> ResolveJoinConditions(unique_ptr<LogicalOperator> op);
-	std::pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
-	GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node);
 };
-
-} // namespace duckdb
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#include <algorithm>
+} // namespace std
 
 namespace duckdb {
 
-using JoinNode = JoinOrderOptimizer::JoinNode;
-
 //! Returns true if A and B are disjoint, false otherwise
 template <class T>
 static bool Disjoint(unordered_set<T> &a, unordered_set<T> &b) {
@@ -145127,6 +145634,9 @@ bool JoinOrderOptimizer::ExtractBindings(Expression &expression, unordered_set<i
 		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
 		// map the base table index to the relation index used by the JoinOrderOptimizer
 		D_ASSERT(relation_mapping.find(colref.binding.table_index) != relation_mapping.end());
+		auto catalog_table = relation_mapping[colref.binding.table_index];
+		auto column_index = colref.binding.column_index;
+		cardinality_estimator.AddColumnToRelationMap(catalog_table, column_index);
 		bindings.insert(relation_mapping[colref.binding.table_index]);
 	}
 	if (expression.type == ExpressionType::BOUND_REF) {
@@ -145145,6 +145655,39 @@ bool JoinOrderOptimizer::ExtractBindings(Expression &expression, unordered_set<i
 	return can_reorder;
 }
 
+void JoinOrderOptimizer::GetColumnBindings(Expression &expression, ColumnBinding &left_binding,
+                                           ColumnBinding &right_binding) {
+	if (expression.type == ExpressionType::COMPARE_EQUAL) {
+		auto &colref = (BoundComparisonExpression &)expression;
+		if (colref.right->type == ExpressionType::BOUND_COLUMN_REF &&
+		    colref.left->type == ExpressionType::BOUND_COLUMN_REF) {
+			auto &right = (BoundColumnRefExpression &)*colref.right;
+			auto &left = (BoundColumnRefExpression &)*colref.left;
+			D_ASSERT(relation_mapping.find(left.binding.table_index) != relation_mapping.end());
+			D_ASSERT(relation_mapping.find(right.binding.table_index) != relation_mapping.end());
+			left_binding = ColumnBinding(relation_mapping[left.binding.table_index], left.binding.column_index);
+			right_binding = ColumnBinding(relation_mapping[right.binding.table_index], right.binding.column_index);
+			return;
+		}
+	} else if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
+		// Here you have a filter on a single column in a table. Return a binding for the column
+		// being filtered on so the filter estimator knows what HLL count to pull
+		auto &colref = (BoundColumnRefExpression &)expression;
+		D_ASSERT(colref.depth == 0);
+		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
+		// map the base table index to the relation index used by the JoinOrderOptimizer
+		D_ASSERT(relation_mapping.find(colref.binding.table_index) != relation_mapping.end());
+		left_binding = ColumnBinding(relation_mapping[colref.binding.table_index], colref.binding.column_index);
+		return;
+	}
+	// TODO: handle inequality filters with functions.
+	// TODO: Don't overwrite the right binding. This fails silently right now
+	//  When enumerating the children, it's possible you overwrite the left_binding
+	//  if the right child is an expression with more children than the left child.
+	ExpressionIterator::EnumerateChildren(
+	    expression, [&](Expression &expr) { GetColumnBindings(expr, left_binding, right_binding); });
+}
+
 static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node, unique_ptr<Expression> expr) {
 	// push an expression into a filter
 	// first check if we have any filter to push it into
@@ -145220,9 +145763,18 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		// e.g. suppose we have (left LEFT OUTER JOIN right WHERE right IS NOT NULL), the join can generate
 		// new NULL values in the right side, so pushing this condition through the join leads to incorrect results
 		// for this reason, we just start a new JoinOptimizer pass in each of the children of the join
+
+		// Keep track of all of the filter bindings the new join order optimizer makes
+		vector<column_binding_map_t<ColumnBinding>> child_binding_maps;
+		idx_t child_bindings_it = 0;
 		for (auto &child : op->children) {
+			child_binding_maps.emplace_back(column_binding_map_t<ColumnBinding>());
 			JoinOrderOptimizer optimizer(context);
 			child = optimizer.Optimize(move(child));
+			// save the relation bindings from the optimized child. These later all get added to the
+			// parent cardinality_estimator relation column binding map.
+			optimizer.cardinality_estimator.CopyRelationMap(child_binding_maps.at(child_bindings_it));
+			child_bindings_it += 1;
 		}
 		// after this we want to treat this node as one  "end node" (like e.g. a base relation)
 		// however the join refers to multiple base relations
@@ -145233,8 +145785,11 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		LogicalJoin::GetTableReferences(*op, bindings);
 		// now create the relation that refers to all these bindings
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
+		auto relation_id = relations.size();
+		// Add binding information from the nonreorderable join to this relation.
 		for (idx_t it : bindings) {
-			relation_mapping[it] = relations.size();
+			cardinality_estimator.MergeBindings(it, relation_id, child_binding_maps);
+			relation_mapping[it] = relation_id;
 		}
 		relations.push_back(move(relation));
 		return true;
@@ -145249,14 +145804,21 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		// base table scan, add to set of relations
 		auto get = (LogicalGet *)op;
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[get->table_index] = relations.size();
+		idx_t relation_id = relations.size();
+		//! make sure the optimizer has knowledge of the exact column bindings as well.
+		auto table_index = get->table_index;
+		relation_mapping[table_index] = relation_id;
+		cardinality_estimator.AddRelationColumnMapping(get, relation_id);
 		relations.push_back(move(relation));
 		return true;
 	} else if (op->type == LogicalOperatorType::LOGICAL_EXPRESSION_GET) {
 		// base table scan, add to set of relations
 		auto get = (LogicalExpressionGet *)op;
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[get->table_index] = relations.size();
+		idx_t relation_id = relations.size();
+		//! make sure the optimizer has knowledge of the exact column bindings as well.
+		auto table_index = get->table_index;
+		relation_mapping[table_index] = relation_id;
 		relations.push_back(move(relation));
 		return true;
 	} else if (op->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
@@ -145288,31 +145850,55 @@ static void UpdateExclusionSet(JoinRelationSet *node, unordered_set<idx_t> &excl
 }
 
 //! Create a new JoinTree node by joining together two previous JoinTree nodes
-static unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right) {
+unique_ptr<JoinNode> JoinOrderOptimizer::CreateJoinTree(JoinRelationSet *set,
+                                                        const vector<NeighborInfo *> &possible_connections,
+                                                        JoinNode *left, JoinNode *right) {
 	// for the hash join we want the right side (build side) to have the smallest cardinality
 	// also just a heuristic but for now...
 	// FIXME: we should probably actually benchmark that as well
 	// FIXME: should consider different join algorithms, should we pick a join algorithm here as well? (probably)
-	if (left->cardinality < right->cardinality) {
-		return CreateJoinTree(set, info, right, left);
-	}
-	// the expected cardinality is the max of the child cardinalities
-	// FIXME: we should obviously use better cardinality estimation here
-	// but for now we just assume foreign key joins only
-	idx_t expected_cardinality;
-	if (info->filters.empty()) {
+	double expected_cardinality;
+	NeighborInfo *best_connection = nullptr;
+	auto plan = plans.find(set);
+	// if we have already calculated an expected cardinality for this set,
+	// just re-use that cardinality
+	if (left->GetCardinality() < right->GetCardinality()) {
+		return CreateJoinTree(set, possible_connections, right, left);
+	}
+	if (plan != plans.end()) {
+		expected_cardinality = plan->second->GetCardinality();
+		best_connection = possible_connections.back();
+	} else if (possible_connections.empty()) {
 		// cross product
-		expected_cardinality = left->cardinality * right->cardinality;
+		expected_cardinality = cardinality_estimator.EstimateCrossProduct(left, right);
 	} else {
 		// normal join, expect foreign key join
-		expected_cardinality = MaxValue(left->cardinality, right->cardinality);
+		expected_cardinality = cardinality_estimator.EstimateCardinalityWithSet(set);
+		best_connection = possible_connections.back();
 	}
-	// cost is expected_cardinality plus the cost of the previous plans
-	idx_t cost = expected_cardinality;
-	return make_unique<JoinNode>(set, info, left, right, expected_cardinality, cost);
+
+	auto cost = CardinalityEstimator::ComputeCost(left, right, expected_cardinality);
+	auto result = make_unique<JoinNode>(set, best_connection, left, right, expected_cardinality, cost);
+	D_ASSERT(cost >= expected_cardinality);
+	return result;
 }
 
-JoinNode *JoinOrderOptimizer::EmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info) {
+void JoinOrderOptimizer::UpdateJoinNodesInFullPlan(JoinNode *node) {
+	if (!node) {
+		return;
+	}
+	if (node->set->count == relations.size()) {
+		join_nodes_in_full_plan.clear();
+	}
+	if (node->set->count < relations.size()) {
+		join_nodes_in_full_plan.insert(node);
+	}
+	UpdateJoinNodesInFullPlan(node->left);
+	UpdateJoinNodesInFullPlan(node->right);
+}
+
+JoinNode *JoinOrderOptimizer::EmitPair(JoinRelationSet *left, JoinRelationSet *right,
+                                       const vector<NeighborInfo *> &info) {
 	// get the left and right join plans
 	auto &left_plan = plans[left];
 	auto &right_plan = plans[right];
@@ -145321,18 +145907,45 @@ JoinNode *JoinOrderOptimizer::EmitPair(JoinRelationSet *left, JoinRelationSet *r
 	auto new_plan = CreateJoinTree(new_set, info, left_plan.get(), right_plan.get());
 	// check if this plan is the optimal plan we found for this set of relations
 	auto entry = plans.find(new_set);
-	if (entry == plans.end() || new_plan->cost < entry->second->cost) {
+	if (entry == plans.end() || new_plan->GetCost() < entry->second->GetCost()) {
 		// the plan is the optimal plan, move it into the dynamic programming tree
 		auto result = new_plan.get();
+		//! make sure plans are symmetric for cardinality estimation
+		if (entry != plans.end()) {
+			cardinality_estimator.VerifySymmetry(result, entry->second.get());
+		}
+
+		if (full_plan_found && join_nodes_in_full_plan.count(new_plan.get()) > 0) {
+			must_update_full_plan = true;
+		}
+		if (new_set->count == relations.size()) {
+			full_plan_found = true;
+			// If we find a full plan, we need to keep track of which nodes are in the full plan.
+			// It's possible the DP algorithm updates one of these nodes, then goes on to solve
+			// the order approximately. In the approximate algorithm, it's not guaranteed that the
+			// node references are updated. If the original full plan is determined to still have
+			// the lowest cost, it's possible to get use-after-free errors.
+			// If we know a node in the full plan is updated, we can prevent ourselves from exiting the
+			// DP algorithm until the last plan updated is a full plan
+			UpdateJoinNodesInFullPlan(result);
+			if (must_update_full_plan) {
+				must_update_full_plan = false;
+			}
+		}
+
 		plans[new_set] = move(new_plan);
 		return result;
 	}
 	return entry->second.get();
 }
 
-bool JoinOrderOptimizer::TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, NeighborInfo *info) {
+bool JoinOrderOptimizer::TryEmitPair(JoinRelationSet *left, JoinRelationSet *right,
+                                     const vector<NeighborInfo *> &info) {
 	pairs++;
-	if (pairs >= 2000) {
+	// If a full plan is created, it's possible a node in the plan gets updated. When this happens, make sure you keep
+	// emitting pairs until you emit another final plan. Another final plan is guaranteed to be produced because of
+	// our symmetry guarantees.
+	if (pairs >= 10000 && !must_update_full_plan) {
 		// when the amount of pairs gets too large we exit the dynamic programming and resort to a greedy algorithm
 		// FIXME: simple heuristic currently
 		// at 10K pairs stop searching exactly and switch to heuristic
@@ -145357,15 +145970,19 @@ bool JoinOrderOptimizer::EmitCSG(JoinRelationSet *node) {
 	if (neighbors.empty()) {
 		return true;
 	}
-	// we iterate over the neighbors ordered by their first node
-	sort(neighbors.begin(), neighbors.end());
+
+	//! Neighbors should be reversed when iterating over them.
+	std::sort(neighbors.begin(), neighbors.end(), std::greater_equal<idx_t>());
+	for (idx_t i = 0; i < neighbors.size() - 1; i++) {
+		D_ASSERT(neighbors[i] >= neighbors[i + 1]);
+	}
 	for (auto neighbor : neighbors) {
 		// since the GetNeighbors only returns the smallest element in a list, the entry might not be connected to
 		// (only!) this neighbor,  hence we have to do a connectedness check before we can emit it
 		auto neighbor_relation = set_manager.GetJoinRelation(neighbor);
-		auto connection = query_graph.GetConnection(node, neighbor_relation);
-		if (connection) {
-			if (!TryEmitPair(node, neighbor_relation, connection)) {
+		auto connections = query_graph.GetConnections(node, neighbor_relation);
+		if (!connections.empty()) {
+			if (!TryEmitPair(node, neighbor_relation, connections)) {
 				return false;
 			}
 		}
@@ -145390,9 +146007,9 @@ bool JoinOrderOptimizer::EnumerateCmpRecursive(JoinRelationSet *left, JoinRelati
 		// emit the combinations of this node and its neighbors
 		auto combined_set = set_manager.Union(right, neighbor);
 		if (combined_set->count > right->count && plans.find(combined_set) != plans.end()) {
-			auto connection = query_graph.GetConnection(left, combined_set);
-			if (connection) {
-				if (!TryEmitPair(left, combined_set, connection)) {
+			auto connections = query_graph.GetConnections(left, combined_set);
+			if (!connections.empty()) {
+				if (!TryEmitPair(left, combined_set, connections)) {
 					return false;
 				}
 			}
@@ -145412,12 +146029,11 @@ bool JoinOrderOptimizer::EnumerateCmpRecursive(JoinRelationSet *left, JoinRelati
 }
 
 bool JoinOrderOptimizer::EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set) {
-	// find neighbors of S under the exlusion set
+	// find neighbors of S under the exclusion set
 	auto neighbors = query_graph.GetNeighbors(node, exclusion_set);
 	if (neighbors.empty()) {
 		return true;
 	}
-	// now first emit the connected subgraphs of the neighbors
 	vector<JoinRelationSet *> union_sets;
 	union_sets.resize(neighbors.size());
 	for (idx_t i = 0; i < neighbors.size(); i++) {
@@ -145434,8 +146050,11 @@ bool JoinOrderOptimizer::EnumerateCSGRecursive(JoinRelationSet *node, unordered_
 	// recursively enumerate the sets
 	unordered_set<idx_t> new_exclusion_set = exclusion_set;
 	for (idx_t i = 0; i < neighbors.size(); i++) {
-		// updated the set of excluded entries with this neighbor
+		// Reset the exclusion set so that the algorithm considers all combinations
+		// of the exclusion_set with a subset of neighbors.
+		new_exclusion_set = exclusion_set;
 		new_exclusion_set.insert(neighbors[i]);
+		// updated the set of excluded entries with this neighbor
 		if (!EnumerateCSGRecursive(union_sets[i], new_exclusion_set)) {
 			return false;
 		}
@@ -145466,6 +146085,99 @@ bool JoinOrderOptimizer::SolveJoinOrderExactly() {
 	return true;
 }
 
+static vector<unordered_set<idx_t>> AddSuperSets(vector<unordered_set<idx_t>> current,
+                                                 const vector<idx_t> &all_neighbors) {
+	vector<unordered_set<idx_t>> ret;
+	for (auto &neighbor : all_neighbors) {
+		for (auto &neighbor_set : current) {
+			auto max_val = std::max_element(neighbor_set.begin(), neighbor_set.end());
+			if (*max_val >= neighbor) {
+				continue;
+			}
+			if (neighbor_set.count(neighbor) == 0) {
+				unordered_set<idx_t> new_set;
+				for (auto &n : neighbor_set) {
+					new_set.insert(n);
+				}
+				new_set.insert(neighbor);
+				ret.push_back(new_set);
+			}
+		}
+	}
+	return ret;
+}
+
+// works by first creating all sets with cardinality 1
+// then iterates over each previously create group of subsets and will only add a neighbor if the neighbor
+// is greater than all relations in the set.
+static vector<unordered_set<idx_t>> GetAllNeighborSets(JoinRelationSet *new_set, unordered_set<idx_t> &exclusion_set,
+                                                       vector<idx_t> neighbors) {
+	vector<unordered_set<idx_t>> ret;
+	sort(neighbors.begin(), neighbors.end());
+	vector<unordered_set<idx_t>> added;
+	for (auto &neighbor : neighbors) {
+		added.push_back(unordered_set<idx_t>({neighbor}));
+		ret.push_back(unordered_set<idx_t>({neighbor}));
+	}
+	do {
+		added = AddSuperSets(added, neighbors);
+		for (auto &d : added) {
+			ret.push_back(d);
+		}
+	} while (!added.empty());
+#if DEBUG
+	// drive by test to make sure we have an accurate amount of
+	// subsets, and that each neighbor is in a correct amount
+	// of those subsets.
+	D_ASSERT(ret.size() == pow(2, neighbors.size()) - 1);
+	for (auto &n : neighbors) {
+		idx_t count = 0;
+		for (auto &set : ret) {
+			if (set.count(n) >= 1) {
+				count += 1;
+			}
+		}
+		D_ASSERT(count == pow(2, neighbors.size() - 1));
+	}
+#endif
+	return ret;
+}
+
+void JoinOrderOptimizer::UpdateDPTree(JoinNode *new_plan) {
+	auto new_set = new_plan->set;
+	// now update every plan that uses this plan
+	unordered_set<idx_t> exclusion_set;
+	for (idx_t i = 0; i < new_set->count; i++) {
+		exclusion_set.insert(new_set->relations[i]);
+	}
+	auto neighbors = query_graph.GetNeighbors(new_set, exclusion_set);
+	auto all_neighbors = GetAllNeighborSets(new_set, exclusion_set, neighbors);
+	for (auto neighbor : all_neighbors) {
+		auto neighbor_relation = set_manager.GetJoinRelation(neighbor);
+		auto combined_set = set_manager.Union(new_set, neighbor_relation);
+
+		auto combined_set_plan = plans.find(combined_set);
+		if (combined_set_plan == plans.end()) {
+			continue;
+		}
+
+		double combined_set_plan_cost = combined_set_plan->second->GetCost();
+		auto connections = query_graph.GetConnections(new_set, neighbor_relation);
+		// recurse and update up the tree if the combined set produces a plan with a lower cost
+		// only recurse on neighbor relations that have plans.
+		auto &right_plan = plans[neighbor_relation];
+		if (!right_plan) {
+			continue;
+		}
+		auto updated_plan = EmitPair(new_set, neighbor_relation, connections);
+		// <= because the child node has already been replaced. You need to
+		// replace the parent node as well in this case
+		if (updated_plan->GetCost() < combined_set_plan_cost) {
+			UpdateDPTree(updated_plan);
+		}
+	}
+}
+
 void JoinOrderOptimizer::SolveJoinOrderApproximately() {
 	// at this point, we exited the dynamic programming but did not compute the final join order because it took too
 	// long instead, we use a greedy heuristic to obtain a join ordering now we use Greedy Operator Ordering to
@@ -145485,11 +146197,17 @@ void JoinOrderOptimizer::SolveJoinOrderApproximately() {
 			for (idx_t j = i + 1; j < join_relations.size(); j++) {
 				auto right = join_relations[j];
 				// check if we can connect these two relations
-				auto connection = query_graph.GetConnection(left, right);
-				if (connection) {
-					// we can! check the cost of this connection
+				auto connection = query_graph.GetConnections(left, right);
+				if (!connection.empty()) {
+					// we can check the cost of this connection
 					auto node = EmitPair(left, right, connection);
-					if (!best_connection || node->cost < best_connection->cost) {
+
+					// update the DP tree in case a plan created by the DP algorithm uses the node
+					// that was potentially just updated by EmitPair. You will get a use-after-free
+					// error if future plans rely on the old node that was just replaced.
+					UpdateDPTree(node);
+
+					if (!best_connection || node->GetCost() < best_connection->GetCost()) {
 						// best pair found so far
 						best_connection = node;
 						best_left = i;
@@ -145508,7 +146226,7 @@ void JoinOrderOptimizer::SolveJoinOrderApproximately() {
 				auto current_plan = plans[join_relations[i]].get();
 				// check if the cardinality is smaller than the smallest two found so far
 				for (idx_t j = 0; j < 2; j++) {
-					if (!smallest_plans[j] || smallest_plans[j]->cardinality > current_plan->cardinality) {
+					if (!smallest_plans[j] || smallest_plans[j]->GetCardinality() > current_plan->GetCardinality()) {
 						smallest_plans[j] = current_plan;
 						smallest_index[j] = i;
 						break;
@@ -145525,12 +146243,14 @@ void JoinOrderOptimizer::SolveJoinOrderApproximately() {
 			// create a cross product edge (i.e. edge with empty filter) between these two sets in the query graph
 			query_graph.CreateEdge(left, right, nullptr);
 			// now emit the pair and continue with the algorithm
-			auto connection = query_graph.GetConnection(left, right);
-			D_ASSERT(connection);
+			auto connections = query_graph.GetConnections(left, right);
+			D_ASSERT(!connections.empty());
 
-			best_connection = EmitPair(left, right, connection);
+			best_connection = EmitPair(left, right, connections);
 			best_left = smallest_index[0];
 			best_right = smallest_index[1];
+
+			UpdateDPTree(best_connection);
 			// the code below assumes best_right > best_left
 			if (best_left > best_right) {
 				std::swap(best_left, best_right);
@@ -145632,6 +146352,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 		}
 		left_node = left.first;
 		right_node = right.first;
+		right_node = right.first;
 		result_relation = set_manager.Union(left_node, right_node);
 	} else {
 		// base node, get the entry from the list of extracted relations
@@ -145640,6 +146361,10 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 		result_relation = node->set;
 		result_operator = move(extracted_relations[node->set->relations[0]]);
 	}
+	auto max_idx_t = NumericLimits<idx_t>::Maximum() - 10000;
+	result_operator->estimated_cardinality = MinValue<idx_t>(node->GetCardinality(), max_idx_t);
+	result_operator->has_estimated_cardinality = true;
+	result_operator->estimated_props = node->estimated_props->Copy();
 	// check if we should do a pushdown on this node
 	// basically, any remaining filter that is a subset of the current relation will no longer be used in joins
 	// hence we should push it here
@@ -145813,6 +146538,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		// first extract the relation set for the entire filter
 		unordered_set<idx_t> bindings;
 		ExtractBindings(*filter, bindings);
+		GetColumnBindings(*filter, filter_info->left_binding, filter_info->right_binding);
 		filter_info->set = set_manager.GetJoinRelation(bindings);
 		filter_info->filter_index = i;
 		// now check if it can be used as a join predicate
@@ -145846,10 +146572,17 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 	// First we initialize each of the single-node plans with themselves and with their cardinalities these are the leaf
 	// nodes of the join tree NOTE: we can just use pointers to JoinRelationSet* here because the GetJoinRelation
 	// function ensures that a unique combination of relations will have a unique JoinRelationSet object.
+	vector<NodeOp> nodes_ops;
 	for (idx_t i = 0; i < relations.size(); i++) {
 		auto &rel = *relations[i];
 		auto node = set_manager.GetJoinRelation(i);
-		plans[node] = make_unique<JoinNode>(node, rel.op->EstimateCardinality(context));
+		nodes_ops.emplace_back(NodeOp(make_unique<JoinNode>(node, 0), rel.op));
+	}
+
+	cardinality_estimator.InitCardinalityEstimatorProps(&nodes_ops, &filter_infos);
+
+	for (auto &node_op : nodes_ops) {
+		plans[node_op.node->set] = move(node_op.node);
 	}
 	// now we perform the actual dynamic programming to compute the final result
 	SolveJoinOrder();
@@ -149001,7 +149734,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -149100,7 +149833,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -149144,7 +149877,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -149269,7 +150002,7 @@ class LogMessageFatal : public LogMessage {
 
 
 // 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
 
 /*
@@ -180292,7 +181025,9 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 		for (auto &col_name : columns) {
 			ColumnRefExpression colref(col_name, ref->table->name);
 			auto result = bind_context.BindColumn(colref, 0);
-			D_ASSERT(!result.HasError());
+			if (result.HasError()) {
+				throw BinderException(result.error);
+			}
 			select_list.push_back(move(result.expression));
 		}
 		auto table_scan = CreatePlan(*ref);
@@ -185393,11 +186128,12 @@ namespace duckdb {
 
 const uint64_t PLAN_SERIALIZATION_VERSION = 1;
 
-LogicalOperator::LogicalOperator(LogicalOperatorType type) : type(type) {
+LogicalOperator::LogicalOperator(LogicalOperatorType type)
+    : type(type), estimated_cardinality(0), has_estimated_cardinality(false) {
 }
 
 LogicalOperator::LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions)
-    : type(type), expressions(move(expressions)) {
+    : type(type), expressions(move(expressions)), estimated_cardinality(0), has_estimated_cardinality(false) {
 }
 
 LogicalOperator::~LogicalOperator() {
@@ -185539,10 +186275,14 @@ void LogicalOperator::AddChild(unique_ptr<LogicalOperator> child) {
 
 idx_t LogicalOperator::EstimateCardinality(ClientContext &context) {
 	// simple estimator, just take the max of the children
+	if (has_estimated_cardinality) {
+		return estimated_cardinality;
+	}
 	idx_t max_cardinality = 0;
 	for (auto &child : children) {
 		max_cardinality = MaxValue(child->EstimateCardinality(context), max_cardinality);
 	}
+	has_estimated_cardinality = true;
 	return max_cardinality;
 }
 
@@ -198556,6 +199296,14 @@ void BaseStatistics::Merge(const BaseStatistics &other) {
 	}
 }
 
+idx_t BaseStatistics::GetDistinctCount() {
+	if (distinct_stats) {
+		auto &d_stats = (DistinctStatistics &)*distinct_stats;
+		return d_stats.GetCount();
+	}
+	return 0;
+}
+
 unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type, StatisticsType stats_type) {
 	unique_ptr<BaseStatistics> result;
 	switch (type.InternalType()) {
@@ -207413,7 +208161,7 @@ unique_ptr<StatementVerifier> UnoptimizedStatementVerifier::Create(const SQLStat
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 // Formatting library for C++
@@ -207426,7 +208174,7 @@ unique_ptr<StatementVerifier> UnoptimizedStatementVerifier::Create(const SQLStat
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
 // See the end of this file for a list
 
 // Formatting library for C++ - implementation
@@ -208823,7 +209571,7 @@ FMT_END_NAMESPACE
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #5
 // See the end of this file for a list
 
 /**************************************************************************
@@ -216375,7 +217123,7 @@ mz_bool mz_zip_end(mz_zip_archive *pZip)
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -216407,7 +217155,7 @@ mz_bool mz_zip_end(mz_zip_archive *pZip)
 
 
 // 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 2018 The RE2 Authors.  All Rights Reserved.
@@ -216472,7 +217220,7 @@ class PODArray {
 
 
 // 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 2007 The RE2 Authors.  All Rights Reserved.
@@ -216499,7 +217247,7 @@ class PODArray {
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -216901,7 +217649,7 @@ template<typename Value> bool SparseArray<Value>::less(const IndexValue& a,
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -217943,7 +218691,7 @@ bool Prog::SearchBitState(const StringPiece& text,
 
 
 // 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 2007 The RE2 Authors.  All Rights Reserved.
@@ -217970,7 +218718,7 @@ bool Prog::SearchBitState(const StringPiece& text,
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -219486,7 +220234,7 @@ Prog* Prog::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -219531,7 +220279,7 @@ Prog* Prog::CompileSet(Regexp* re, RE2::Anchor anchor, int64_t max_mem) {
 
 
 // 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 2016 The RE2 Authors.  All Rights Reserved.
@@ -219582,7 +220330,7 @@ class HashMix {
 
 
 // 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 2007 The RE2 Authors.  All Rights Reserved.
@@ -219726,7 +220474,7 @@ class WriterMutexLock {
 
 
 // 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 2016 The RE2 Authors.  All Rights Reserved.
@@ -221802,7 +222550,7 @@ bool Prog::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -221812,7 +222560,7 @@ bool Prog::PossibleMatchRange(std::string* min, std::string* max, int maxlen) {
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -221938,7 +222686,7 @@ class FilteredRE2 {
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -222056,7 +222804,7 @@ class Prefilter {
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -222316,7 +223064,7 @@ void FilteredRE2::PrintPrefilter(int regexpid) {
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -222512,7 +223260,7 @@ static bool CanBeEmptyString(Regexp* re) {
 
 
 // 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 2006-2007 The RE2 Authors.  All Rights Reserved.
@@ -223235,7 +223983,7 @@ void Prog::Fanout(SparseArray<int>* fanout) {
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -223819,7 +224567,7 @@ fail:
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -223859,7 +224607,7 @@ fail:
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -223947,7 +224695,7 @@ extern Rune ApplyFold(const CaseFold *f, Rune r);
 
 
 // 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 2008 The RE2 Authors.  All Rights Reserved.
@@ -226455,7 +227203,7 @@ Regexp* Regexp::Parse(const StringPiece& s, ParseFlags global_flags,
 
 
 // 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
 
 // GENERATED BY make_perl_groups.pl; DO NOT EDIT.
@@ -226583,7 +227331,7 @@ const int num_posix_groups = 28;
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -227284,7 +228032,7 @@ Prefilter* Prefilter::FromRE2(const RE2* re2) {
 
 
 // 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 2009 The RE2 Authors.  All Rights Reserved.
@@ -227695,7 +228443,7 @@ std::string PrefilterTree::DebugNodeString(Prefilter* node) const {
 
 
 // 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 2007 The RE2 Authors.  All Rights Reserved.
@@ -227719,7 +228467,7 @@ std::string PrefilterTree::DebugNodeString(Prefilter* node) const {
 
 
 // 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 2016 The RE2 Authors.  All Rights Reserved.
@@ -228745,7 +229493,7 @@ void Prog::ComputeHints(std::vector<Inst>* flat, int begin, int end) {
 
 
 // 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.
@@ -229989,7 +230737,7 @@ DEFINE_INTEGER_PARSER(ulonglong)
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -230969,7 +231717,7 @@ CharClass* CharClassBuilder::GetCharClass() {
 
 
 // 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 2010 The RE2 Authors.  All Rights Reserved.
@@ -230979,7 +231727,7 @@ CharClass* CharClassBuilder::GetCharClass() {
 
 
 // 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 2010 The RE2 Authors.  All Rights Reserved.
@@ -231220,7 +231968,7 @@ bool RE2::Set::Match(const StringPiece& text, std::vector<int>* v,
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -231885,7 +232633,7 @@ Regexp* SimplifyWalker::SimplifyCharClass(Regexp* re) {
 
 
 // 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 2004 The RE2 Authors.  All Rights Reserved.
@@ -231959,7 +232707,7 @@ std::ostream& operator<<(std::ostream& o, const StringPiece& p) {
 
 
 // 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 2006 The RE2 Authors.  All Rights Reserved.
@@ -232317,7 +233065,7 @@ static void AppendCCRange(std::string* t, Rune lo, Rune hi) {
 
 
 // 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
 
 
@@ -232893,7 +233641,7 @@ const int num_unicode_tolower = 194;
 
 
 // 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
 
 
@@ -238961,7 +239709,7 @@ const int num_unicode_groups = 184;
 
 
 // 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
 
 /*
@@ -239230,7 +239978,7 @@ utfrune(const char *s, Rune c)
 
 
 // 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 1999-2005 The RE2 Authors.  All Rights Reserved.
@@ -239403,7 +240151,7 @@ void StringAppendF(std::string* dst, const char* format, ...) {
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
 // See the end of this file for a list
 
 /* hyperloglog.c - Redis HyperLogLog probabilistic cardinality approximation.
@@ -239444,7 +240192,7 @@ void StringAppendF(std::string* dst, const char* format, ...) {
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
 // See the end of this file for a list
 
 /* SDSLib 2.0 -- A C dynamic strings library
@@ -240991,7 +241739,7 @@ void AddToSingleLogInternal(UnifiedVectorFormat &vdata, idx_t count, uint64_t in
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #7
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #1
 // See the end of this file for a list
 
 /* SDSLib 2.0 -- A C dynamic strings library
@@ -243407,7 +244155,7 @@ void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out) {
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
 // See the end of this file for a list
 
 /* -*- mode: c; c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil -*- */
@@ -243467,7 +244215,7 @@ namespace duckdb {
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
 // See the end of this file for a list
 
 static const utf8proc_uint16_t utf8proc_sequences[] = {
@@ -259121,7 +259869,7 @@ UTF8PROC_DLLEXPORT utf8proc_uint8_t *utf8proc_NFKC_Casefold(const utf8proc_uint8
 
 
 // LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #3
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #4
 // See the end of this file for a list
 
 
@@ -321349,6 +322097,29 @@ bool MbedTlsWrapper::IsValidSha256Signature(const std::string &pubkey, const std
 
 ### THIRD PARTY LICENSE #1 ###
 
+Copyright (c) 2012 Art.sy, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+### THIRD PARTY LICENSE #2 ###
+
 // Copyright (c) 2009 The RE2 Authors. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
@@ -321379,7 +322150,7 @@ bool MbedTlsWrapper::IsValidSha256Signature(const std::string &pubkey, const std
 
 
 
-### THIRD PARTY LICENSE #2 ###
+### THIRD PARTY LICENSE #3 ###
 
 Copyright (c) 2012 - present, Victor Zverovich
 
@@ -321411,7 +322182,7 @@ without including the above copyright and permission notices.
 
 
 
-### THIRD PARTY LICENSE #3 ###
+### THIRD PARTY LICENSE #4 ###
 
 ## utf8proc license ##
 
@@ -321509,7 +322280,7 @@ trademarks mentioned herein are the property of their respective owners.
 
 
 
-### THIRD PARTY LICENSE #4 ###
+### THIRD PARTY LICENSE #5 ###
 
 Copyright 2013-2014 RAD Game Tools and Valve Software
 Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
@@ -321536,7 +322307,7 @@ THE SOFTWARE.
 
 
 
-### THIRD PARTY LICENSE #5 ###
+### THIRD PARTY LICENSE #6 ###
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
@@ -321564,7 +322335,7 @@ DEALINGS IN THE SOFTWARE.
 
 
 
-### THIRD PARTY LICENSE #6 ###
+### THIRD PARTY LICENSE #7 ###
 
 Copyright (c) 2014-2017 Melissa O'Neill and PCG Project contributors
 
@@ -321587,29 +322358,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
-### THIRD PARTY LICENSE #7 ###
-
-Copyright (c) 2012 Art.sy, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
 ### THIRD PARTY LICENSE #8 ###
 
                                  Apache License