duckdb 1.1.3 → 1.1.4-dev9.0

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_validator.hpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/csv_validator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/map.hpp"
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+//! Information used to validate
+struct ValidatorLine {
+	ValidatorLine(idx_t start_pos_p, idx_t end_pos_p) : start_pos(start_pos_p), end_pos(end_pos_p) {
+	}
+	const idx_t start_pos;
+	const idx_t end_pos;
+};
+
+struct ThreadLines {
+	ThreadLines() {};
+	//! Validate everything is as it should be, returns true if it's all good, false o.w.
+	void Verify() const;
+
+	void Insert(idx_t thread, ValidatorLine line_info);
+
+	string Print() const;
+
+private:
+	map<idx_t, ValidatorLine> thread_lines;
+	//! We allow up to 2 bytes of error margin (basically \r\n)
+	static constexpr idx_t error_margin = 2;
+};
+
+//! The validator works by double-checking that threads started and ended in the right positions
+struct CSVValidator {
+	CSVValidator() {
+	}
+	//! Validate that all files are good
+	void Verify() const;
+
+	//! Inserts line_info to a given thread index of a given file.
+	void Insert(idx_t file_idx, idx_t thread, ValidatorLine line_info);
+
+	string Print(idx_t file_idx) const;
+
+private:
+	//! Per file thread lines.
+	vector<ThreadLines> per_file_thread_lines;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/typedefs.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/function/encoding_function.hpp"
+
+namespace duckdb {
+
+struct DBConfig;
+
+//! Struct that holds encoder buffers
+struct CSVEncoderBuffer {
+	CSVEncoderBuffer() : encoded_buffer_size(0) {};
+	void Initialize(idx_t encoded_buffer_size);
+
+	char *Ptr() const;
+
+	idx_t GetCapacity() const;
+
+	idx_t GetSize() const;
+
+	void SetSize(const idx_t buffer_size);
+
+	bool HasDataToRead() const;
+
+	void Reset();
+	idx_t cur_pos = 0;
+	//! The actual encoded buffer size, from the last file_handle read.
+	idx_t actual_encoded_buffer_size = 0;
+
+private:
+	//! The encoded buffer, we only have one per file, so we cache it and make sure to pass over unused bytes.
+	std::unique_ptr<char[]> encoded_buffer;
+	//! The encoded buffer size is defined as buffer_size/GetRatio()
+	idx_t encoded_buffer_size;
+};
+
+class CSVEncoder {
+public:
+	//! Constructor, basically takes an encoding and the output buffer size
+	CSVEncoder(DBConfig &config, const string &encoding_name, idx_t buffer_size);
+	//! Main encode function, it reads the file into an encoded buffer and converts it to the output buffer
+	idx_t Encode(FileHandle &file_handle_input, char *output_buffer, const idx_t decoded_buffer_size);
+	string encoding_name;
+
+private:
+	//! The actual encoded buffer
+	CSVEncoderBuffer encoded_buffer;
+	//! Potential remaining bytes
+	CSVEncoderBuffer remaining_bytes_buffer;
+	//! Actual Encoding Function
+	optional_ptr<EncodingFunction> encoding_function;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
 #include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_validator.hpp"
 
 namespace duckdb {
 
@@ -22,7 +23,7 @@ namespace duckdb {
 struct CSVGlobalState : public GlobalTableFunctionState {
 	CSVGlobalState(ClientContext &context, const shared_ptr<CSVBufferManager> &buffer_manager_p,
 	               const CSVReaderOptions &options, idx_t system_threads_p, const vector<string> &files,
-	               vector<column_t> column_ids_p, const ReadCSVData &bind_data);
+	               vector<ColumnIndex> column_ids_p, const ReadCSVData &bind_data);
 
 	~CSVGlobalState() override {
 	}
@@ -31,7 +32,7 @@ struct CSVGlobalState : public GlobalTableFunctionState {
 	//! In case it returns a nullptr it means we are done reading these files.
 	unique_ptr<StringValueScanner> Next(optional_ptr<StringValueScanner> previous_scanner);
 
-	void FillRejectsTable();
+	void FillRejectsTable() const;
 
 	void DecrementThread();
 
@@ -58,7 +59,7 @@ private:
 	//! Number of threads being used in this scanner
 	idx_t running_threads = 1;
 	//! The column ids to read
-	vector<column_t> column_ids;
+	vector<ColumnIndex> column_ids;
 
 	string sniffer_mismatch_error;
 
@@ -78,6 +79,8 @@ private:
 	unordered_map<idx_t, idx_t> threads_per_file;
 	//! We hold information on the current scanner boundary
 	CSVIterator current_boundary;
+
+	CSVValidator validator;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp

@@ -27,7 +27,7 @@ namespace duckdb {
 struct CSVBoundary {
 	CSVBoundary(idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos);
 	CSVBoundary();
-	void Print();
+	void Print() const;
 	//! Start Buffer index of the file where we start scanning
 	idx_t buffer_idx = 0;
 	//! Start Buffer position of the buffer of the file where we start scanning
@@ -53,10 +53,10 @@ struct CSVIterator {
 public:
 	CSVIterator();
 
-	void Print();
+	void Print() const;
 	//! Moves the boundary to the next one to be scanned, if there are no next boundaries, it returns False
 	//! Otherwise, if there are boundaries, it returns True
-	bool Next(CSVBufferManager &buffer_manager);
+	bool Next(CSVBufferManager &buffer_manager, const CSVReaderOptions &reader_options);
 	//! If boundary is set
 	bool IsBoundarySet() const;
 
@@ -67,12 +67,20 @@ public:
 
 	void SetCurrentPositionToBoundary();
 
-	void SetCurrentBoundaryToPosition(bool single_threaded);
+	void SetCurrentBoundaryToPosition(bool single_threaded, const CSVReaderOptions &reader_options);
 
 	void SetStart(idx_t pos);
+	void SetEnd(idx_t pos);
 
-	//! 8 MB TODO: Should benchmarks other values
-	static constexpr idx_t BYTES_PER_THREAD = 8000000;
+	// Gets the current position for the file
+	idx_t GetGlobalCurrentPos() const;
+
+	//! Checks if we are done with this iterator
+	void CheckIfDone();
+
+	static idx_t BytesPerThread(const CSVReaderOptions &reader_options);
+
+	static constexpr idx_t ROWS_PER_THREAD = 4;
 
 	CSVPosition pos;
 
@@ -80,6 +88,8 @@ public:
 
 	bool first_one = true;
 
+	idx_t buffer_size;
+
 private:
 	//! The original setting
 	CSVBoundary boundary;

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp

@@ -30,7 +30,7 @@ struct DialectCandidates {
 	explicit DialectCandidates(const CSVStateMachineOptions &options);
 
 	//! Static functions to get defaults of the search space
-	static vector<char> GetDefaultDelimiter();
+	static vector<string> GetDefaultDelimiter();
 
 	static vector<vector<char>> GetDefaultQuote();
 
@@ -43,7 +43,7 @@ struct DialectCandidates {
 	string Print();
 
 	//! Candidates for the delimiter
-	vector<char> delim_candidates;
+	vector<string> delim_candidates;
 	//! Candidates for the comment
 	vector<char> comment_candidates;
 	//! Quote-Rule Candidates
@@ -136,6 +136,8 @@ public:
 	static bool CanYouCastIt(ClientContext &context, const string_t value, const LogicalType &type,
 	                         const DialectOptions &dialect_options, const bool is_null, const char decimal_separator);
 
+	idx_t LinesSniffed() const;
+
 private:
 	//! CSV State Machine Cache
 	CSVStateMachineCache &state_machine_cache;
@@ -151,9 +153,10 @@ private:
 	SetColumns set_columns;
 	shared_ptr<CSVErrorHandler> error_handler;
 	shared_ptr<CSVErrorHandler> detection_error_handler;
-
+	//! Number of lines sniffed in this sniffer
+	idx_t lines_sniffed;
 	//! Sets the result options
-	void SetResultOptions();
+	void SetResultOptions() const;
 
 	//! ------------------------------------------------------//
 	//! ----------------- Dialect Detection ----------------- //
@@ -233,6 +236,8 @@ private:
 	                     unordered_map<idx_t, vector<LogicalType>> &best_sql_types_candidates_per_column_idx,
 	                     CSVReaderOptions &options, CSVErrorHandler &error_handler);
 	vector<string> names;
+	//! If the file only has a header
+	bool single_row_file = false;
 
 	//! ------------------------------------------------------//
 	//! ------------------ Type Replacement ----------------- //

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/state_machine_options.hpp

@@ -15,11 +15,13 @@ namespace duckdb {
 //! Basically which char, quote and escape were used to generate it.
 struct CSVStateMachineOptions {
 	CSVStateMachineOptions() {};
-	CSVStateMachineOptions(char delimiter_p, char quote_p, char escape_p, char comment_p, NewLineIdentifier new_line_p)
-	    : delimiter(delimiter_p), quote(quote_p), escape(escape_p), comment(comment_p), new_line(new_line_p) {};
+	CSVStateMachineOptions(string delimiter_p, char quote_p, char escape_p, char comment_p,
+	                       NewLineIdentifier new_line_p, bool rfc_4180_p)
+	    : delimiter(std::move(delimiter_p)), quote(quote_p), escape(escape_p), comment(comment_p), new_line(new_line_p),
+	      rfc_4180(rfc_4180_p) {};
 
 	//! Delimiter to separate columns within each line
-	CSVOption<char> delimiter = ',';
+	CSVOption<string> delimiter {","};
 	//! Quote used for columns that contain reserved characters, e.g '
 	CSVOption<char> quote = '\"';
 	//! Escape character to escape quote character
@@ -28,10 +30,12 @@ struct CSVStateMachineOptions {
 	CSVOption<char> comment = '\0';
 	//! New Line separator
 	CSVOption<NewLineIdentifier> new_line = NewLineIdentifier::NOT_SET;
+	//! RFC 4180 conformance
+	CSVOption<bool> rfc_4180 = false;
 
 	bool operator==(const CSVStateMachineOptions &other) const {
 		return delimiter == other.delimiter && quote == other.quote && escape == other.escape &&
-		       new_line == other.new_line && comment == other.comment;
+		       new_line == other.new_line && comment == other.comment && rfc_4180 == other.rfc_4180;
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp

@@ -12,7 +12,7 @@
 #include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
 #include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
 #include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
-
+#include "duckdb/execution/operator/csv_scanner/csv_validator.hpp"
 namespace duckdb {
 
 struct CSVBufferUsage {
@@ -96,7 +96,8 @@ public:
 
 class LineError {
 public:
-	explicit LineError(bool ignore_errors_p) : is_error_in_line(false), ignore_errors(ignore_errors_p) {};
+	explicit LineError(const idx_t scan_id_p, const bool ignore_errors_p)
+	    : is_error_in_line(false), ignore_errors(ignore_errors_p), scan_id(scan_id_p) {};
 	//! We clear up our CurrentError Vector
 	void Reset() {
 		current_errors.clear();
@@ -132,10 +133,19 @@ public:
 
 	bool HandleErrors(StringValueResult &result);
 
+	bool HasError() const {
+		return !current_errors.empty();
+	}
+
+	idx_t Size() const {
+		return current_errors.size();
+	}
+
 private:
 	vector<CurrentError> current_errors;
 	bool is_error_in_line;
 	bool ignore_errors;
+	idx_t scan_id;
 };
 
 struct ParseTypeInfo {
@@ -155,13 +165,14 @@ struct ParseTypeInfo {
 	uint8_t scale;
 	uint8_t width;
 };
+
 class StringValueResult : public ScannerResult {
 public:
 	StringValueResult(CSVStates &states, CSVStateMachine &state_machine,
 	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator,
 	                  idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_handler, CSVIterator &iterator,
 	                  bool store_line_size, shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read, bool sniffing,
-	                  string path);
+	                  string path, idx_t scan_id);
 
 	~StringValueResult();
 
@@ -180,6 +191,8 @@ public:
 	const bool null_padding;
 	const bool ignore_errors;
 
+	const idx_t extra_delimiter_bytes = 0;
+
 	unsafe_unique_array<const char *> null_str_ptr;
 	unsafe_unique_array<idx_t> null_str_size;
 	idx_t null_str_count;
@@ -234,6 +247,9 @@ public:
 
 	//! Specialized code for quoted values, makes sure to remove quotes and escapes
 	static inline void AddQuotedValue(StringValueResult &result, const idx_t buffer_pos);
+	//! Specialized code for possibly escaped values, makes sure to remove escapes
+	static inline void AddPossiblyEscapedValue(StringValueResult &result, const idx_t buffer_pos, const char *value_ptr,
+	                                           const idx_t length, const bool empty);
 	//! Adds a Value to the result
 	static inline void AddValue(StringValueResult &result, const idx_t buffer_pos);
 	//! Adds a Row to the result
@@ -246,13 +262,15 @@ public:
 	//! Handles EmptyLine states
 	static inline bool EmptyLine(StringValueResult &result, const idx_t buffer_pos);
 	inline bool AddRowInternal();
-	//! Force the throw of a unicode error
+	//! Force the throw of a Unicode error
 	void HandleUnicodeError(idx_t col_idx, LinePosition &error_position);
 	bool HandleTooManyColumnsError(const char *value_ptr, const idx_t size);
 	inline void AddValueToVector(const char *value_ptr, const idx_t size, bool allocate = false);
 	static inline void SetComment(StringValueResult &result, idx_t buffer_pos);
 	static inline bool UnsetComment(StringValueResult &result, idx_t buffer_pos);
 
+	inline idx_t HandleMultiDelimiter(const idx_t buffer_pos) const;
+
 	DataChunk &ToChunk();
 	//! Resets the state of the result
 	void Reset();
@@ -267,6 +285,18 @@ public:
 	void RemoveLastLine();
 };
 
+struct ValidRowInfo {
+	ValidRowInfo(bool is_valid_p, idx_t start_pos_p, idx_t end_buffer_idx_p, idx_t end_pos_p, bool last_state_quote_p)
+	    : is_valid(is_valid_p), start_pos(start_pos_p), end_buffer_idx(end_buffer_idx_p), end_pos(end_pos_p),
+	      last_state_quote(last_state_quote_p) {};
+	ValidRowInfo() : is_valid(false), start_pos(0), end_buffer_idx(0), end_pos(0) {};
+
+	bool is_valid;
+	idx_t start_pos;
+	idx_t end_buffer_idx;
+	idx_t end_pos;
+	bool last_state_quote = false;
+};
 //! Our dialect scanner basically goes over the CSV and actually parses the values to a DuckDB vector of string_t
 class StringValueScanner : public BaseScanner {
 public:
@@ -292,12 +322,17 @@ public:
 	bool FinishedIterator() const;
 
 	//! Creates a new string with all escaped values removed
-	static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, Vector &vector);
+	static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, char quote, Vector &vector);
 
 	//! If we can directly cast the type when consuming the CSV file, or we have to do it later
 	static bool CanDirectlyCast(const LogicalType &type, bool icu_loaded);
 
+	//! Gets validation line information
+	ValidatorLine GetValidationLine();
+
 	const idx_t scanner_idx;
+	//! We use the max of idx_t to signify this is a line finder scanner.
+	static constexpr idx_t LINE_FINDER_ID = NumericLimits<idx_t>::Maximum();
 
 	//! Variable that manages buffer tracking
 	shared_ptr<CSVBufferUsage> buffer_tracker;
@@ -308,21 +343,31 @@ private:
 	void FinalizeChunkProcess() override;
 
 	//! Function used to process values that go over the first buffer, extra allocation might be necessary
-	void ProcessOverbufferValue();
+	void ProcessOverBufferValue();
 
 	void ProcessExtraRow();
 	//! Function used to move from one buffer to the other, if necessary
 	bool MoveToNextBuffer();
 
-	void SkipUntilNewLine();
-
+	//! -------- Functions used to figure out where lines start ---------!//
+	//! Main function, sets the correct start
 	void SetStart();
+	//! From a given initial state, it skips until we reach the until_state
+	bool SkipUntilState(CSVState initial_state, CSVState until_state, CSVIterator &current_iterator,
+	                    bool &quoted) const;
+	//! If the current row we found is valid
+	bool IsRowValid(CSVIterator &current_iterator) const;
+	ValidRowInfo TryRow(CSVState state, idx_t start_pos, idx_t end_pos) const;
+	bool FirstValueEndsOnQuote(CSVIterator iterator) const;
 
 	StringValueResult result;
 	vector<LogicalType> types;
-
-	//! Pointer to the previous buffer handle, necessary for overbuffer values
+	//! True Position where this scanner started scanning(i.e., after figuring out where the first line starts)
+	idx_t start_pos;
+	//! Pointer to the previous buffer handle, necessary for over-buffer values
 	shared_ptr<CSVBufferHandle> previous_buffer_handle;
+	//! Strict state machine, is basically a state machine with rfc 4180 set to true, used to figure out new line.
+	shared_ptr<CSVStateMachine> state_machine_strict;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp

@@ -30,8 +30,8 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 
-	bool RequiresBatchIndex() const override {
-		return true;
+	OperatorPartitionInfo RequiredPartitionInfo() const override {
+		return OperatorPartitionInfo::BatchIndex();
 	}
 
 	bool ParallelSink() const override {

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_buffered_batch_collector.hpp

@@ -37,8 +37,8 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 
-	bool RequiresBatchIndex() const override {
-		return true;
+	OperatorPartitionInfo RequiredPartitionInfo() const override {
+		return OperatorPartitionInfo::BatchIndex();
 	}
 
 	bool ParallelSink() const override {

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp

@@ -57,8 +57,8 @@ public:
 		return true;
 	}
 
-	bool RequiresBatchIndex() const override {
-		return true;
+	OperatorPartitionInfo RequiredPartitionInfo() const override {
+		return OperatorPartitionInfo::BatchIndex();
 	}
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reservoir_sample.hpp

@@ -41,7 +41,7 @@ public:
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
 	                          OperatorSinkFinalizeInput &input) const override;
 	bool ParallelSink() const override {
-		return true;
+		return !options->repeatable;
 	}
 
 	bool IsSink() const override {

package/src/duckdb/src/include/duckdb/execution/operator/join/join_filter_pushdown.hpp

@@ -8,19 +8,19 @@
 
 #pragma once
 
+#include "duckdb/planner/column_binding.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/table_filter.hpp"
-#include "duckdb/planner/column_binding.hpp"
 
 namespace duckdb {
 class DataChunk;
 class DynamicTableFilterSet;
+class LogicalGet;
+class JoinHashTable;
 struct GlobalUngroupedAggregateState;
 struct LocalUngroupedAggregateState;
 
 struct JoinFilterPushdownColumn {
-	//! The join condition from which this filter pushdown is generated
-	idx_t join_condition;
 	//! The probe column index to which this filter should be applied
 	ColumnBinding probe_column_index;
 };
@@ -39,11 +39,27 @@ struct JoinFilterLocalState {
 	unique_ptr<LocalUngroupedAggregateState> local_aggregate_state;
 };
 
-struct JoinFilterPushdownInfo {
+struct JoinFilterPushdownFilter {
 	//! The dynamic table filter set where to push filters into
 	shared_ptr<DynamicTableFilterSet> dynamic_filters;
-	//! The filters that we should generate
-	vector<JoinFilterPushdownColumn> filters;
+	//! The columns for which we should generate filters
+	vector<JoinFilterPushdownColumn> columns;
+};
+
+struct PushdownFilterTarget {
+	PushdownFilterTarget(LogicalGet &get, vector<JoinFilterPushdownColumn> columns_p)
+	    : get(get), columns(std::move(columns_p)) {
+	}
+
+	LogicalGet &get;
+	vector<JoinFilterPushdownColumn> columns;
+};
+
+struct JoinFilterPushdownInfo {
+	//! The join condition indexes for which we compute the min/max aggregates
+	vector<idx_t> join_condition;
+	//! The probes to push the filter into
+	vector<JoinFilterPushdownFilter> probe_info;
 	//! Min/Max aggregates
 	vector<unique_ptr<Expression>> min_max_aggregates;
 
@@ -53,7 +69,12 @@ public:
 
 	void Sink(DataChunk &chunk, JoinFilterLocalState &lstate) const;
 	void Combine(JoinFilterGlobalState &gstate, JoinFilterLocalState &lstate) const;
-	void PushFilters(JoinFilterGlobalState &gstate, const PhysicalOperator &op) const;
+	unique_ptr<DataChunk> Finalize(ClientContext &context, JoinHashTable &ht, JoinFilterGlobalState &gstate,
+	                               const PhysicalOperator &op) const;
+
+private:
+	void PushInFilter(const JoinFilterPushdownFilter &info, JoinHashTable &ht, const PhysicalOperator &op,
+	                  idx_t filter_idx, idx_t filter_col_idx) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/join/perfect_hash_join_executor.hpp

@@ -22,12 +22,9 @@ class PhysicalHashJoin;
 struct PerfectHashJoinStats {
 	Value build_min;
 	Value build_max;
-	Value probe_min;
-	Value probe_max;
 	bool is_build_small = false;
 	bool is_build_dense = false;
 	idx_t build_range = 0;
-	idx_t estimated_cardinality = 0;
 };
 
 //! PhysicalHashJoin represents a hash loop join between two tables
@@ -35,14 +32,14 @@ class PerfectHashJoinExecutor {
 	using PerfectHashTable = vector<Vector>;
 
 public:
-	explicit PerfectHashJoinExecutor(const PhysicalHashJoin &join, JoinHashTable &ht, PerfectHashJoinStats pjoin_stats);
+	PerfectHashJoinExecutor(const PhysicalHashJoin &join, JoinHashTable &ht);
 
 public:
-	bool CanDoPerfectHashJoin();
+	bool CanDoPerfectHashJoin(const PhysicalHashJoin &op, const Value &min, const Value &max);
 
 	unique_ptr<OperatorState> GetOperatorState(ExecutionContext &context);
-	OperatorResultType ProbePerfectHashTable(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                         OperatorState &state);
+	OperatorResultType ProbePerfectHashTable(ExecutionContext &context, DataChunk &input, DataChunk &lhs_output_columns,
+	                                         DataChunk &chunk, OperatorState &state);
 	bool BuildPerfectHashTable(LogicalType &type);
 
 private:
@@ -64,9 +61,9 @@ private:
 	JoinHashTable &ht;
 	//! Columnar perfect hash table
 	PerfectHashTable perfect_hash_table;
-	//! Build and probe statistics
+	//! Build statistics
 	PerfectHashJoinStats perfect_join_statistics;
-	//! Stores the occurences of each value in the build side
+	//! Stores the occurrences of each value in the build side
 	unsafe_unique_array<bool> bitmap_build_idx;
 	//! Stores the number of unique keys in the build side
 	idx_t unique_keys = 0;