duckdb 0.10.2 → 0.10.3-dev10.0

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

@@ -37,9 +37,10 @@ public:
 	bool escaped = false;
 	idx_t quoted_position = 0;
 
+	CSVStateMachine &state_machine;
+
 protected:
 	CSVStates &states;
-	CSVStateMachine &state_machine;
 };
 
 //! This is the base of our CSV scanners.
@@ -51,10 +52,10 @@ public:
 	                     shared_ptr<CSVFileScan> csv_file_scan = nullptr, CSVIterator iterator = {});
 
 	virtual ~BaseScanner() = default;
+
 	//! Returns true if the scanner is finished
 	bool FinishedFile();
-	//! Resets the scanner
-	void Reset();
+
 	//! Parses data into a output_chunk
 	virtual ScannerResult &ParseChunk();
 
@@ -63,6 +64,8 @@ public:
 
 	CSVIterator &GetIterator();
 
+	void SetIterator(const CSVIterator &it);
+
 	idx_t GetBoundaryIndex() {
 		return iterator.GetBoundaryIdx();
 	}
@@ -92,6 +95,10 @@ public:
 
 	bool ever_quoted = false;
 
+	//! Skips Notes and/or parts of the data, starting from the top.
+	//! notes are dirty lines on top of the file, before the actual data
+	void SkipCSVRows(idx_t rows_to_skip);
+
 protected:
 	//! Boundaries of this scanner
 	CSVIterator iterator;

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

@@ -13,6 +13,7 @@
 #include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp"
 #include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
 #include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
 

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

@@ -52,7 +52,7 @@ class CSVError {
 public:
 	CSVError() {};
 	CSVError(string error_message, CSVErrorType type, idx_t column_idx, string csv_row, LinesPerBoundary error_info,
-	         idx_t row_byte_position, int64_t byte_position, const CSVReaderOptions &reader_options,
+	         idx_t row_byte_position, optional_idx byte_position, const CSVReaderOptions &reader_options,
 	         const string &fixes);
 	CSVError(string error_message, CSVErrorType type, LinesPerBoundary error_info);
 	//! Produces error messages for column name -> type mismatch.
@@ -60,7 +60,7 @@ public:
 	//! Produces error messages for casting errors
 	static CSVError CastError(const CSVReaderOptions &options, string &column_name, string &cast_error,
 	                          idx_t column_idx, string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position,
-	                          int64_t byte_position, LogicalTypeId type);
+	                          optional_idx byte_position, LogicalTypeId type);
 	//! Produces error for when the line size exceeds the maximum line size option
 	static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info,
 	                              string &csv_row, idx_t byte_position);
@@ -69,15 +69,15 @@ public:
 	//! Produces error messages for unterminated quoted values
 	static CSVError UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column,
 	                                        LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-	                                        int64_t byte_position);
+	                                        optional_idx byte_position);
 	//! Produces error messages for null_padding option is set and we have quoted new values in parallel
 	static CSVError NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info);
 	//! Produces error for incorrect (e.g., smaller and lower than the predefined) number of columns in a CSV Line
 	static CSVError IncorrectColumnAmountError(const CSVReaderOptions &state_machine, idx_t actual_columns,
 	                                           LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-	                                           int64_t byte_position);
+	                                           optional_idx byte_position);
 	static CSVError InvalidUTF8(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-	                            string &csv_row, idx_t row_byte_position, int64_t byte_position);
