duckdb 0.3.5-dev593.0 → 0.3.5-dev604.0

package/src/duckdb.cpp

@@ -4681,6 +4681,7 @@ CatalogEntry *CatalogSet::CreateEntryInternal(ClientContext &context, unique_ptr
 	auto entry_index = current_entry++;
 	auto catalog_entry = entry.get();
 
+	entry->set = this;
 	entry->timestamp = 0;
 
 	PutMapping(context, name, entry_index);
@@ -5376,6 +5377,9 @@ void DependencyManager::AddObject(ClientContext &context, CatalogEntry *object,
 	for (auto &dependency : dependencies) {
 		idx_t entry_index;
 		CatalogEntry *catalog_entry;
+		if (!dependency->set) {
+			throw InternalException("Dependency has no set");
+		}
 		if (!dependency->set->GetEntryInternal(context, dependency->name, entry_index, catalog_entry)) {
 			throw InternalException("Dependency has already been deleted?");
 		}
@@ -38514,11 +38518,39 @@ bool ChunkCollection::Equals(ChunkCollection &other) {
 	if (ColumnCount() != other.ColumnCount()) {
 		return false;
 	}
-	// if count is equal amount of chunks should be equal
+	// first try to compare the results as-is
+	bool compare_equals = true;
 	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
 		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
 			auto lvalue = GetValue(col_idx, row_idx);
 			auto rvalue = other.GetValue(col_idx, row_idx);
+			if (!Value::ValuesAreEqual(lvalue, rvalue)) {
+				compare_equals = false;
+				break;
+			}
+		}
+		if (!compare_equals) {
+			break;
+		}
+	}
+	if (compare_equals) {
+		return true;
+	}
+	// if the results are not equal,
+	// sort both chunk collections to ensure the comparison is not order insensitive
+	vector<OrderType> desc(ColumnCount(), OrderType::DESCENDING);
+	vector<OrderByNullType> null_order(ColumnCount(), OrderByNullType::NULLS_FIRST);
+	auto this_order = unique_ptr<idx_t[]>(new idx_t[count]);
+	auto other_order = unique_ptr<idx_t[]>(new idx_t[count]);
+	Sort(desc, null_order, this_order.get());
+	other.Sort(desc, null_order, other_order.get());
+
+	for (idx_t row_idx = 0; row_idx < count; row_idx++) {
+		auto lrow = this_order[row_idx];
+		auto rrow = other_order[row_idx];
+		for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
+			auto lvalue = GetValue(col_idx, lrow);
+			auto rvalue = other.GetValue(col_idx, rrow);
 			if (!Value::ValuesAreEqual(lvalue, rvalue)) {
 				return false;
 			}
@@ -112991,6 +113023,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 struct ActiveQueryContext {
@@ -113698,14 +113731,16 @@ void ClientContext::DisableProfiling() {
 }
 
 struct VerifyStatement {
-	VerifyStatement(unique_ptr<SelectStatement> statement_p, string statement_name_p, bool require_equality = true)
+	VerifyStatement(unique_ptr<SelectStatement> statement_p, string statement_name_p, bool require_equality = true,
+	                bool disable_optimizer = false)
 	    : statement(move(statement_p)), statement_name(move(statement_name_p)), require_equality(require_equality),
-	      select_list(statement->node->GetSelectList()) {
+	      disable_optimizer(disable_optimizer), select_list(statement->node->GetSelectList()) {
 	}
 
 	unique_ptr<SelectStatement> statement;
 	string statement_name;
 	bool require_equality;
+	bool disable_optimizer;
 	const vector<unique_ptr<ParsedExpression>> &select_list;
 };
 
@@ -113733,8 +113768,9 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	BufferedDeserializer source(serializer);
 	auto deserialized_stmt = SelectStatement::Deserialize(source);
 
+	auto query_str = select_stmt->ToString();
 	Parser parser;
-	parser.ParseQuery(select_stmt->ToString());
+	parser.ParseQuery(query_str);
 	D_ASSERT(parser.statements.size() == 1);
 	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
 	auto parsed_statement = move(parser.statements[0]);
@@ -113745,6 +113781,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	verify_statements.emplace_back(move(deserialized_stmt), "Deserialized statement");
 	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(parsed_statement)),
 	                               "Parsed statement", false);
+	verify_statements.emplace_back(unique_ptr_cast<SQLStatement, SelectStatement>(move(unoptimized_stmt)),
+	                               "Unoptimized", true, true);
 
 	// all the statements should be equal
 	for (idx_t i = 1; i < verify_statements.size(); i++) {
@@ -113809,9 +113847,11 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	auto statement_copy_for_explain = select_stmt->Copy();
 
 	// execute the original statement
+	auto optimizer_enabled = config.enable_optimizer;
 	vector<unique_ptr<MaterializedQueryResult>> results;
 	for (idx_t i = 0; i < verify_statements.size(); i++) {
 		interrupted = false;
+		config.enable_optimizer = !verify_statements[i].disable_optimizer;
 		try {
 			auto result = RunStatementInternal(lock, query, move(verify_statements[i].statement), false, false);
 			results.push_back(unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result)));
@@ -113819,6 +113859,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 			results.push_back(make_unique<MaterializedQueryResult>(ex.what()));
 		}
 	}
+	config.enable_optimizer = optimizer_enabled;
 
 	// check explain, only if q does not already contain EXPLAIN
 	if (results[0]->success) {
@@ -113831,8 +113872,6 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 		} // LCOV_EXCL_STOP
 	}
 
-	config.enable_optimizer = true;
-
 	if (profiling_is_enabled) {
 		config.enable_profiler = true;
 	}
@@ -129547,37 +129586,37 @@ private:
 	Expression *GetNode(Expression *expr);
 	idx_t GetEquivalenceSet(Expression *expr);
 	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
-
-	//! Functions used to push and generate OR Filters
-	void LookUpConjunctions(Expression *expr);
-	bool BFSLookUpConjunctions(BoundConjunctionExpression *conjunction);
-	void VerifyOrsToPush(Expression &expr);
-
-	bool UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr);
-	bool UpdateFilterByColumn(BoundColumnRefExpression *column_ref, BoundComparisonExpression *comparison_expr);
-	void GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids);
-
-	template <typename CONJUNCTION_TYPE>
-	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
-		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
-		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
-		last_conj_filter->child_filters.push_back(move(new_filter));
-		last_conj_filter = conj_filter_ptr;
-	}
-
-	template <typename CONJUNCTION_TYPE>
-	unique_ptr<TableFilter> NextConjunctionFilter(BoundConjunctionExpression *conjunction) {
-		unique_ptr<ConjunctionFilter> conj_filter = make_unique<CONJUNCTION_TYPE>();
-		for (auto &expr : conjunction->children) {
-			auto comp_expr = (BoundComparisonExpression *)expr.get();
-			auto &const_expr =
-			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
-			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
-			auto const_filter = make_unique<ConstantFilter>(comp_expr->type, const_value);
-			conj_filter->child_filters.push_back(move(const_filter));
-		}
-		return move(conj_filter);
-	}
+	//
+	//	//! Functions used to push and generate OR Filters
+	//	void LookUpConjunctions(Expression *expr);
+	//	bool BFSLookUpConjunctions(BoundConjunctionExpression *conjunction);
+	//	void VerifyOrsToPush(Expression &expr);
+	//
+	//	bool UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr);
+	//	bool UpdateFilterByColumn(BoundColumnRefExpression *column_ref, BoundComparisonExpression *comparison_expr);
+	//	void GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids);
+	//
+	//	template <typename CONJUNCTION_TYPE>
+	//	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
+	//		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
+	//		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
+	//		last_conj_filter->child_filters.push_back(move(new_filter));
+	//		last_conj_filter = conj_filter_ptr;
+	//	}
+	//
+	//	template <typename CONJUNCTION_TYPE>
+	//	unique_ptr<TableFilter> NextConjunctionFilter(BoundConjunctionExpression *conjunction) {
+	//		unique_ptr<ConjunctionFilter> conj_filter = make_unique<CONJUNCTION_TYPE>();
+	//		for (auto &expr : conjunction->children) {
+	//			auto comp_expr = (BoundComparisonExpression *)expr.get();
+	//			auto &const_expr =
+	//			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
+	//			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
+	//			auto const_filter = make_unique<ConstantFilter>(comp_expr->type, const_value);
+	//			conj_filter->child_filters.push_back(move(const_filter));
+	//		}
+	//		return move(conj_filter);
+	//	}
 
 private:
 	vector<unique_ptr<Expression>> remaining_filters;
