duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/execution/operator/csv_scanner/util/csv_error.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
 #include <sstream>
 
@@ -13,25 +13,10 @@ LinesPerBoundary::LinesPerBoundary(idx_t boundary_idx_p, idx_t lines_in_batch_p)
 CSVErrorHandler::CSVErrorHandler(bool ignore_errors_p) : ignore_errors(ignore_errors_p) {
 }
 
-void CSVErrorHandler::Error(CSVError &csv_error) {
-	LinesPerBoundary mock;
-	Error(mock, csv_error, true);
-}
-void CSVErrorHandler::Error(LinesPerBoundary &error_info, CSVError &csv_error, bool force_error) {
-	if (ignore_errors && !force_error) {
-		lock_guard<mutex> parallel_lock(main_mutex);
-		// We store this error
-		errors.push_back({error_info, csv_error});
-		return;
-	}
-
+void CSVErrorHandler::ThrowError(CSVError csv_error) {
 	std::ostringstream error;
 	if (PrintLineNumber(csv_error)) {
-		error << "CSV Error on Line: " << GetLine(error_info) << std::endl;
-	}
-	{
-		lock_guard<mutex> parallel_lock(main_mutex);
-		got_borked = true;
+		error << "CSV Error on Line: " << GetLine(csv_error.error_info) << std::endl;
 	}
 	error << csv_error.error_message;
 	switch (csv_error.type) {
@@ -46,6 +31,33 @@ void CSVErrorHandler::Error(LinesPerBoundary &error_info, CSVError &csv_error, b
 	}
 }
 
+void CSVErrorHandler::Error(CSVError csv_error, bool force_error) {
+	if ((ignore_errors && !force_error) || (PrintLineNumber(csv_error) && !CanGetLine(csv_error.GetBoundaryIndex()))) {
+		lock_guard<mutex> parallel_lock(main_mutex);
+		// We store this error, we can't throw it now, or we are ignoring it
+		errors[csv_error.error_info].push_back(std::move(csv_error));
+		return;
+	}
+	// Otherwise we can throw directly
+	ThrowError(csv_error);
+}
+
+void CSVErrorHandler::ErrorIfNeeded() {
+	CSVError first_error;
+	{
+		lock_guard<mutex> parallel_lock(main_mutex);
+		if (ignore_errors || errors.empty()) {
+			// Nothing to error
+			return;
+		}
+		first_error = errors.begin()->second[0];
+	}
+
+	if (CanGetLine(first_error.error_info.boundary_idx)) {
+		ThrowError(first_error);
+	}
+}
+
 void CSVErrorHandler::Insert(idx_t boundary_idx, idx_t rows) {
 	lock_guard<mutex> parallel_lock(main_mutex);
 	if (lines_per_batch_map.find(boundary_idx) == lines_per_batch_map.end()) {
@@ -60,12 +72,14 @@ void CSVErrorHandler::NewMaxLineSize(idx_t scan_line_size) {
 	max_line_length = std::max(scan_line_size, max_line_length);
 }
 
-CSVError::CSVError(string error_message_p, CSVErrorType type_p)
-    : error_message(std::move(error_message_p)), type(type_p) {
+CSVError::CSVError(string error_message_p, CSVErrorType type_p, LinesPerBoundary error_info_p)
+    : error_message(std::move(error_message_p)), type(type_p), error_info(error_info_p) {
 }
 
-CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, vector<Value> row_p)
-    : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), row(std::move(row_p)) {
+CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, vector<Value> row_p,
+                   LinesPerBoundary error_info_p)
+    : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), row(std::move(row_p)),
+      error_info(error_info_p) {
 }
 
 CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names) {
@@ -77,7 +91,7 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_
 		}
 	}
 	if (sql_types_per_column.empty()) {
-		return CSVError("", CSVErrorType::COLUMN_NAME_TYPE_MISMATCH);
+		return CSVError("", CSVErrorType::COLUMN_NAME_TYPE_MISMATCH, {});
 	}
 	string exception = "COLUMN_TYPES error: Columns with names: ";
 	for (auto &col : sql_types_per_column) {
@@ -85,28 +99,43 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_
 	}
 	exception.pop_back();
 	exception += " do not exist in the CSV File";
-	return CSVError(exception, CSVErrorType::COLUMN_NAME_TYPE_MISMATCH);
+	return CSVError(exception, CSVErrorType::COLUMN_NAME_TYPE_MISMATCH, {});
 }
 
 CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx,
-                             vector<Value> &row) {
+                             vector<Value> &row, LinesPerBoundary error_info, LogicalTypeId type) {
 	std::ostringstream error;
 	// Which column
 	error << "Error when converting column \"" << column_name << "\"." << std::endl;
 	// What was the cast error
 	error << cast_error << std::endl;
-	error << std::endl;
-	// What were the options
+
+	error << "Column " << column_name << " is being converted as type " << LogicalTypeIdToString(type) << std::endl;
+	if (!options.WasTypeManuallySet(column_idx)) {
+		error << "This type was auto-detected from the CSV file." << std::endl;
+		error << "Possible solutions:" << std::endl;
+		error << "* Override the type for this column manually by setting the type explicitly, e.g. types={'"
+		      << column_name << "': 'VARCHAR'}" << std::endl;
+		error << "* Set the sample size to a larger value to enable the auto-detection to scan more values, e.g. "
+		         "sample_size=-1"
+		      << std::endl;
+		error << "* Use a COPY statement to automatically derive types from an existing table." << std::endl;
+	} else {
+		error << "This type was either manually set or derived from an existing table. Select a different type to "
+		         "correctly parse this column."
+		      << std::endl;
+	}
 	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, row);
+
+	return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, row, error_info);
 }
 
-CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size) {
+CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info) {
 	std::ostringstream error;
 	error << "Maximum line size of " << options.maximum_line_size << " bytes exceeded. ";
 	error << "Actual Size:" << actual_size << " bytes." << std::endl;
 	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE);
+	return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE, error_info);
 }
 
 CSVError CSVError::SniffingError(string &file_path) {
@@ -114,72 +143,91 @@ CSVError CSVError::SniffingError(string &file_path) {
 	// Which column
 	error << "Error when sniffing file \"" << file_path << "\"." << std::endl;
 	error << "CSV options could not be auto-detected. Consider setting parser options manually." << std::endl;
-	return CSVError(error.str(), CSVErrorType::SNIFFING);
+	return CSVError(error.str(), CSVErrorType::SNIFFING, {});
 }
 
-CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options) {
+CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info) {
 	std::ostringstream error;
 	error << " The parallel scanner does not support null_padding in conjunction with quoted new lines. Please "
 	         "disable the parallel csv reader with parallel=false"
 	      << std::endl;
 	// What were the options
 	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE);
+	return CSVError(error.str(), CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE, error_info);
 }
 
 CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, string_t *vector_ptr,
-                                           idx_t vector_line_start, idx_t current_column) {
+                                           idx_t vector_line_start, idx_t current_column, LinesPerBoundary error_info) {
 	std::ostringstream error;
 	error << "Value with unterminated quote found." << std::endl;
 	error << std::endl;
 	// What were the options
 	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES);
+	return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES, error_info);
 }
 
 CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, string_t *vector_ptr,
-                                              idx_t vector_line_start, idx_t actual_columns) {
+                                              idx_t vector_line_start, idx_t actual_columns,
+                                              LinesPerBoundary error_info) {
 	std::ostringstream error;
 	// How many columns were expected and how many were found
 	error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns
 	      << std::endl;
+	error << std::endl << "Possible fixes:" << std::endl;
+	if (!options.null_padding) {
+		error << "* Enable null padding (null_padding=true) to replace missing values with NULL" << std::endl;
+	}
+	if (!options.ignore_errors) {
+		error << "* Enable ignore errors (ignore_errors=true) to skip this row" << std::endl;
+	}
+	error << std::endl;
+	// What were the options
+	error << options.ToString();
+	return CSVError(error.str(), CSVErrorType::INCORRECT_COLUMN_AMOUNT, error_info);
+}
+
+CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, LinesPerBoundary error_info) {
+	std::ostringstream error;
+	// How many columns were expected and how many were found
+	error << "Invalid unicode (byte sequence mismatch) detected." << std::endl;
 	// What were the options
 	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::INCORRECT_COLUMN_AMOUNT);
+	return CSVError(error.str(), CSVErrorType::INVALID_UNICODE, error_info);
 }
 
 bool CSVErrorHandler::PrintLineNumber(CSVError &error) {
+	if (!print_line) {
+		return false;
+	}
 	switch (error.type) {
 	case CSVErrorType::CAST_ERROR:
 	case CSVErrorType::UNTERMINATED_QUOTES:
 	case CSVErrorType::INCORRECT_COLUMN_AMOUNT:
 	case CSVErrorType::MAXIMUM_LINE_SIZE:
 	case CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE:
+	case CSVErrorType::INVALID_UNICODE:
 		return true;
 	default:
 		return false;
 	}
 }
 
-idx_t CSVErrorHandler::GetLine(LinesPerBoundary &error_info) {
-	idx_t current_line = 1 + error_info.lines_in_batch; // We start from one, since the lines are 1-indexed
-	for (idx_t boundary_idx = 0; boundary_idx < error_info.boundary_idx; boundary_idx++) {
-		bool batch_done = false;
-		while (!batch_done) {
-			if (boundary_idx == 0) {
-				// if it's the first boundary, we just return
-				break;
-			}
-			lock_guard<mutex> parallel_lock(main_mutex);
-			if (lines_per_batch_map.find(boundary_idx) != lines_per_batch_map.end()) {
-				batch_done = true;
-				current_line += lines_per_batch_map[boundary_idx].lines_in_batch;
-			}
-			if (got_borked) {
-				return current_line;
-			}
+bool CSVErrorHandler::CanGetLine(idx_t boundary_index) {
+	for (idx_t i = 0; i < boundary_index; i++) {
+		if (lines_per_batch_map.find(i) == lines_per_batch_map.end()) {
+			return false;
 		}
 	}
+	return true;
+}
+
+idx_t CSVErrorHandler::GetLine(const LinesPerBoundary &error_info) {
+	lock_guard<mutex> parallel_lock(main_mutex);
+	// We start from one, since the lines are 1-indexed
+	idx_t current_line = 1 + error_info.lines_in_batch;
+	for (idx_t boundary_idx = 0; boundary_idx < error_info.boundary_idx; boundary_idx++) {
+		current_line += lines_per_batch_map[boundary_idx].lines_in_batch;
+	}
 	return current_line;
 }
 

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/vector_size.hpp"
 #include "duckdb/common/string_util.hpp"
@@ -297,6 +297,13 @@ template <class T>
 string FormatOptionLine(const string &name, const CSVOption<T> option) {
 	return name + " = " + option.FormatValue() + " " + option.FormatSet() + "\n  ";
 }
+bool CSVReaderOptions::WasTypeManuallySet(idx_t i) const {
+	if (i >= was_type_manually_set.size()) {
+		return false;
+	}
+	return was_type_manually_set[i];
+}
+
 string CSVReaderOptions::ToString() const {
 	auto &delimiter = dialect_options.state_machine_options.delimiter;
 	auto &quote = dialect_options.state_machine_options.quote;

package/src/duckdb/src/execution/operator/filter/ub_duckdb_operator_filter.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/execution/operator/filter/physical_filter.cpp>

package/src/duckdb/src/execution/operator/helper/physical_limit.cpp

@@ -8,12 +8,10 @@
 
 namespace duckdb {
 
-PhysicalLimit::PhysicalLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
-                             unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,
+PhysicalLimit::PhysicalLimit(vector<LogicalType> types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
                              idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality), limit_value(limit),
-      offset_value(offset), limit_expression(std::move(limit_expression)),
-      offset_expression(std::move(offset_expression)) {
+    : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality),
+      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
 }
 
 //===--------------------------------------------------------------------===//
@@ -36,13 +34,12 @@ class LimitLocalState : public LocalSinkState {
 public:
 	explicit LimitLocalState(ClientContext &context, const PhysicalLimit &op)
 	    : current_offset(0), data(context, op.types, true) {
-		this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value;
-		this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value;
+		PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset);
 	}
 
 	idx_t current_offset;
-	idx_t limit;
-	idx_t offset;
+	optional_idx limit;
+	optional_idx offset;
 	BatchedDataCollection data;
 };
 
@@ -54,38 +51,56 @@ unique_ptr<LocalSinkState> PhysicalLimit::GetLocalSinkState(ExecutionContext &co
 	return make_uniq<LimitLocalState>(context.client, *this);
 }
 
-bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, idx_t &limit, idx_t &offset,
-                                  idx_t current_offset, idx_t &max_element, Expression *limit_expression,
-                                  Expression *offset_expression) {
-	if (limit != DConstants::INVALID_INDEX && offset != DConstants::INVALID_INDEX) {
-		max_element = limit + offset;
-		if ((limit == 0 || current_offset >= max_element) && !(limit_expression || offset_expression)) {
-			return false;
-		}
+void PhysicalLimit::SetInitialLimits(const BoundLimitNode &limit_val, const BoundLimitNode &offset_val,
+                                     optional_idx &limit, optional_idx &offset) {
+	switch (limit_val.Type()) {
+	case LimitNodeType::CONSTANT_VALUE:
+		limit = limit_val.GetConstantValue();
+		break;
+	case LimitNodeType::UNSET:
+		limit = MAX_LIMIT_VALUE;
+		break;
+	default:
+		break;
 	}
+	switch (offset_val.Type()) {
+	case LimitNodeType::CONSTANT_VALUE:
+		offset = offset_val.GetConstantValue();
+		break;
+	case LimitNodeType::UNSET:
+		offset = 0;
+		break;
+	default:
+		break;
+	}
+}
 
-	// get the next chunk from the child
-	if (limit == DConstants::INVALID_INDEX) {
-		limit = 1ULL << 62ULL;
-		Value val = GetDelimiter(context, input, limit_expression);
+bool PhysicalLimit::ComputeOffset(ExecutionContext &context, DataChunk &input, optional_idx &limit,
+                                  optional_idx &offset, idx_t current_offset, idx_t &max_element,
+                                  const BoundLimitNode &limit_val, const BoundLimitNode &offset_val) {
+	if (!limit.IsValid()) {
+		Value val = GetDelimiter(context, input, limit_val.GetValueExpression());
 		if (!val.IsNull()) {
 			limit = val.GetValue<idx_t>();
+		} else {
+			limit = MAX_LIMIT_VALUE;
 		}
-		if (limit > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit, 1ULL << 62ULL);
+		if (limit.GetIndex() > MAX_LIMIT_VALUE) {
+			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", limit.GetIndex(), MAX_LIMIT_VALUE);
 		}
 	}
-	if (offset == DConstants::INVALID_INDEX) {
-		offset = 0;
-		Value val = GetDelimiter(context, input, offset_expression);
+	if (!offset.IsValid()) {
+		Value val = GetDelimiter(context, input, offset_val.GetValueExpression());
 		if (!val.IsNull()) {
 			offset = val.GetValue<idx_t>();
+		} else {
+			offset = 0;
 		}
-		if (offset > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL);
+		if (offset.GetIndex() > MAX_LIMIT_VALUE) {
+			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), MAX_LIMIT_VALUE);
 		}
 	}
-	max_element = limit + offset;
+	max_element = limit.GetIndex() + offset.GetIndex();
 	if (limit == 0 || current_offset >= max_element) {
 		return false;
 	}
@@ -100,8 +115,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, DataChunk &chunk,
 	auto &offset = state.offset;
 
 	idx_t max_element;
-	if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_expression.get(),
-	                   offset_expression.get())) {
+	if (!ComputeOffset(context, chunk, limit, offset, state.current_offset, max_element, limit_val, offset_val)) {
 		return SinkResultType::FINISHED;
 	}
 	auto max_cardinality = max_element - state.current_offset;
@@ -121,8 +135,12 @@ SinkCombineResultType PhysicalLimit::Combine(ExecutionContext &context, Operator
 	auto &state = input.local_state.Cast<LimitLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
-	gstate.limit = state.limit;
-	gstate.offset = state.offset;
+	if (state.limit.IsValid()) {
+		gstate.limit = state.limit.GetIndex();
+	}
+	if (state.offset.IsValid()) {
+		gstate.offset = state.offset.GetIndex();
+	}
 	gstate.data.Merge(state.data);
 
 	return SinkCombineResultType::FINISHED;
@@ -209,12 +227,12 @@ bool PhysicalLimit::HandleOffset(DataChunk &input, idx_t &current_offset, idx_t
 	return true;
 }
 
-Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, Expression *expr) {
+Value PhysicalLimit::GetDelimiter(ExecutionContext &context, DataChunk &input, const Expression &expr) {
 	DataChunk limit_chunk;
-	vector<LogicalType> types {expr->return_type};
+	vector<LogicalType> types {expr.return_type};
 	auto &allocator = Allocator::Get(context.client);
 	limit_chunk.Initialize(allocator, types);
-	ExpressionExecutor limit_executor(context.client, expr);
+	ExpressionExecutor limit_executor(context.client, &expr);
 	auto input_size = input.size();
 	input.SetCardinality(1);
 	limit_executor.Execute(input, limit_chunk);

package/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp

@@ -7,6 +7,13 @@
 
 namespace duckdb {
 
+PhysicalLimitPercent::PhysicalLimitPercent(vector<LogicalType> types, BoundLimitNode limit_val_p,
+                                           BoundLimitNode offset_val_p, idx_t estimated_cardinality)
+    : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality),
+      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
+	D_ASSERT(limit_val.Type() == LimitNodeType::CONSTANT_PERCENTAGE ||
+	         limit_val.Type() == LimitNodeType::EXPRESSION_PERCENTAGE);
+}
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
@@ -14,28 +21,37 @@ class LimitPercentGlobalState : public GlobalSinkState {
 public:
 	explicit LimitPercentGlobalState(ClientContext &context, const PhysicalLimitPercent &op)
 	    : current_offset(0), data(context, op.GetTypes()) {
-		if (!op.limit_expression) {
-			this->limit_percent = op.limit_percent;
-			is_limit_percent_delimited = true;
-		} else {
-			this->limit_percent = 100.0;
+		switch (op.limit_val.Type()) {
+		case LimitNodeType::CONSTANT_PERCENTAGE:
+			this->limit_percent = op.limit_val.GetConstantPercentage();
+			this->is_limit_set = true;
+			break;
+		case LimitNodeType::EXPRESSION_PERCENTAGE:
+			this->is_limit_set = false;
+			break;
+		default:
+			throw InternalException("Unsupported type for limit value in PhysicalLimitPercent");
 		}
-
-		if (!op.offset_expression) {
-			this->offset = op.offset_value;
-			is_offset_delimited = true;
-		} else {
+		switch (op.offset_val.Type()) {
+		case LimitNodeType::CONSTANT_VALUE:
+			this->offset = op.offset_val.GetConstantValue();
+			break;
+		case LimitNodeType::UNSET:
 			this->offset = 0;
+			break;
+		case LimitNodeType::EXPRESSION_VALUE:
+			break;
+		default:
+			throw InternalException("Unsupported type for offset value in PhysicalLimitPercent");
 		}
 	}
 
 	idx_t current_offset;
 	double limit_percent;
-	idx_t offset;
+	optional_idx offset;
 	ColumnDataCollection data;
 
-	bool is_limit_percent_delimited = false;
-	bool is_offset_delimited = false;
+	bool is_limit_set = false;
 };
 
 unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientContext &context) const {
@@ -49,28 +65,31 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk &
 	auto &offset = state.offset;
 
 	// get the next chunk from the child
-	if (!state.is_limit_percent_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_expression.get());
+	if (!state.is_limit_set) {
+		Value val = PhysicalLimit::GetDelimiter(context, chunk, limit_val.GetPercentageExpression());
 		if (!val.IsNull()) {
 			limit_percent = val.GetValue<double>();
+		} else {
+			limit_percent = 100.0;
 		}
 		if (limit_percent < 0.0) {
 			throw BinderException("Percentage value(%f) can't be negative", limit_percent);
 		}
-		state.is_limit_percent_delimited = true;
+		state.is_limit_set = true;
 	}
-	if (!state.is_offset_delimited) {
-		Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_expression.get());
+	if (!state.offset.IsValid()) {
+		Value val = PhysicalLimit::GetDelimiter(context, chunk, offset_val.GetValueExpression());
 		if (!val.IsNull()) {
 			offset = val.GetValue<idx_t>();
+		} else {
+			offset = 0;
 		}
-		if (offset > 1ULL << 62ULL) {
-			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset, 1ULL << 62ULL);
+		if (offset.GetIndex() > 1ULL << 62ULL) {
+			throw BinderException("Max value %lld for LIMIT/OFFSET is %lld", offset.GetIndex(), 1ULL << 62ULL);
 		}
-		state.is_offset_delimited = true;
 	}
 
-	if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset, DConstants::INVALID_INDEX)) {
+	if (!PhysicalLimit::HandleOffset(chunk, state.current_offset, offset.GetIndex(), NumericLimits<idx_t>::Maximum())) {
 		return SinkResultType::NEED_MORE_INPUT;
 	}
 
@@ -83,15 +102,14 @@ SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, DataChunk &
 //===--------------------------------------------------------------------===//
 class LimitPercentOperatorState : public GlobalSourceState {
 public:
-	explicit LimitPercentOperatorState(const PhysicalLimitPercent &op)
-	    : limit(DConstants::INVALID_INDEX), current_offset(0) {
+	explicit LimitPercentOperatorState(const PhysicalLimitPercent &op) : current_offset(0) {
 		D_ASSERT(op.sink_state);
 		auto &gstate = op.sink_state->Cast<LimitPercentGlobalState>();
 		gstate.data.InitializeScan(scan_state);
 	}
 
 	ColumnDataScanState scan_state;
-	idx_t limit;
+	optional_idx limit;
 	idx_t current_offset;
 };
 
@@ -108,33 +126,39 @@ SourceResultType PhysicalLimitPercent::GetData(ExecutionContext &context, DataCh
 	auto &limit = state.limit;
 	auto &current_offset = state.current_offset;
 
-	if (gstate.is_limit_percent_delimited && limit == DConstants::INVALID_INDEX) {
+	if (!limit.IsValid()) {
+		if (!gstate.is_limit_set) {
+			// no limit value and we have not set limit_percent
+			// we are running LIMIT % with a subquery over an empty table
+			D_ASSERT(gstate.data.Count() == 0);
+			return SourceResultType::FINISHED;
+		}
 		idx_t count = gstate.data.Count();
 		if (count > 0) {
-			count += offset;
+			count += offset.GetIndex();
 		}
 		if (Value::IsNan(percent_limit) || percent_limit < 0 || percent_limit > 100) {
 			throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%");
 		}
-		double limit_dbl = percent_limit / 100 * count;
-		if (limit_dbl > count) {
+		auto limit_percentage = idx_t(percent_limit / 100.0 * double(count));
+		if (limit_percentage > count) {
 			limit = count;
 		} else {
-			limit = idx_t(limit_dbl);
+			limit = idx_t(limit_percentage);
 		}
 		if (limit == 0) {
 			return SourceResultType::FINISHED;
 		}
 	}
 
-	if (current_offset >= limit) {
+	if (current_offset >= limit.GetIndex()) {
 		return SourceResultType::FINISHED;
 	}
 	if (!gstate.data.Scan(state.scan_state, chunk)) {
 		return SourceResultType::FINISHED;
 	}
 
-	PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit);
+	PhysicalLimit::HandleOffset(chunk, current_offset, 0, limit.GetIndex());
 
 	return SourceResultType::HAVE_MORE_OUTPUT;
 }

package/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp

@@ -3,13 +3,10 @@
 
 namespace duckdb {
 
-PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
-                                               unique_ptr<Expression> limit_expression,
-                                               unique_ptr<Expression> offset_expression, idx_t estimated_cardinality,
-                                               bool parallel)
+PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, BoundLimitNode limit_val_p,
+                                               BoundLimitNode offset_val_p, idx_t estimated_cardinality, bool parallel)
     : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, std::move(types), estimated_cardinality),
-      limit_value(limit), offset_value(offset), limit_expression(std::move(limit_expression)),
-      offset_expression(std::move(offset_expression)), parallel(parallel) {
+      limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)), parallel(parallel) {
 }
 
 //===--------------------------------------------------------------------===//
@@ -18,12 +15,11 @@ PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, idx_t
 class StreamingLimitOperatorState : public OperatorState {
 public:
 	explicit StreamingLimitOperatorState(const PhysicalStreamingLimit &op) {
-		this->limit = op.limit_expression ? DConstants::INVALID_INDEX : op.limit_value;
-		this->offset = op.offset_expression ? DConstants::INVALID_INDEX : op.offset_value;
+		PhysicalLimit::SetInitialLimits(op.limit_val, op.offset_val, limit, offset);
 	}
 
-	idx_t limit;
-	idx_t offset;
+	optional_idx limit;
+	optional_idx offset;
 };
 
 class StreamingLimitGlobalState : public GlobalOperatorState {
@@ -50,11 +46,11 @@ OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, Da
 	auto &offset = state.offset;
 	idx_t current_offset = gstate.current_offset.fetch_add(input.size());
 	idx_t max_element;
-	if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element,
-	                                  limit_expression.get(), offset_expression.get())) {
+	if (!PhysicalLimit::ComputeOffset(context, input, limit, offset, current_offset, max_element, limit_val,
+	                                  offset_val)) {
 		return OperatorResultType::FINISHED;
 	}
-	if (PhysicalLimit::HandleOffset(input, current_offset, offset, limit)) {
+	if (PhysicalLimit::HandleOffset(input, current_offset, offset.GetIndex(), limit.GetIndex())) {
 		chunk.Reference(input);
 	}
 	return OperatorResultType::NEED_MORE_INPUT;