+	                            string &csv_row, idx_t row_byte_position, optional_idx byte_position);
 
 	idx_t GetBoundaryIndex() {
 		return error_info.boundary_idx;
@@ -104,7 +104,7 @@ public:
 	//! Byte position of where the row starts
 	idx_t row_byte_position;
 	//! Byte Position where error occurred.
-	int64_t byte_position;
+	optional_idx byte_position;
 };
 
 class CSVErrorHandler {

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

@@ -69,9 +69,9 @@ struct CSVReaderOptions {
 	//! User-defined name list
 	vector<string> name_list;
 	//! Types considered as candidates for auto detection ordered by descending specificity (~ from high to low)
-	vector<LogicalType> auto_type_candidates = {LogicalType::VARCHAR, LogicalType::TIMESTAMP, LogicalType::DATE,
-	                                            LogicalType::TIME,    LogicalType::DOUBLE,    LogicalType::BIGINT,
-	                                            LogicalType::BOOLEAN, LogicalType::SQLNULL};
+	vector<LogicalType> auto_type_candidates = {LogicalType::VARCHAR,   LogicalType::DOUBLE, LogicalType::BIGINT,
+	                                            LogicalType::TIMESTAMP, LogicalType::DATE,   LogicalType::TIME,
+	                                            LogicalType::BOOLEAN,   LogicalType::SQLNULL};
 	//! In case the sniffer found a mismatch error from user defined types or dialect
 	string sniffer_user_mismatch_error;
 	//! In case the sniffer found a mismatch error from user defined types or dialect
@@ -120,10 +120,8 @@ struct CSVReaderOptions {
 	string suffix;
 	string write_newline;
 
-	//! The date format to use (if any is specified)
-	map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
 	//! The date format to use for writing (if any is specified)
-	map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
+	map<LogicalTypeId, Value> write_date_format = {{LogicalTypeId::DATE, Value()}, {LogicalTypeId::TIMESTAMP, Value()}};
 	//! Whether or not a type format is specified
 	map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
@@ -146,6 +144,9 @@ struct CSVReaderOptions {
 	void SetDelimiter(const string &delimiter);
 	string GetDelimiter() const;
 
+	//! If we can safely ignore errors (i.e., they are being ignored and not being stored in a rejects table)
+	bool IgnoreErrors() const;
+
 	NewLineIdentifier GetNewline() const;
 	void SetNewline(const string &input);
 	//! Set an option that is supported by both reading and writing functions, called by

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

@@ -16,6 +16,7 @@
 namespace duckdb {
 struct DateTimestampSniffing {
 	bool initialized = false;
+	bool had_match = false;
 	vector<string> format;
 };
 //! Struct to store the result of the Sniffer
@@ -74,6 +75,19 @@ struct SetColumns {
 	}
 };
 
+struct HeaderValue {
+	HeaderValue() : is_null(true) {
+	}
+	explicit HeaderValue(string_t value_p) {
+		value = value_p;
+	}
+	bool IsNull() {
+		return is_null;
+	}
+	bool is_null = false;
+	string_t value {};
+};
+
 //! Sniffer that detects Header, Dialect and Types of CSV Files
 class CSVSniffer {
 public:
@@ -125,6 +139,10 @@ private:
 	                                     const vector<QuoteRule> &quoterule_candidates,
 	                                     const unordered_map<uint8_t, vector<char>> &quote_candidates_map,
 	                                     const unordered_map<uint8_t, vector<char>> &escape_candidates_map);
+	//! 2.1 If the user set a number of lines to skip, make sure we skip them
+	//! We skip from the first scanner and then apply information on the remaining scanners.
+	void SkipLines(vector<unique_ptr<ColumnCountScanner>> &csv_state_machines);
+
 	//! 3. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
 	void AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner>, idx_t &rows_read, idx_t &best_consistent_rows,
 	                             idx_t &prev_padding_count);
@@ -142,8 +160,6 @@ private:
 	void DetectTypes();
 	//! Change the date format for the type to the string
 	//! Try to cast a string value to the specified sql type
-	bool TryCastValue(const DialectOptions &dialect_options, const string &decimal_separator, const Value &value,
-	                  const LogicalType &sql_type);
 	void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier, const LogicalTypeId &sql_type);
 
 	//! Function that initialized the necessary variables used for date and timestamp detection
@@ -151,7 +167,10 @@ private:
 	                                         const LogicalType &sql_type);
 	//! Functions that performs detection for date and timestamp formats
 	void DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const LogicalType &sql_type, const string &separator,
-	                                   Value &dummy_val);
+	                                   string_t &dummy_val);
+	//! If a string_t value can be cast to a type
+	bool CanYouCastIt(const string_t value, const LogicalType &type, const DialectOptions &dialect_options,
+	                  const bool is_null, const char decimal_separator);
 
 	//! Variables for Type Detection
 	//! Format Candidates for Date and Timestamp Types