@@ -129587,26 +129626,26 @@ private:
 	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
 	unordered_map<idx_t, vector<Expression *>> equivalence_map;
 	idx_t set_index = 0;
-
-	//! Structures used for OR Filters
-
-	struct ConjunctionsToPush {
-		BoundConjunctionExpression *root_or;
-
-		// only preserve AND if there is a single column in the expression
-		bool preserve_and = true;
-
-		// conjunction chain for this column
-		vector<unique_ptr<BoundConjunctionExpression>> conjunctions;
-	};
-
-	expression_map_t<vector<unique_ptr<ConjunctionsToPush>>> map_col_conjunctions;
-	vector<BoundColumnRefExpression *> vec_colref_insertion_order;
-
-	BoundConjunctionExpression *cur_root_or;
-	BoundConjunctionExpression *cur_conjunction;
-
-	BoundColumnRefExpression *cur_colref_to_push;
+	//
+	//	//! Structures used for OR Filters
+	//
+	//	struct ConjunctionsToPush {
+	//		BoundConjunctionExpression *root_or;
+	//
+	//		// only preserve AND if there is a single column in the expression
+	//		bool preserve_and = true;
+	//
+	//		// conjunction chain for this column
+	//		vector<unique_ptr<BoundConjunctionExpression>> conjunctions;
+	//	};
+	//
+	//	expression_map_t<vector<unique_ptr<ConjunctionsToPush>>> map_col_conjunctions;
+	//	vector<BoundColumnRefExpression *> vec_colref_insertion_order;
+	//
+	//	BoundConjunctionExpression *cur_root_or;
+	//	BoundConjunctionExpression *cur_conjunction;
+	//
+	//	BoundColumnRefExpression *cur_colref_to_push;
 };
 
 } // namespace duckdb
