duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

package/src/duckdb/src/main/query_profiler.cpp

@@ -1,21 +1,23 @@
 #include "duckdb/main/query_profiler.hpp"
-#include "duckdb/common/to_string.hpp"
+
 #include "duckdb/common/fstream.hpp"
+#include "duckdb/common/http_state.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-#include "duckdb/common/http_stats.hpp"
+#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/limits.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/execution/operator/helper/physical_execute.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
-#include <utility>
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+
 #include <algorithm>
+#include <utility>
 
 namespace duckdb {
 
@@ -377,15 +379,15 @@ void QueryProfiler::QueryTreeToStream(std::ostream &ss) const {
 		return;
 	}
 
-	if (context.client_data->http_stats && !context.client_data->http_stats->IsEmpty()) {
+	if (context.client_data->http_state && !context.client_data->http_state->IsEmpty()) {
 		string read =
-		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_received);
+		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_received);
 		string written =
-		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_sent);
-		string head = "#HEAD: " + to_string(context.client_data->http_stats->head_count);
-		string get = "#GET: " + to_string(context.client_data->http_stats->get_count);
-		string put = "#PUT: " + to_string(context.client_data->http_stats->put_count);
-		string post = "#POST: " + to_string(context.client_data->http_stats->post_count);
+		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_sent);
+		string head = "#HEAD: " + to_string(context.client_data->http_state->head_count);
+		string get = "#GET: " + to_string(context.client_data->http_state->get_count);
+		string put = "#PUT: " + to_string(context.client_data->http_state->put_count);
+		string post = "#POST: " + to_string(context.client_data->http_state->post_count);
 
 		constexpr idx_t TOTAL_BOX_WIDTH = 39;
 		ss << "┌─────────────────────────────────────┐\n";

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

@@ -7,15 +7,15 @@
 
 namespace duckdb {
 
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)) {
+ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type)
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_unique<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select));
+	ExplainStatement explain(std::move(select), type);
 	return binder.Bind((SQLStatement &)explain);
 }
 

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

@@ -25,6 +25,7 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/main/relation/join_relation.hpp"
 #include "duckdb/main/relation/value_relation.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 namespace duckdb {
 
@@ -303,8 +304,8 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 	return Query(sql);
 }
 
-unique_ptr<QueryResult> Relation::Explain() {
-	auto explain = make_shared<ExplainRelation>(shared_from_this());
+unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
+	auto explain = make_shared<ExplainRelation>(shared_from_this(), type);
 	return explain->Execute();
 }
 

package/src/duckdb/src/main/settings/settings.cpp

@@ -454,11 +454,15 @@ Value CustomExtensionRepository::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 
 void EnableProgressBarSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.enable_progress_bar = ClientConfig().enable_progress_bar;
 }
 
 void EnableProgressBarSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).enable_progress_bar = input.GetValue<bool>();
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.enable_progress_bar = input.GetValue<bool>();
 }
 
 Value EnableProgressBarSetting::GetSetting(ClientContext &context) {
@@ -469,11 +473,15 @@ Value EnableProgressBarSetting::GetSetting(ClientContext &context) {
 // Enable Progress Bar Print
 //===--------------------------------------------------------------------===//
 void EnableProgressBarPrintSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).print_progress_bar = input.GetValue<bool>();
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.print_progress_bar = input.GetValue<bool>();
 }
 
 void EnableProgressBarPrintSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).print_progress_bar = ClientConfig().print_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.print_progress_bar = ClientConfig().print_progress_bar;
 }
 
 Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
@@ -878,13 +886,17 @@ Value ProfilingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 
 void ProgressBarTimeSetting::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).wait_time = ClientConfig().wait_time;