@@ -164,9 +183,10 @@ private:
 	unordered_map<idx_t, vector<LogicalType>> best_sql_types_candidates_per_column_idx;
 	map<LogicalTypeId, vector<string>> best_format_candidates;
 	unique_ptr<StringValueScanner> best_candidate;
-	vector<Value> best_header_row;
+	vector<HeaderValue> best_header_row;
 	//! Variable used for sniffing date and timestamp
 	map<LogicalTypeId, DateTimestampSniffing> format_candidates;
+	map<LogicalTypeId, DateTimestampSniffing> original_format_candidates;
 
 	//! ------------------------------------------------------//
 	//! ------------------ Type Refinement ------------------ //

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

@@ -67,14 +67,23 @@ public:
 	                              unordered_map<idx_t, shared_ptr<CSVBufferHandle>> &buffer_handles);
 };
 
+class StringValueResult;
+
 class CurrentError {
 public:
-	CurrentError(CSVErrorType type, idx_t col_idx_p, LinePosition error_position_p)
-	    : type(type), col_idx(col_idx_p), error_position(error_position_p) {};
-
+	CurrentError(CSVErrorType type, idx_t col_idx_p, idx_t chunk_idx_p, LinePosition error_position_p,
+	             idx_t current_line_size_p)
+	    : type(type), col_idx(col_idx_p), chunk_idx(chunk_idx_p), current_line_size(current_line_size_p),
+	      error_position(error_position_p) {};
+	//! Error Type (e.g., Cast, Wrong # of columns, ...)
 	CSVErrorType type;
+	//! Column index related to the CSV File columns
 	idx_t col_idx;
+	//! Column index related to the produced chunk (i.e., with projection applied)
+	idx_t chunk_idx;
+	//! Current CSV Line size in Bytes
 	idx_t current_line_size;
+	//! Error Message produced
 	string error_message;
 	//! Exact Position where the error happened
 	LinePosition error_position;
@@ -84,12 +93,74 @@ public:
 	}
 };
 