@@ -129691,7 +129730,7 @@ FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInforma
 }
 
 FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
-	LookUpConjunctions(expr.get());
+	//	LookUpConjunctions(expr.get());
 	// try to push the filter into the combiner
 	auto result = AddFilter(expr.get());
 	if (result == FilterResult::UNSUPPORTED) {
@@ -130161,7 +130200,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 		}
 	}
 
-	GenerateORFilters(table_filters, column_ids);
+	//	GenerateORFilters(table_filters, column_ids);
 
 	return table_filters;
 }
@@ -130630,176 +130669,176 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left,
 		return InvertValueComparisonResult(CompareValueInformation(right, left));
 	}
 }
-
-void FilterCombiner::LookUpConjunctions(Expression *expr) {
-	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
-		auto root_or_expr = (BoundConjunctionExpression *)expr;
-		for (const auto &entry : map_col_conjunctions) {
-			for (const auto &conjs_to_push : entry.second) {
-				if (conjs_to_push->root_or->Equals(root_or_expr)) {
-					return;
-				}
-			}
-		}
-
-		cur_root_or = root_or_expr;
-		cur_conjunction = root_or_expr;
-		cur_colref_to_push = nullptr;
-		if (!BFSLookUpConjunctions(cur_root_or)) {
-			if (cur_colref_to_push) {
-				auto entry = map_col_conjunctions.find(cur_colref_to_push);
-				auto &vec_conjs_to_push = entry->second;
-				if (vec_conjs_to_push.size() == 1) {
-					map_col_conjunctions.erase(entry);
-					return;
-				}
-				vec_conjs_to_push.pop_back();
-			}
-		}
-		return;
-	}
-
-	// Verify if the expression has a column already pushed down by other OR expression
-	VerifyOrsToPush(*expr);
-}
-
-bool FilterCombiner::BFSLookUpConjunctions(BoundConjunctionExpression *conjunction) {
-	vector<BoundConjunctionExpression *> conjunctions_to_visit;
-
-	for (auto &child : conjunction->children) {
-		switch (child->GetExpressionClass()) {
-		case ExpressionClass::BOUND_CONJUNCTION: {
-			auto child_conjunction = (BoundConjunctionExpression *)child.get();
-			conjunctions_to_visit.emplace_back(child_conjunction);
-			break;
-		}
-		case ExpressionClass::BOUND_COMPARISON: {
-			if (!UpdateConjunctionFilter((BoundComparisonExpression *)child.get())) {
-				return false;
-			}
-			break;
-		}
-		default: {
-			return false;
-		}
-		}
-	}
-
-	for (auto child_conjunction : conjunctions_to_visit) {
-		cur_conjunction = child_conjunction;
-		// traverse child conjuction
-		if (!BFSLookUpConjunctions(child_conjunction)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void FilterCombiner::VerifyOrsToPush(Expression &expr) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto colref = (BoundColumnRefExpression *)&expr;
-		auto entry = map_col_conjunctions.find(colref);
-		if (entry == map_col_conjunctions.end()) {
-			return;
-		}
-		map_col_conjunctions.erase(entry);
-	}
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { VerifyOrsToPush(child); });
-}
-
-bool FilterCombiner::UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr) {
-	bool left_is_scalar = comparison_expr->left->IsFoldable();
-	bool right_is_scalar = comparison_expr->right->IsFoldable();
-
-	Expression *non_scalar_expr;
-	if (left_is_scalar || right_is_scalar) {
-		// only support comparison with scalar
-		non_scalar_expr = left_is_scalar ? comparison_expr->right.get() : comparison_expr->left.get();
-
-		if (non_scalar_expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
-			return UpdateFilterByColumn((BoundColumnRefExpression *)non_scalar_expr, comparison_expr);
-		}
-	}
-
-	return false;
-}
-
-bool FilterCombiner::UpdateFilterByColumn(BoundColumnRefExpression *column_ref,
-                                          BoundComparisonExpression *comparison_expr) {
-	if (cur_colref_to_push == nullptr) {
-		cur_colref_to_push = column_ref;
-
-		auto or_conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-		or_conjunction->children.emplace_back(comparison_expr->Copy());
-
-		unique_ptr<ConjunctionsToPush> conjs_to_push = make_unique<ConjunctionsToPush>();
-		conjs_to_push->conjunctions.emplace_back(move(or_conjunction));
-		conjs_to_push->root_or = cur_root_or;
-
-		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
-		vec_col_conjs.emplace_back(move(conjs_to_push));
-		vec_colref_insertion_order.emplace_back(column_ref);
-		return true;
-	}
-
-	auto entry = map_col_conjunctions.find(cur_colref_to_push);
-	D_ASSERT(entry != map_col_conjunctions.end());
-	auto &conjunctions_to_push = entry->second.back();
-
-	if (!cur_colref_to_push->Equals(column_ref)) {
-		// check for multiple colunms in the same root OR node
-		if (cur_root_or == cur_conjunction) {
-			return false;
-		}
-		// found an AND using a different column, we should stop the look up
-		if (cur_conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-			return false;
-		}
-
-		// found a different column, AND conditions cannot be preserved anymore
-		conjunctions_to_push->preserve_and = false;
-		return true;
-	}
-
-	auto &last_conjunction = conjunctions_to_push->conjunctions.back();
-	if (cur_conjunction->GetExpressionType() == last_conjunction->GetExpressionType()) {
-		last_conjunction->children.emplace_back(comparison_expr->Copy());
-	} else {
-		auto new_conjunction = make_unique<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
-		new_conjunction->children.emplace_back(comparison_expr->Copy());
-		conjunctions_to_push->conjunctions.emplace_back(move(new_conjunction));
-	}
-	return true;
-}
-
-void FilterCombiner::GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids) {
-	for (const auto colref : vec_colref_insertion_order) {
-		auto column_index = column_ids[colref->binding.column_index];
-		if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-			break;
-		}
-
-		for (const auto &conjunctions_to_push : map_col_conjunctions[colref]) {
-			// root OR filter to push into the TableFilter
-			auto root_or_filter = make_unique<ConjunctionOrFilter>();
-			// variable to hold the last conjuntion filter pointer
-			// the next filter will be added into it, i.e., we create a chain of conjunction filters
-			ConjunctionFilter *last_conj_filter = root_or_filter.get();
-
-			for (auto &conjunction : conjunctions_to_push->conjunctions) {
-				if (conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
-				    conjunctions_to_push->preserve_and) {
-					GenerateConjunctionFilter<ConjunctionAndFilter>(conjunction.get(), last_conj_filter);
-				} else {
-					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
-				}
-			}
-			table_filter.PushFilter(column_index, move(root_or_filter));
-		}
-	}
-	map_col_conjunctions.clear();
-	vec_colref_insertion_order.clear();
-}
+//
+// void FilterCombiner::LookUpConjunctions(Expression *expr) {
+//	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
+//		auto root_or_expr = (BoundConjunctionExpression *)expr;
+//		for (const auto &entry : map_col_conjunctions) {
+//			for (const auto &conjs_to_push : entry.second) {
+//				if (conjs_to_push->root_or->Equals(root_or_expr)) {
+//					return;
+//				}
+//			}
+//		}
+//
+//		cur_root_or = root_or_expr;
+//		cur_conjunction = root_or_expr;
+//		cur_colref_to_push = nullptr;
+//		if (!BFSLookUpConjunctions(cur_root_or)) {
+//			if (cur_colref_to_push) {
+//				auto entry = map_col_conjunctions.find(cur_colref_to_push);
+//				auto &vec_conjs_to_push = entry->second;
+//				if (vec_conjs_to_push.size() == 1) {
+//					map_col_conjunctions.erase(entry);
+//					return;
+//				}
+//				vec_conjs_to_push.pop_back();
+//			}
+//		}
+//		return;
+//	}
+//
+//	// Verify if the expression has a column already pushed down by other OR expression
+//	VerifyOrsToPush(*expr);
+//}
+//
+// bool FilterCombiner::BFSLookUpConjunctions(BoundConjunctionExpression *conjunction) {
+//	vector<BoundConjunctionExpression *> conjunctions_to_visit;
+//
+//	for (auto &child : conjunction->children) {
+//		switch (child->GetExpressionClass()) {
+//		case ExpressionClass::BOUND_CONJUNCTION: {
+//			auto child_conjunction = (BoundConjunctionExpression *)child.get();
+//			conjunctions_to_visit.emplace_back(child_conjunction);
+//			break;
+//		}
+//		case ExpressionClass::BOUND_COMPARISON: {
+//			if (!UpdateConjunctionFilter((BoundComparisonExpression *)child.get())) {
+//				return false;
+//			}
+//			break;
+//		}
+//		default: {
+//			return false;
+//		}
+//		}
+//	}
+//
+//	for (auto child_conjunction : conjunctions_to_visit) {
+//		cur_conjunction = child_conjunction;
+//		// traverse child conjuction
+//		if (!BFSLookUpConjunctions(child_conjunction)) {
+//			return false;
+//		}
+//	}
+//	return true;
+//}
+//
+// void FilterCombiner::VerifyOrsToPush(Expression &expr) {
+//	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+//		auto colref = (BoundColumnRefExpression *)&expr;
+//		auto entry = map_col_conjunctions.find(colref);
+//		if (entry == map_col_conjunctions.end()) {
+//			return;
+//		}
+//		map_col_conjunctions.erase(entry);
+//	}
+//	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { VerifyOrsToPush(child); });
+//}
+//
+// bool FilterCombiner::UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr) {
+//	bool left_is_scalar = comparison_expr->left->IsFoldable();
+//	bool right_is_scalar = comparison_expr->right->IsFoldable();
+//
+//	Expression *non_scalar_expr;
+//	if (left_is_scalar || right_is_scalar) {
+//		// only support comparison with scalar
+//		non_scalar_expr = left_is_scalar ? comparison_expr->right.get() : comparison_expr->left.get();
+//
+//		if (non_scalar_expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
+//			return UpdateFilterByColumn((BoundColumnRefExpression *)non_scalar_expr, comparison_expr);
+//		}
+//	}
+//
+//	return false;
+//}
+//
+// bool FilterCombiner::UpdateFilterByColumn(BoundColumnRefExpression *column_ref,
+//                                          BoundComparisonExpression *comparison_expr) {
+//	if (cur_colref_to_push == nullptr) {
+//		cur_colref_to_push = column_ref;
+//
+//		auto or_conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
+//		or_conjunction->children.emplace_back(comparison_expr->Copy());
+//
+//		unique_ptr<ConjunctionsToPush> conjs_to_push = make_unique<ConjunctionsToPush>();
+//		conjs_to_push->conjunctions.emplace_back(move(or_conjunction));
+//		conjs_to_push->root_or = cur_root_or;
+//
+//		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
+//		vec_col_conjs.emplace_back(move(conjs_to_push));
+//		vec_colref_insertion_order.emplace_back(column_ref);
+//		return true;
+//	}
+//
+//	auto entry = map_col_conjunctions.find(cur_colref_to_push);
+//	D_ASSERT(entry != map_col_conjunctions.end());
+//	auto &conjunctions_to_push = entry->second.back();
+//
+//	if (!cur_colref_to_push->Equals(column_ref)) {
+//		// check for multiple colunms in the same root OR node
+//		if (cur_root_or == cur_conjunction) {
+//			return false;
+//		}
+//		// found an AND using a different column, we should stop the look up
+//		if (cur_conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
+//			return false;
+//		}
+//
+//		// found a different column, AND conditions cannot be preserved anymore
+//		conjunctions_to_push->preserve_and = false;
+//		return true;
+//	}
+//
+//	auto &last_conjunction = conjunctions_to_push->conjunctions.back();
+//	if (cur_conjunction->GetExpressionType() == last_conjunction->GetExpressionType()) {
+//		last_conjunction->children.emplace_back(comparison_expr->Copy());
+//	} else {
+//		auto new_conjunction = make_unique<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
+//		new_conjunction->children.emplace_back(comparison_expr->Copy());
+//		conjunctions_to_push->conjunctions.emplace_back(move(new_conjunction));
+//	}
+//	return true;
+//}
+//
+// void FilterCombiner::GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids) {
+//	for (const auto colref : vec_colref_insertion_order) {
+//		auto column_index = column_ids[colref->binding.column_index];
+//		if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
+//			break;
+//		}
+//
+//		for (const auto &conjunctions_to_push : map_col_conjunctions[colref]) {
+//			// root OR filter to push into the TableFilter
+//			auto root_or_filter = make_unique<ConjunctionOrFilter>();
+//			// variable to hold the last conjuntion filter pointer
+//			// the next filter will be added into it, i.e., we create a chain of conjunction filters
+//			ConjunctionFilter *last_conj_filter = root_or_filter.get();
+//
+//			for (auto &conjunction : conjunctions_to_push->conjunctions) {
+//				if (conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
+//				    conjunctions_to_push->preserve_and) {
+//					GenerateConjunctionFilter<ConjunctionAndFilter>(conjunction.get(), last_conj_filter);
+//				} else {
+//					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
+//				}
+//			}
+//			table_filter.PushFilter(column_index, move(root_or_filter));
+//		}
+//	}
+//	map_col_conjunctions.clear();
+//	vec_colref_insertion_order.clear();
+//}
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
@@ -133238,6 +133277,7 @@ private:
 	unique_ptr<BaseStatistics> PropagateExpression(BoundBetweenExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundCaseExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundCastExpression &expr, unique_ptr<Expression> *expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundComparisonExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundConstantExpression &expr, unique_ptr<Expression> *expr_ptr);