-	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.wait_time = ClientConfig().wait_time;
+	config.enable_progress_bar = ClientConfig().enable_progress_bar;
 }
 
 void ProgressBarTimeSetting::SetLocal(ClientContext &context, const Value &input) {
-	ClientConfig::GetConfig(context).wait_time = input.GetValue<int32_t>();
-	ClientConfig::GetConfig(context).enable_progress_bar = true;
+	auto &config = ClientConfig::GetConfig(context);
+	ProgressBar::SystemOverrideCheck(config);
+	config.wait_time = input.GetValue<int32_t>();
+	config.enable_progress_bar = true;
 }
 
 Value ProgressBarTimeSetting::GetSetting(ClientContext &context) {

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -57,6 +57,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		analyzer.VisitOperator(*op.children[0]);
 		return;
 	}
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (everything_referenced) {

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

@@ -424,7 +424,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 			parent_expr =
 			    make_unique<BoundColumnRefExpression>(parent_expr->alias, parent_expr->return_type, it->first);
 			parent_cond.comparison =
-			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisionExpression(child_cond.comparison);
+			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisonExpression(child_cond.comparison);
 			break;
 		}
 	}

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

@@ -2,21 +2,18 @@
 
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression/bound_between_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/operator/logical_empty_result.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
 
 namespace duckdb {
 
@@ -604,7 +601,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 
 		// create the ExpressionValueInformation
 		ExpressionValueInformation info;
-		info.comparison_type = left_is_scalar ? FlipComparisionExpression(comparison.type) : comparison.type;
+		info.comparison_type = left_is_scalar ? FlipComparisonExpression(comparison.type) : comparison.type;
 		info.constant = constant_value;
 
 		// get the current bucket of constant values

package/src/duckdb/src/optimizer/filter_pullup.cpp

@@ -14,6 +14,7 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 		return PullupJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
@@ -31,7 +32,8 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 
 unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	auto &join = (LogicalJoin &)*op;
 
 	switch (join.join_type) {

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -23,6 +23,7 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 		return PushdownCrossProduct(std::move(op));
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		return PushdownJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_PROJECTION:
@@ -48,7 +49,8 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	auto &join = (LogicalJoin &)*op;
 	unordered_set<idx_t> left_bindings, right_bindings;
 	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
@@ -105,13 +107,7 @@ void FilterPushdown::GenerateFilters() {
 	});
 }
 
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(std::move(child));
-	}
-	// now push any existing filters
+unique_ptr<LogicalOperator> FilterPushdown::PushFinalFilters(unique_ptr<LogicalOperator> op) {
 	if (filters.empty()) {
 		// no filters to push
 		return op;
@@ -124,6 +120,16 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	return std::move(filter);
 }
 
+unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
+	// unhandled type, first perform filter pushdown in its children
+	for (auto &child : op->children) {
+		FilterPushdown pushdown(optimizer);
+		child = pushdown.Rewrite(std::move(child));
+	}
+	// now push any existing filters
+	return PushFinalFilters(std::move(op));
+}
+
 void FilterPushdown::Filter::ExtractBindings() {
 	bindings.clear();
 	LogicalJoin::GetExpressionBindings(*filter, bindings);

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

@@ -6,24 +6,20 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
+#include <cmath>
+
 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;
-		}
+	if (!op) {
+		return nullptr;
 	}
-	return nullptr;
+	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
+	auto get = (LogicalGet *)op;
+	TableCatalogEntry *entry = get->GetTable();
+	return entry;
 }
 
 // The filter was made on top of a logical sample or other projection,
@@ -45,8 +41,7 @@ void CardinalityEstimator::AddRelationTdom(FilterInfo *filter_info) {
 		}
 	}
 	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));
+	relations_to_tdoms.emplace_back(column_binding_set_t({key}));
 }
 
 bool CardinalityEstimator::SingleColumnFilter(FilterInfo *filter_info) {
@@ -99,7 +94,7 @@ void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector<
 		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.emplace_back(tmp);
 		relations_to_tdoms.back().filters.push_back(filter_info);
 	}
 }
@@ -265,7 +260,7 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set
 			// 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());
+				subgraphs.emplace_back();
 				auto subgraph = &subgraphs.back();
 				subgraph->relations.insert(filter->left_binding.table_index);
 				subgraph->relations.insert(filter->right_binding.table_index);
@@ -304,23 +299,37 @@ static bool IsLogicalFilter(LogicalOperator *op) {
 	return op->type == LogicalOperatorType::LOGICAL_FILTER;
 }
 