+class LineError {
+public:
+	explicit LineError(bool ignore_errors_p) : is_error_in_line(false), ignore_errors(ignore_errors_p) {};
+	//! We clear up our CurrentError Vector
+	void Reset() {
+		current_errors.clear();
+		is_error_in_line = false;
+	}
+	void Insert(const CSVErrorType &type, const idx_t &col_idx, const idx_t &chunk_idx,
+	            const LinePosition &error_position, const idx_t current_line_size = 0) {
+		is_error_in_line = true;
+		if (!ignore_errors) {
+			// We store it for later
+			current_errors.push_back({type, col_idx, chunk_idx, error_position, current_line_size});
+			current_errors.back().current_line_size = current_line_size;
+		}
+	}
+	//! Set that we currently have an error, but don't really store them
+	void SetError() {
+		is_error_in_line = true;
+	}
+	//! Dirty hack for adding cast message
+	void ModifyErrorMessageOfLastError(string error_message) {
+		D_ASSERT(!current_errors.empty() && current_errors.back().type == CSVErrorType::CAST_ERROR);
+		current_errors.back().error_message = std::move(error_message);
+	}
+
+	bool HasErrorType(CSVErrorType type) {
+		for (auto &error : current_errors) {
+			if (type == error.type) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool HandleErrors(StringValueResult &result);
+
+private:
+	vector<CurrentError> current_errors;
+	bool is_error_in_line;
+	bool ignore_errors;
+};
+
+struct ParseTypeInfo {
+	ParseTypeInfo() {};
+	ParseTypeInfo(LogicalType &type, bool validate_utf_8_p) : validate_utf8(validate_utf_8_p) {
+		type_id = type.id();
+		internal_type = type.InternalType();
+		if (type.id() == LogicalTypeId::DECIMAL) {
+			// We only care about these if we have a decimal value
+			type.GetDecimalProperties(width, scale);
+		}
+	}
+
+	bool validate_utf8;
+	LogicalTypeId type_id;
+	PhysicalType internal_type;
+	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,
-	                  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);
+	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator,
+	                  bool figure_out_new_line, 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);
 
 	~StringValueResult();
 
@@ -115,6 +186,7 @@ public:
 	DataChunk parse_chunk;
 	idx_t number_of_rows = 0;
 	idx_t cur_col_id = 0;
+	bool figure_out_new_line;
 	idx_t result_size;
 	//! Information to properly handle errors
 	CSVErrorHandler &error_handler;
@@ -127,7 +199,7 @@ public:
 	bool added_last_line = false;
 	bool quoted_new_line = false;
 
-	unsafe_unique_array<std::pair<LogicalTypeId, bool>> parse_types;
+	unsafe_unique_array<ParseTypeInfo> parse_types;
 	vector<string> names;
 
 	shared_ptr<CSVFileScan> csv_file_scan;
@@ -144,9 +216,15 @@ public:
 	idx_t requested_size;
 
 	//! Errors happening in the current line (if any)
-	vector<CurrentError> current_errors;
-
+	LineError current_errors;
+	StrpTimeFormat date_format, timestamp_format;
 	bool sniffing;
+
+	char decimal_separator;
+
+	//! We store borked rows so we can generate multiple errors during flushing
+	unordered_set<idx_t> borked_rows;
+
 	//! Specialized code for quoted values, makes sure to remove quotes and escapes
 	static inline void AddQuotedValue(StringValueResult &result, const idx_t buffer_pos);
 	//! Adds a Value to the result
@@ -163,13 +241,9 @@ public:
 	inline bool AddRowInternal();
 	//! Force the throw of a unicode error
 	void HandleUnicodeError(idx_t col_idx, LinePosition &error_position);
-	//! Certain errors should only be handled when adding the line, to ensure proper error propagation.
-	bool HandleError();
-
+	bool HandleTooManyColumnsError(const char *value_ptr, const idx_t size);
 	inline void AddValueToVector(const char *value_ptr, const idx_t size, bool allocate = false);
 
-	Value GetValue(idx_t row_idx, idx_t col_idx);
-
 	DataChunk &ToChunk();
 	//! Resets the state of the result
 	void Reset();
@@ -181,7 +255,7 @@ public:
 	StringValueScanner(idx_t scanner_idx, const shared_ptr<CSVBufferManager> &buffer_manager,
 	                   const shared_ptr<CSVStateMachine> &state_machine,
 	                   const shared_ptr<CSVErrorHandler> &error_handler, const shared_ptr<CSVFileScan> &csv_file_scan,
-	                   bool sniffing = false, CSVIterator boundary = {}, idx_t result_size = STANDARD_VECTOR_SIZE);
+	                   bool sniffing = false, CSVIterator boundary = {}, bool figure_out_nl = false);
 
 	StringValueScanner(const shared_ptr<CSVBufferManager> &buffer_manager,
 	                   const shared_ptr<CSVStateMachine> &state_machine,
@@ -201,8 +275,7 @@ public:
 	static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, 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,
-	                            const map<LogicalTypeId, CSVOption<StrpTimeFormat>> &format_options);
+	static bool CanDirectlyCast(const LogicalType &type);
 
 	const idx_t scanner_idx;
 
@@ -224,9 +297,6 @@ private:
 	//! BOM skipping (https://en.wikipedia.org/wiki/Byte_order_mark)
 	void SkipBOM();
 