@@ -136257,6 +136297,73 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCompar
 
 
 
+
+
+
+
+
+namespace duckdb {
+
+unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundConjunctionExpression &expr,
+                                                                     unique_ptr<Expression> *expr_ptr) {
+	auto is_and = expr.type == ExpressionType::CONJUNCTION_AND;
+	for (idx_t expr_idx = 0; expr_idx < expr.children.size(); expr_idx++) {
+		auto &child = expr.children[expr_idx];
+		auto stats = PropagateExpression(child);
+		if (!child->IsFoldable()) {
+			continue;
+		}
+		// we have a constant in a conjunction
+		// we (1) either prune the child
+		// or (2) replace the entire conjunction with a constant
+		auto constant = ExpressionExecutor::EvaluateScalar(*child);
+		if (constant.IsNull()) {
+			continue;
+		}
+		auto b = BooleanValue::Get(constant);
+		bool prune_child = false;
+		bool constant_value = true;
+		if (b) {
+			// true
+			if (is_and) {
+				// true in and: prune child
+				prune_child = true;
+			} else {
+				// true in OR: replace with TRUE
+				constant_value = true;
+			}
+		} else {
+			// false
+			if (is_and) {
+				// false in AND: replace with FALSE
+				constant_value = false;
+			} else {
+				// false in OR: prune child
+				prune_child = true;
+			}
+		}
+		if (prune_child) {
+			expr.children.erase(expr.children.begin() + expr_idx);
+			expr_idx--;
+			continue;
+		}
+		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(constant_value));
+		return PropagateExpression(*expr_ptr);
+	}
+	if (expr.children.empty()) {
+		// if there are no children left, replace the conjunction with TRUE (for AND) or FALSE (for OR)
+		*expr_ptr = make_unique<BoundConstantExpression>(Value::BOOLEAN(is_and));
+		return PropagateExpression(*expr_ptr);
+	} else if (expr.children.size() == 1) {
+		// if there is one child left, replace the conjunction with that one child
+		*expr_ptr = move(expr.children[0]);
+	}
+	return nullptr;
+}
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -136577,7 +136684,7 @@ bool StatisticsPropagator::ExpressionIsConstant(Expression &expr, const Value &v
 	}
 	auto &bound_constant = (BoundConstantExpression &)expr;
 	D_ASSERT(bound_constant.value.type() == val.type());
-	return bound_constant.value == val;
+	return Value::NotDistinctFrom(bound_constant.value, val);
 }
 
 bool StatisticsPropagator::ExpressionIsConstantOrNull(Expression &expr, const Value &val) {
@@ -137361,6 +137468,8 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(Expression
 		return PropagateExpression((BoundBetweenExpression &)expr, expr_ptr);
 	case ExpressionClass::BOUND_CASE:
 		return PropagateExpression((BoundCaseExpression &)expr, expr_ptr);
+	case ExpressionClass::BOUND_CONJUNCTION:
+		return PropagateExpression((BoundConjunctionExpression &)expr, expr_ptr);
 	case ExpressionClass::BOUND_FUNCTION:
 		return PropagateExpression((BoundFunctionExpression &)expr, expr_ptr);
 	case ExpressionClass::BOUND_CAST: