duckdb 0.3.2-dev788.0 → 0.3.2-dev841.0

package/src/duckdb.cpp

@@ -21139,6 +21139,7 @@ public:
 
 	int64_t GetFileSize(FileHandle &handle) override;
 
+	void Reset(FileHandle &handle) override;
 	bool OnDiskFile(FileHandle &handle) override {
 		return false;
 	};
@@ -21181,6 +21182,10 @@ int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
 	return child_handle->Write(buffer, nr_bytes);
 }
 
+void PipeFileSystem::Reset(FileHandle &handle) {
+	throw InternalException("Cannot reset pipe file system");
+}
+
 int64_t PipeFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
 	auto &pipe = (PipeFile &)handle;
 	return pipe.ReadChunk(buffer, nr_bytes);
@@ -56617,6 +56622,125 @@ string PhysicalTopN::ParamsToString() const {
 
 namespace duckdb {
 
+struct CSVFileHandle {
+public:
+	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p) : file_handle(move(file_handle_p)) {
+		can_seek = file_handle->CanSeek();
+		plain_file_source = file_handle->OnDiskFile() && can_seek;
+		file_size = file_handle->GetFileSize();
+	}
+
+	bool CanSeek() {
+		return can_seek;
+	}
+	void Seek(idx_t position) {
+		if (!can_seek) {
+			throw InternalException("Cannot seek in this file");
+		}
+		file_handle->Seek(position);
+	}
+	idx_t SeekPosition() {
+		if (!can_seek) {
+			throw InternalException("Cannot seek in this file");
+		}
+		return file_handle->SeekPosition();
+	}
+	void Reset() {
+		if (plain_file_source) {
+			file_handle->Reset();
+		} else {
+			if (!reset_enabled) {
+				throw InternalException("Reset called but reset is not enabled for this CSV Handle");
+			}
+			read_position = 0;
+		}
+	}
+	bool PlainFileSource() {
+		return plain_file_source;
+	}
+
+	idx_t FileSize() {
+		return file_size;
+	}
+
+	idx_t Read(void *buffer, idx_t nr_bytes) {
+		if (!plain_file_source) {
+			// not a plain file source: we need to do some bookkeeping around the reset functionality
+			idx_t result_offset = 0;
+			if (read_position < buffer_size) {
+				// we need to read from our cached buffer
+				auto buffer_read_count = MinValue<idx_t>(nr_bytes, buffer_size - read_position);
+				memcpy(buffer, cached_buffer.get() + read_position, buffer_read_count);
+				result_offset += buffer_read_count;
+				read_position += buffer_read_count;
+				if (result_offset == nr_bytes) {
+					return nr_bytes;
+				}
+			} else if (!reset_enabled && cached_buffer) {
+				// reset is disabled but we still have cached data
+				// we can remove any cached data
+				cached_buffer.reset();
+				buffer_size = 0;
+				buffer_capacity = 0;
+				read_position = 0;
+			}
+			// we have data left to read from the file
+			// read directly into the buffer
+			auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+			read_position += bytes_read;
+			if (reset_enabled) {
+				// if reset caching is enabled, we need to cache the bytes that we have read
+				if (buffer_size + bytes_read >= buffer_capacity) {
+					// no space; first enlarge the buffer
+					buffer_capacity = MaxValue<idx_t>(NextPowerOfTwo(buffer_size + bytes_read), buffer_capacity * 2);
+
+					auto new_buffer = unique_ptr<data_t[]>(new data_t[buffer_capacity]);
+					if (buffer_size > 0) {
+						memcpy(new_buffer.get(), cached_buffer.get(), buffer_size);
+					}
+					cached_buffer = move(new_buffer);
+				}
+				memcpy(cached_buffer.get() + buffer_size, (char *)buffer + result_offset, bytes_read);
+				buffer_size += bytes_read;
+			}
+
+			return result_offset + bytes_read;
+		} else {
+			return file_handle->Read(buffer, nr_bytes);
+		}
+	}
+
+	string ReadLine() {
+		string result;
+		char buffer[1];
+		while (true) {
+			idx_t tuples_read = Read(buffer, 1);
+			if (tuples_read == 0 || buffer[0] == '\n') {
+				return result;
+			}
+			if (buffer[0] != '\r') {
+				result += buffer[0];
+			}
+		}
+	}
+
+	void DisableReset() {
+		this->reset_enabled = false;
+	}
+
+private:
+	unique_ptr<FileHandle> file_handle;
+	bool reset_enabled = true;
+	bool can_seek = false;
+	bool plain_file_source = false;
+	idx_t file_size = 0;
+	// reset support
+	unique_ptr<data_t[]> cached_buffer;
+	idx_t read_position = 0;
+	idx_t buffer_size = 0;
+	idx_t buffer_capacity = 0;
+};
+
 void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
 	this->delimiter = StringUtil::Replace(input, "\\t", "\t");
 	this->has_delimiter = true;
@@ -56749,6 +56873,13 @@ BufferedCSVReader::BufferedCSVReader(ClientContext &context, BufferedCSVReaderOp
                         requested_types) {
 }
 
+BufferedCSVReader::~BufferedCSVReader() {
+}
+
+idx_t BufferedCSVReader::GetFileSize() {
+	return file_handle ? file_handle->FileSize() : 0;
+}
+
 void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
 	PrepareComplexParser();
 	if (options.auto_detect) {
@@ -56765,6 +56896,9 @@ void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
 		SkipRowsAndReadHeader(options.skip_rows, options.header);
 	}
 	InitParseChunk(sql_types.size());
+	// we only need reset support during the automatic CSV type detection
+	// since reset support might require caching (in the case of streams), we disable it for the remainder
+	file_handle->DisableReset();
 }
 
 void BufferedCSVReader::PrepareComplexParser() {
@@ -56773,12 +56907,10 @@ void BufferedCSVReader::PrepareComplexParser() {
 	quote_search = TextSearchShiftArray(options.quote);
 }
 
-unique_ptr<FileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions &options) {
-	auto result = fs.OpenFile(options.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
-	                          options.compression, this->opener);
-	plain_file_source = result->OnDiskFile() && result->CanSeek();
-	file_size = result->GetFileSize();
-	return result;
+unique_ptr<CSVFileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions &options) {
+	auto file_handle = fs.OpenFile(options.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
+	                               options.compression, this->opener);
+	return make_unique<CSVFileHandle>(move(file_handle));
 }
 
 // Helper function to generate column names