-	//! Skips Notes, notes are dirty lines on top of the file, before the actual data
-	void SkipCSVRows();
-
 	void SkipUntilNewLine();
 
 	void SetStart();

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

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// src/include/duckdb/execution/operator/helper/physical_update_extensions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/parsed_data/update_extensions_info.hpp"
+#include "duckdb/main/extension_helper.hpp"
+
+namespace duckdb {
+
+struct UpdateExtensionsGlobalState : public GlobalSourceState {
+	UpdateExtensionsGlobalState() : offset(0) {
+	}
+
+	vector<ExtensionUpdateResult> update_result_entries;
+	idx_t offset;
+};
+
+//! PhysicalUpdateExtensions represents an extension UPDATE operation
+class PhysicalUpdateExtensions : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UPDATE_EXTENSIONS;
+
+public:
+	explicit PhysicalUpdateExtensions(unique_ptr<UpdateExtensionsInfo> info, idx_t estimated_cardinality)
+	    : PhysicalOperator(PhysicalOperatorType::UPDATE_EXTENSIONS,
+	                       {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
+	                        LogicalType::VARCHAR},
+	                       estimated_cardinality),
+	      info(std::move(info)) {
+	}
+
+	unique_ptr<UpdateExtensionsInfo> info;
+
+	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
+
+public:
+	// Source interface
+	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+
+	bool IsSource() const override {
+		return true;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_batch_insert.hpp

@@ -20,7 +20,7 @@ public:
 	//! INSERT INTO
 	PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry &table,
 	                    physical_index_vector_t<idx_t> column_index_map, vector<unique_ptr<Expression>> bound_defaults,
-	                    idx_t estimated_cardinality);
+	                    vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t estimated_cardinality);
 	//! CREATE TABLE AS
 	PhysicalBatchInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
 	                    idx_t estimated_cardinality);
@@ -33,6 +33,8 @@ public:
 	vector<LogicalType> insert_types;
 	//! The default expressions of the columns for which no value is provided
 	vector<unique_ptr<Expression>> bound_defaults;
+	//! The bound constraints for the table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	//! Table schema, in case of CREATE TABLE AS
 	optional_ptr<SchemaCatalogEntry> schema;
 	//! Create table info, in case of CREATE TABLE AS

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_delete.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/planner/bound_constraint.hpp"
 
 namespace duckdb {
 class DataTable;
@@ -19,14 +20,13 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DELETE_OPERATOR;
 
 public:
-	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
-	               idx_t estimated_cardinality, bool return_chunk)
-	    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, std::move(types), estimated_cardinality),
-	      tableref(tableref), table(table), row_id_index(row_id_index), return_chunk(return_chunk) {
-	}
+	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
+	               vector<unique_ptr<BoundConstraint>> bound_constraints, idx_t row_id_index,
+	               idx_t estimated_cardinality, bool return_chunk);
 
 	TableCatalogEntry &tableref;
 	DataTable &table;
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	idx_t row_id_index;
 	bool return_chunk;
 

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_export.hpp

@@ -57,6 +57,7 @@ public:
 
 	static void ExtractEntries(ClientContext &context, vector<reference<SchemaCatalogEntry>> &schemas,
 	                           ExportEntries &result);
+	static catalog_entry_vector_t GetNaiveExportOrder(ClientContext &context, Catalog &catalog);
 
 public:
 	// Sink interface

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp

@@ -26,11 +26,12 @@ public:
 public:
 	//! INSERT INTO
 	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry &table, physical_index_vector_t<idx_t> column_index_map,
-	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<Expression>> set_expressions,
-	               vector<PhysicalIndex> set_columns, vector<LogicalType> set_types, idx_t estimated_cardinality,
-	               bool return_chunk, bool parallel, OnConflictAction action_type,
-	               unique_ptr<Expression> on_conflict_condition, unique_ptr<Expression> do_update_condition,
-	               unordered_set<column_t> on_conflict_filter, vector<column_t> columns_to_fetch);
+	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<BoundConstraint>> bound_constraints,
+	               vector<unique_ptr<Expression>> set_expressions, vector<PhysicalIndex> set_columns,
+	               vector<LogicalType> set_types, idx_t estimated_cardinality, bool return_chunk, bool parallel,
+	               OnConflictAction action_type, unique_ptr<Expression> on_conflict_condition,
+	               unique_ptr<Expression> do_update_condition, unordered_set<column_t> on_conflict_filter,
+	               vector<column_t> columns_to_fetch);
 	//! CREATE TABLE AS
 	PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info,
 	               idx_t estimated_cardinality, bool parallel);