-static LogicalGet *GetLogicalGet(LogicalOperator *op) {
+static LogicalGet *GetLogicalGet(LogicalOperator *op, idx_t table_index = DConstants::INVALID_INDEX) {
 	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());
+		get = GetLogicalGet(op->children.at(0).get(), table_index);
 		break;
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		get = GetLogicalGet(op->children.at(0).get());
+		get = GetLogicalGet(op->children.at(0).get(), table_index);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		LogicalComparisonJoin *join = (LogicalComparisonJoin *)op;
+		// We should never be calling GetLogicalGet without a valid table_index.
+		// We are attempting to get the catalog table for a relation (for statistics/cardinality estimation)
+		// A logical join means there is a non-reorderable relation in the join plan. This means we need
+		// to know the exact table index to return.
+		D_ASSERT(table_index != DConstants::INVALID_INDEX);
 		if (join->join_type == JoinType::MARK || join->join_type == JoinType::LEFT) {
 			auto child = join->children.at(0).get();
-			get = GetLogicalGet(child);
+			get = GetLogicalGet(child, table_index);
+			if (get && get->table_index == table_index) {
+				return get;
+			}
+			child = join->children.at(1).get();
+			get = GetLogicalGet(child, table_index);
+			if (get && get->table_index == table_index) {
+				return get;
+			}
 		}
 		break;
 	}
@@ -370,16 +379,20 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> *node_op
 		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.
+				// If a base op is a Logical Comparison join it is probably a left join,
+				// so the cost of the larger table is a fine estimate.
+				// TODO: provide better estimates for cost of mark joins
+				// MARK joins are used for anti and semi joins, so the cost can conceivably be
+				// less than the base table cardinality.
 				join_node->SetCost(join_node->GetBaseTableCardinality());
 			}
+		} else if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+			// AsOf joins have the cardinality of the LHS
+			join_node->SetCost(join_node->GetBaseTableCardinality());
 		}
-		// update cardinality with filters
+		// Total domains can be affected by filters. So we update base table cardinality first
 		EstimateBaseTableCardinality(join_node, op);
+		// Then update total domains.
 		UpdateTotalDomains(join_node, op);
 	}
 
@@ -390,74 +403,84 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> *node_op
 void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *op) {
 	auto relation_id = node->set->relations[0];
 	relation_attributes[relation_id].cardinality = node->GetCardinality<double>();
+	//! Initialize the distinct count for all columns used in joins with the current relation.
+	idx_t distinct_count = node->GetBaseTableCardinality();
 	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;
+	LogicalGet *get = nullptr;
+	bool get_updated = true;
 	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
+		//! for every column used in a filter in the relation, get the distinct count via HLL, or assume it to be
 		//! the cardinality
 		ColumnBinding key = ColumnBinding(relation_id, column);
+		auto actual_binding = relation_column_to_original_column.find(key);
+		// each relation has columns that are either projected or used as filters
+		// In order to get column statistics we need to make sure the actual binding still
+		// refers to the same base table relation, as non-reorderable joins may involve 2+
+		// base table relations and therefore the columns may also refer to 2 different
+		// base table relations
+		if (actual_binding != relation_column_to_original_column.end() &&
+		    (!get || get->table_index != actual_binding->second.table_index)) {
+			get = GetLogicalGet(op, actual_binding->second.table_index);
+			get_updated = true;
+		} else {
+			get_updated = false;
+		}
 
-		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];
+		if (get_updated) {
+			catalog_table = GetCatalogTableEntry(get);
+		}
 
-			auto base_stats = catalog_table->GetStatistics(context, actual_binding.column_index);
+		if (catalog_table && actual_binding != relation_column_to_original_column.end()) {
+			// Get HLL stats here
+			auto base_stats = catalog_table->GetStatistics(context, actual_binding->second.column_index);
 			if (base_stats) {
-				count = base_stats->GetDistinctCount();
+				distinct_count = base_stats->GetDistinctCount();
 			}
 
-			// means you have a direct filter on a column. The count/total domain for the column
+			// means you have a direct filter on a column. The distinct_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<idx_t>();
+				distinct_count = node->GetCardinality<idx_t>();
 			}
 
-			// HLL has estimation error, count can't be greater than cardinality of the table before filters
-			if (count > node->GetBaseTableCardinality()) {
-				count = node->GetBaseTableCardinality();
+			// HLL has estimation error, distinct_count can't be greater than cardinality of the table before filters
+			if (distinct_count > node->GetBaseTableCardinality()) {
+				distinct_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
+			// No HLL. So if we know there is a direct filter, reduce the distinct count to the cardinality
+			// with filter effects. Otherwise assume the distinct count is still the cardinality
 			if (direct_filter) {
-				count = node->GetCardinality<idx_t>();
+				distinct_count = node->GetCardinality<idx_t>();
 			} else {
-				count = node->GetBaseTableCardinality();
+				distinct_count = node->GetBaseTableCardinality();
 			}
 		}
-
+		// Update the relation_to_tdom set with the estimated distinct count (or tdom) calculated above
 		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;
+				if (relation_to_tdom.tdom_hll < distinct_count) {
+					relation_to_tdom.tdom_hll = distinct_count;
 					relation_to_tdom.has_tdom_hll = true;
 				}
-				if (relation_to_tdom.tdom_no_hll > count) {
-					relation_to_tdom.tdom_no_hll = count;
+				if (relation_to_tdom.tdom_no_hll > distinct_count) {
+					relation_to_tdom.tdom_no_hll = distinct_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;
+				if (relation_to_tdom.tdom_no_hll > distinct_count && !relation_to_tdom.has_tdom_hll) {
+					relation_to_tdom.tdom_no_hll = distinct_count;
 				}
 			}
 			break;
@@ -465,9 +488,8 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 	}
 }
 
-TableFilterSet *CardinalityEstimator::GetTableFilters(LogicalOperator *op) {
-	// First check table filters
-	auto get = GetLogicalGet(op);
+TableFilterSet *CardinalityEstimator::GetTableFilters(LogicalOperator *op, idx_t table_index) {
+	auto get = GetLogicalGet(op, table_index);
 	return get ? &get->table_filters : nullptr;
 }
 
@@ -529,9 +551,10 @@ idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column
 	return cardinality_after_filters;
 }
 
-idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters) {
+idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters,
+                                                idx_t table_index) {
 	idx_t cardinality_after_filters = cardinality;
-	auto get = GetLogicalGet(op);
+	auto get = GetLogicalGet(op, table_index);
 	unique_ptr<BaseStatistics> column_statistics;
 	for (auto &it : table_filters->filters) {
 		column_statistics = nullptr;
@@ -562,17 +585,30 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 
 void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op) {
 	auto has_logical_filter = IsLogicalFilter(op);
-	auto table_filters = GetTableFilters(op);
+	D_ASSERT(node->set->count == 1);
+	auto relation_id = node->set->relations[0];
 
-	auto card_after_filters = node->GetBaseTableCardinality();
-	if (table_filters) {
-		double inspect_result = (double)InspectTableFilters(card_after_filters, op, table_filters);
-		card_after_filters = MinValue(inspect_result, (double)card_after_filters);
-	}
-	if (has_logical_filter) {
-		card_after_filters *= DEFAULT_SELECTIVITY;
+	double lowest_card_found = NumericLimits<double>::Maximum();
+	for (auto &column : relation_attributes[relation_id].columns) {
+		auto card_after_filters = node->GetBaseTableCardinality();
+		ColumnBinding key = ColumnBinding(relation_id, column);
+		TableFilterSet *table_filters = nullptr;
+		auto actual_binding = relation_column_to_original_column.find(key);
+		if (actual_binding != relation_column_to_original_column.end()) {
+			table_filters = GetTableFilters(op, actual_binding->second.table_index);
+		}
+
+		if (table_filters) {
+			double inspect_result =
+			    (double)InspectTableFilters(card_after_filters, op, table_filters, actual_binding->second.table_index);
+			card_after_filters = MinValue(inspect_result, (double)card_after_filters);
+		}
+		if (has_logical_filter) {
+			card_after_filters *= DEFAULT_SELECTIVITY;
+		}
+		lowest_card_found = MinValue(card_after_filters, lowest_card_found);
 	}
-	node->SetEstimatedCardinality(card_after_filters);
+	node->SetEstimatedCardinality(lowest_card_found);
 }
 
 } // namespace duckdb