@@ -56944,7 +57076,7 @@ bool BufferedCSVReader::JumpToNextSample() {
 	// assess if it makes sense to jump, based on size of the first chunk relative to size of the entire file
 	if (sample_chunk_idx == 0) {
 		idx_t bytes_first_chunk = bytes_in_chunk;
-		double chunks_fit = (file_size / (double)bytes_first_chunk);
+		double chunks_fit = (file_handle->FileSize() / (double)bytes_first_chunk);
 		jumping_samples = chunks_fit >= options.sample_chunks;
 
 		// jump back to the beginning
@@ -56959,7 +57091,7 @@ bool BufferedCSVReader::JumpToNextSample() {
 
 	// if we deal with any other sources than plaintext files, jumping_samples can be tricky. In that case
 	// we just read x continuous chunks from the stream TODO: make jumps possible for zipfiles.
-	if (!plain_file_source || !jumping_samples) {
+	if (!file_handle->PlainFileSource() || !jumping_samples) {
 		sample_chunk_idx++;
 		return true;
 	}
@@ -56969,13 +57101,13 @@ bool BufferedCSVReader::JumpToNextSample() {
 	bytes_per_line_avg = ((bytes_per_line_avg * (sample_chunk_idx)) + bytes_per_line) / (sample_chunk_idx + 1);
 
 	// if none of the previous conditions were met, we can jump
-	idx_t partition_size = (idx_t)round(file_size / (double)options.sample_chunks);
+	idx_t partition_size = (idx_t)round(file_handle->FileSize() / (double)options.sample_chunks);
 
 	// calculate offset to end of the current partition
 	int64_t offset = partition_size - bytes_in_chunk - remaining_bytes_in_buffer;
 	auto current_pos = file_handle->SeekPosition();
 
-	if (current_pos + offset < file_size) {
+	if (current_pos + offset < file_handle->FileSize()) {
 		// set position in stream and clear failure bits
 		file_handle->Seek(current_pos + offset);
 
@@ -56986,10 +57118,10 @@ bool BufferedCSVReader::JumpToNextSample() {
 		// seek backwards from the end in last chunk and hope to catch the end of the file
 		// TODO: actually it would be good to make sure that the end of file is being reached, because
 		// messy end-lines are quite common. For this case, however, we first need a skip_end detection anyways.
-		file_handle->Seek(file_size - bytes_in_chunk);
+		file_handle->Seek(file_handle->FileSize() - bytes_in_chunk);
 
 		// estimate linenr
-		linenr = (idx_t)round((file_size - bytes_in_chunk) / bytes_per_line_avg);
+		linenr = (idx_t)round((file_handle->FileSize() - bytes_in_chunk) / bytes_per_line_avg);
 		linenr_estimated = true;
 	}
 
@@ -57143,6 +57275,7 @@ void BufferedCSVReader::DetectDialect(const vector<LogicalType> &requested_types
 
 					JumpToBeginning(original_options.skip_rows);
 					sniffed_column_counts.clear();
+
 					if (!TryParseCSV(ParserMode::SNIFFING_DIALECT)) {
 						continue;
 					}
@@ -88587,9 +88720,9 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind);
 	// generate a random uuid
-	set.AddFunction(
-	    ScalarFunction("gen_random_uuid", {}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind));
+	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
 }
 
 } // namespace duckdb
@@ -91542,7 +91675,7 @@ static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, cons
 		result->csv_reader = make_unique<BufferedCSVReader>(context, bind_data.options, bind_data.sql_types);
 	}
 	bind_data.bytes_read = 0;
-	bind_data.file_size = result->csv_reader->file_size;
+	bind_data.file_size = result->csv_reader->GetFileSize();
 	result->file_index = 1;
 	return move(result);
 }
@@ -98287,8 +98420,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		original_result->error = ex.what();
 		original_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 
 	// check explain, only if q does not already contain EXPLAIN
 	if (original_result->success) {
@@ -98308,8 +98441,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		copied_result->error = ex.what();
 		copied_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	// now execute the deserialized statement
 	try {
 		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false, false);
@@ -98317,8 +98450,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		deserialized_result->error = ex.what();
 		deserialized_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	// now execute the unoptimized statement
 	config.enable_optimizer = false;
 	try {
@@ -98327,8 +98460,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		unoptimized_result->error = ex.what();
 		unoptimized_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	config.enable_optimizer = true;
 
 	if (profiling_is_enabled) {
@@ -112849,7 +112982,10 @@ void ExpressionRewriter::VisitExpression(unique_ptr<Expression> *expression) {
 
 
 
+
+
 #include <functional>
+#include <map>
 
 namespace duckdb {
 
@@ -112887,6 +113023,37 @@ private:
 	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);
+	}
+
 private:
 	vector<unique_ptr<Expression>> remaining_filters;
 
@@ -112895,6 +113062,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;
 };
 
 } // namespace duckdb
@@ -112916,6 +113103,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 using ExpressionValueInformation = FilterCombiner::ExpressionValueInformation;
@@ -112978,6 +113166,7 @@ FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInforma
 }
 
 FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
+	LookUpConjunctions(expr.get());
 	// try to push the filter into the combiner
 	auto result = AddFilter(expr.get());
 	if (result == FilterResult::UNSUPPORTED) {
@@ -113450,6 +113639,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 		}
 	}
 
+	GenerateORFilters(table_filters, column_ids);
+
 	return table_filters;
 }
 
@@ -113887,6 +114078,176 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &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();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -119023,6 +119384,10 @@ FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &
 	// only handle numerics for now
 	switch (left.type.InternalType()) {
 	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32:
@@ -119150,6 +119515,10 @@ namespace duckdb {
 unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value &input) {
 	switch (input.type().InternalType()) {
 	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32:
@@ -149839,7 +150208,7 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 
 namespace duckdb {
 
-ConjunctionOrFilter::ConjunctionOrFilter() : TableFilter(TableFilterType::CONJUNCTION_OR) {
+ConjunctionOrFilter::ConjunctionOrFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_OR) {
 }
 
 FilterPropagateResult ConjunctionOrFilter::CheckStatistics(BaseStatistics &stats) {
@@ -149868,7 +150237,7 @@ string ConjunctionOrFilter::ToString(const string &column_name) {
 }
 
 bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
+	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
 	auto &other = (ConjunctionOrFilter &)other_p;
@@ -149883,11 +150252,11 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	return true;
 }
 
-ConjunctionAndFilter::ConjunctionAndFilter() : TableFilter(TableFilterType::CONJUNCTION_AND) {
+ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
 }
 
 FilterPropagateResult ConjunctionAndFilter::CheckStatistics(BaseStatistics &stats) {
-	// the OR filter is true if ALL of the children is true
+	// the AND filter is true if ALL of the children is true
 	D_ASSERT(!child_filters.empty());
 	auto result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
 	for (auto &filter : child_filters) {
@@ -149913,7 +150282,7 @@ string ConjunctionAndFilter::ToString(const string &column_name) {
 }
 
 bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
+	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
 	auto &other = (ConjunctionAndFilter &)other_p;
@@ -160130,6 +160499,14 @@ FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
+	case ExpressionType::COMPARE_NOTEQUAL:
+		if (constant < min || constant > max) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		} else if (min == max && min == constant) {
+			// corner case of a cluster with one numeric equal to the target constant
+			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
+		}
+		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 		// X >= C
 		// this can be true only if max(X) >= C
@@ -160326,7 +160703,6 @@ unique_ptr<BaseStatistics> StringStatistics::Copy() {
 	memcpy(stats->max, max, MAX_STRING_MINMAX_SIZE);
 	stats->has_unicode = has_unicode;
 	stats->max_string_length = max_string_length;
-	stats->max_string_length = max_string_length;
 	if (validity_stats) {
 		stats->validity_stats = validity_stats->Copy();
 	}
@@ -160430,6 +160806,11 @@ FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_t
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
+	case ExpressionType::COMPARE_NOTEQUAL:
+		if (min_comp < 0 || max_comp > 0) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		}
+		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 	case ExpressionType::COMPARE_GREATERTHAN:
 		if (max_comp <= 0) {
@@ -162553,6 +162934,16 @@ static void FilterSelectionSwitch(T *vec, T *predicate, SelectionVector &sel, id
 		}
 		break;
 	}
+	case ExpressionType::COMPARE_NOTEQUAL: {
+		if (mask.AllValid()) {
+			approved_tuple_count =
+			    TemplatedFilterSelection<T, NotEquals, false>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
+		} else {
+			approved_tuple_count =
+			    TemplatedFilterSelection<T, NotEquals, true>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
+		}
+		break;
+	}
 	case ExpressionType::COMPARE_LESSTHAN: {
 		if (mask.AllValid()) {
 			approved_tuple_count =
@@ -162622,15 +163013,44 @@ static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t approved_tuple_c
 	}
 }
 
-void ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
-                                    idx_t &approved_tuple_count, ValidityMask &mask) {
+idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
+                                     idx_t &approved_tuple_count, ValidityMask &mask) {
 	switch (filter.filter_type) {
+	case TableFilterType::CONJUNCTION_OR: {
+		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
+		idx_t count_total = 0;
+		SelectionVector result_sel(approved_tuple_count);
+		auto &conjunction_or = (ConjunctionOrFilter &)filter;
+		for (auto &child_filter : conjunction_or.child_filters) {
+			SelectionVector temp_sel;
+			temp_sel.Initialize(sel);
+			idx_t temp_tuple_count = approved_tuple_count;
+			idx_t temp_count = FilterSelection(temp_sel, result, *child_filter, temp_tuple_count, mask);
+			// tuples passed, move them into the actual result vector
+			for (idx_t i = 0; i < temp_count; i++) {
+				auto new_idx = temp_sel.get_index(i);
+				bool is_new_idx = true;
+				for (idx_t res_idx = 0; res_idx < count_total; res_idx++) {
+					if (result_sel.get_index(res_idx) == new_idx) {
+						is_new_idx = false;
+						break;
+					}
+				}
+				if (is_new_idx) {
+					result_sel.set_index(count_total++, new_idx);
+				}
+			}
+		}
+		sel.Initialize(result_sel);
+		approved_tuple_count = count_total;
+		return approved_tuple_count;
+	}
 	case TableFilterType::CONJUNCTION_AND: {
 		auto &conjunction_and = (ConjunctionAndFilter &)filter;
 		for (auto &child_filter : conjunction_and.child_filters) {
 			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
 		}
-		break;
+		return approved_tuple_count;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
 		auto &constant_filter = (ConstantFilter &)filter;
@@ -162743,14 +163163,12 @@ void ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		default:
 			throw InvalidTypeException(result.GetType(), "Invalid type for filter pushed down to table comparison");
 		}
-		break;
+		return approved_tuple_count;
 	}
 	case TableFilterType::IS_NULL:
-		TemplatedNullSelection<true>(sel, approved_tuple_count, mask);
-		break;
+		return TemplatedNullSelection<true>(sel, approved_tuple_count, mask);
 	case TableFilterType::IS_NOT_NULL:
-		TemplatedNullSelection<false>(sel, approved_tuple_count, mask);
-		break;
+		return TemplatedNullSelection<false>(sel, approved_tuple_count, mask);
 	default:
 		throw InternalException("FIXME: unsupported type for filter selection");
 	}