@@ -43,6 +44,8 @@ public:
 	vector<LogicalType> insert_types;
 	//! The default expressions of the columns for which no value is provided
 	vector<unique_ptr<Expression>> bound_defaults;
+	//! The bound constraints for the table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	//! If the returning statement is present, return the whole chunk
 	bool return_chunk;
 	//! Table schema, in case of CREATE TABLE AS

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_update.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/planner/expression.hpp"
+#include "duckdb/planner/bound_constraint.hpp"
 
 namespace duckdb {
 class DataTable;
@@ -22,13 +23,15 @@ public:
 public:
 	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table,
 	               vector<PhysicalIndex> columns, vector<unique_ptr<Expression>> expressions,
-	               vector<unique_ptr<Expression>> bound_defaults, idx_t estimated_cardinality, bool return_chunk);
+	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<BoundConstraint>> bound_constraints,
+	               idx_t estimated_cardinality, bool return_chunk);
 
 	TableCatalogEntry &tableref;
 	DataTable &table;
 	vector<PhysicalIndex> columns;
 	vector<unique_ptr<Expression>> expressions;
 	vector<unique_ptr<Expression>> bound_defaults;
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	bool update_is_del_and_insert;
 	//! If the returning statement is present, return the whole chunk
 	bool return_chunk;

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/common/optionally_owned_ptr.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 
 namespace duckdb {
@@ -20,15 +21,13 @@ public:
 
 public:
 	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
-	                       unique_ptr<ColumnDataCollection> owned_collection = nullptr);
+	                       optionally_owned_ptr<ColumnDataCollection> collection);
 
 	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
 	                       idx_t cte_index);
 
-	// the column data collection to scan
-	optional_ptr<ColumnDataCollection> collection;
-	//! Owned column data collection, if any
-	unique_ptr<ColumnDataCollection> owned_collection;
+	//! (optionally owned) column data collection to scan
+	optionally_owned_ptr<ColumnDataCollection> collection;
 
 	idx_t cte_index;
 

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp

@@ -39,8 +39,12 @@ public:
 
 public:
 	bool IsFoldable() const;
-	void EvaluateExpression(ClientContext &context, idx_t expression_idx, DataChunk *child_chunk,
-	                        DataChunk &result) const;
+	void EvaluateExpression(ClientContext &context, idx_t expression_idx, optional_ptr<DataChunk> child_chunk,
+	                        DataChunk &result, optional_ptr<DataChunk> temp_chunk_ptr = nullptr) const;
+
+private:
+	void EvaluateExpressionInternal(ClientContext &context, idx_t expression_idx, optional_ptr<DataChunk> child_chunk,
+	                                DataChunk &result, DataChunk &temp_chunk) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp

@@ -26,7 +26,7 @@ public:
 
 	vector<const_reference<PhysicalOperator>> cte_scans;
 
-	std::shared_ptr<ColumnDataCollection> working_table;
+	shared_ptr<ColumnDataCollection> working_table;
 
 	idx_t table_index;
 	string ctename;

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp

@@ -29,7 +29,7 @@ public:
 	idx_t table_index;
 
 	bool union_all;
-	std::shared_ptr<ColumnDataCollection> working_table;
+	shared_ptr<ColumnDataCollection> working_table;
 	shared_ptr<MetaPipeline> recursive_meta_pipeline;
 
 public:

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -31,7 +31,7 @@ public:
 	LogicalDependencyList dependencies;
 	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
 	//! This data structure is used to establish it.
-	unordered_map<idx_t, std::shared_ptr<ColumnDataCollection>> recursive_cte_tables;
+	unordered_map<idx_t, shared_ptr<ColumnDataCollection>> recursive_cte_tables;
 	//! Materialized CTE ids must be collected.
 	unordered_map<idx_t, vector<const_reference<PhysicalOperator>>> materialized_ctes;