duckdb 1.1.2-dev4.0 → 1.1.2-dev6.0

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

@@ -8,25 +8,50 @@
 
 #pragma once
 
-#include "duckdb/execution/operator/csv_scanner/state_machine/csv_state_machine.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
 #include "duckdb/common/vector.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/quote_rules.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner/column_count_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/quote_rules.hpp"
+#include "duckdb/execution/operator/csv_scanner/column_count_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_schema.hpp"
+#include "duckdb/execution/operator/csv_scanner/header_value.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp"
 
 namespace duckdb {
 struct DateTimestampSniffing {
 	bool initialized = false;
+	bool had_match = false;
 	vector<string> format;
+	idx_t initial_size;
 };
-//! Struct to store the result of the Sniffer
-struct SnifferResult {
-	SnifferResult(vector<LogicalType> return_types_p, vector<string> names_p)
-	    : return_types(std::move(return_types_p)), names(std::move(names_p)) {
-	}
-	//! Return Types that were detected
-	vector<LogicalType> return_types;
-	//! Column Names that were detected
-	vector<string> names;
+
+//! All the options that will be used to sniff the dialect of the CSV file
+struct DialectCandidates {
+	//! The constructor populates all of our the options that will be used in our sniffer search space
+	explicit DialectCandidates(const CSVStateMachineOptions &options);
+
+	//! Static functions to get defaults of the search space
+	static vector<char> GetDefaultDelimiter();
+
+	static vector<vector<char>> GetDefaultQuote();
+
+	static vector<QuoteRule> GetDefaultQuoteRule();
+
+	static vector<vector<char>> GetDefaultEscape();
+
+	static vector<char> GetDefaultComment();
+
+	string Print();
+
+	//! Candidates for the delimiter
+	vector<char> delim_candidates;
+	//! Candidates for the comment
+	vector<char> comment_candidates;
+	//! Quote-Rule Candidates
+	vector<QuoteRule> quote_rule_candidates;
+	//! Candidates for the quote option
+	unordered_map<uint8_t, vector<char>> quote_candidates_map;
+	//! Candidates for the escape option
+	unordered_map<uint8_t, vector<char>> escape_candidates_map;
 };
 
 //! This represents the data related to columns that have been set by the user
@@ -45,12 +70,12 @@ struct SetColumns {
 	//! Column Names that were detected
 	const vector<string> *names = nullptr;
 	//! If columns are set
-	bool IsSet();
+	bool IsSet() const;
 	//! How many columns
-	idx_t Size();
+	idx_t Size() const;
 	//! Helper function that checks if candidate is acceptable based on the number of columns it produces
-	inline bool IsCandidateUnacceptable(idx_t num_cols, bool null_padding, bool ignore_errors,
-	                                    bool last_value_always_empty) {
+	inline bool IsCandidateUnacceptable(const idx_t num_cols, bool null_padding, bool ignore_errors,
+	                                    bool last_value_always_empty) const {
 		if (!IsSet() || ignore_errors) {
 			// We can't say its unacceptable if it's not set or if we ignore errors
 			return false;
@@ -74,11 +99,17 @@ struct SetColumns {
 	}
 };
 
+//! Struct used to know if we have a date or timestamp type already identified in this CSV File
+struct HasType {
+	bool date = false;
+	bool timestamp = false;
+};
+
 //! Sniffer that detects Header, Dialect and Types of CSV Files
 class CSVSniffer {
 public:
 	explicit CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager> buffer_manager_p,
-	                    CSVStateMachineCache &state_machine_cache, SetColumns set_columns = {});
+	                    CSVStateMachineCache &state_machine_cache, bool default_null_to_varchar = true);
 
 	//! Main method that sniffs the CSV file, returns the types, names and options as a result
 	//! CSV Sniffing consists of five steps:
@@ -89,8 +120,22 @@ public:
 	//! 5. Type Replacement: Replaces the types of the columns if the user specified them
 	SnifferResult SniffCSV(bool force_match = false);
 
+	//! I call it adaptive, since that's a sexier term.
+	//! In practice this Function that only sniffs the first two rows, to verify if a header exists and what are the
+	//! data types It does this considering a priorly set CSV schema. If there is a mismatch of the schema it runs the
+	//! full on blazing all guns sniffer, if that still fails it tells the user to union_by_name.
+	//! It returns the projection order.
+	SnifferResult AdaptiveSniff(const CSVSchema &file_schema);
+
+	//! Function that only sniffs the first two rows, to verify if a header exists and what are the data types
+	AdaptiveSnifferResult MinimalSniff();
+
 	static NewLineIdentifier DetectNewLineDelimiter(CSVBufferManager &buffer_manager);
 
+	//! If a string_t value can be cast to a type
+	static bool CanYouCastIt(ClientContext &context, const string_t value, const LogicalType &type,
+	                         const DialectOptions &dialect_options, const bool is_null, const char decimal_separator);
+
 private:
 	//! CSV State Machine Cache
 	CSVStateMachineCache &state_machine_cache;
@@ -106,6 +151,7 @@ private:
 	SetColumns set_columns;
 	shared_ptr<CSVErrorHandler> error_handler;
 	shared_ptr<CSVErrorHandler> detection_error_handler;
+
 	//! Sets the result options
 	void SetResultOptions();
 
@@ -115,42 +161,41 @@ private:
 	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
 	void DetectDialect();
 	//! Functions called in the main DetectDialect(); function
-	//! 1. Generates the search space candidates for the dialect
-	void GenerateCandidateDetectionSearchSpace(vector<char> &delim_candidates, vector<QuoteRule> &quoterule_candidates,
-	                                           unordered_map<uint8_t, vector<char>> &quote_candidates_map,
-	                                           unordered_map<uint8_t, vector<char>> &escape_candidates_map);
-	//! 2. Generates the search space candidates for the state machines
+	//! 1. Generates the search space candidates for the state machines
 	void GenerateStateMachineSearchSpace(vector<unique_ptr<ColumnCountScanner>> &column_count_scanners,
-	                                     const vector<char> &delimiter_candidates,
-	                                     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);
-	//! 3. Analyzes if dialect candidate is a good candidate to be considered, if so, it adds it to the candidates
+	                                     const DialectCandidates &dialect_candidates);
+
+	//! 2. 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);
-	//! 4. Refine Candidates over remaining chunks
+	                             idx_t &prev_padding_count, idx_t &min_ignored_rows);
+	//! 3. Refine Candidates over remaining chunks
 	void RefineCandidates();
 
 	//! Checks if candidate still produces good values for the next chunk
-	bool RefineCandidateNextChunk(ColumnCountScanner &candidate);
+	bool RefineCandidateNextChunk(ColumnCountScanner &candidate) const;
 
 	//! ------------------------------------------------------//
 	//! ------------------- Type Detection ------------------ //
 	//! ------------------------------------------------------//
-	//! Second phase of auto detection: detect types, format template candidates
+	//! Second phase of auto-detection: detect types, format template candidates
 	//! ordered by descending specificity (~ from high to low)
 	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(CSVStateMachine &candidate, const Value &value, const LogicalType &sql_type);
-	void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier, const LogicalTypeId &sql_type);
+	static void SetDateFormat(CSVStateMachine &candidate, const string &format_specifier,
+	                          const LogicalTypeId &sql_type);
 
 	//! Function that initialized the necessary variables used for date and timestamp detection
 	void InitializeDateAndTimeStampDetection(CSVStateMachine &candidate, const string &separator,
 	                                         const LogicalType &sql_type);
+	//! Sets user defined date and time formats (if any)
+	void SetUserDefinedDateTimeFormat(CSVStateMachine &candidate) const;
 	//! Functions that performs detection for date and timestamp formats
 	void DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const LogicalType &sql_type, const string &separator,
-	                                   Value &dummy_val);
+	                                   const string_t &dummy_val);
+	//! Sniffs the types from a data chunk
+	void SniffTypes(DataChunk &data_chunk, CSVStateMachine &state_machine,
+	                unordered_map<idx_t, vector<LogicalType>> &info_sql_types_candidates, idx_t start_idx_detection);
 
 	//! Variables for Type Detection
 	//! Format Candidates for Date and Timestamp Types
@@ -163,9 +208,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 ------------------ //
@@ -173,17 +219,26 @@ private:
 	void RefineTypes();
 	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
 	vector<LogicalType> detected_types;
-
+	//! If when finding a SQLNULL type in type detection we default it to varchar
+	const bool default_null_to_varchar;
 	//! ------------------------------------------------------//
 	//! ------------------ Header Detection ----------------- //
 	//! ------------------------------------------------------//
 	void DetectHeader();
+	static bool DetectHeaderWithSetColumn(ClientContext &context, vector<HeaderValue> &best_header_row,
+	                                      const SetColumns &set_columns, CSVReaderOptions &options);
+	static vector<string>
+	DetectHeaderInternal(ClientContext &context, vector<HeaderValue> &best_header_row, CSVStateMachine &state_machine,
+	                     const SetColumns &set_columns,
+	                     unordered_map<idx_t, vector<LogicalType>> &best_sql_types_candidates_per_column_idx,
+	                     CSVReaderOptions &options, CSVErrorHandler &error_handler);
 	vector<string> names;
 
 	//! ------------------------------------------------------//
 	//! ------------------ Type Replacement ----------------- //
 	//! ------------------------------------------------------//
 	void ReplaceTypes();
+	vector<bool> manually_set;
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/csv_scanner/sniffer/sniff_result.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/operator/csv_scanner/csv_state_machine.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+//! Struct to store the result of the Sniffer
+struct SnifferResult {
+	SnifferResult(vector<LogicalType> return_types_p, vector<string> names_p)
+	    : return_types(std::move(return_types_p)), names(std::move(names_p)) {
+	}
+	//! Return Types that were detected
+	vector<LogicalType> return_types;
+	//! Column Names that were detected
+	vector<string> names;
+};
+
+struct AdaptiveSnifferResult : SnifferResult {
+	AdaptiveSnifferResult(vector<LogicalType> return_types_p, vector<string> names_p, bool more_than_one_row_p)
+	    : SnifferResult(std::move(return_types_p), std::move(names_p)), more_than_one_row(more_than_one_row_p) {
+	}
+	bool more_than_one_row;
+	SnifferResult ToSnifferResult() {
+		return {return_types, names};
+	}
+};
+} // namespace duckdb

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

@@ -186,7 +186,7 @@ public:
 
 	//! Internal Data Chunk used for flushing
 	DataChunk parse_chunk;
-	idx_t number_of_rows = 0;
+	int64_t number_of_rows = 0;
 	idx_t cur_col_id = 0;
 	bool figure_out_new_line = false;
 	//! Information to properly handle errors

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

@@ -26,7 +26,6 @@ struct PerfectHashJoinStats {
 	Value probe_max;
 	bool is_build_small = false;
 	bool is_build_dense = false;
-	bool is_probe_in_domain = false;
 	idx_t build_range = 0;
 	idx_t estimated_cardinality = 0;
 };

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

@@ -34,17 +34,14 @@ public:
 
 public:
 	PhysicalExport(vector<LogicalType> types, CopyFunction function, unique_ptr<CopyInfo> info,
-	               idx_t estimated_cardinality, BoundExportData exported_tables)
-	    : PhysicalOperator(PhysicalOperatorType::EXPORT, std::move(types), estimated_cardinality),
-	      function(std::move(function)), info(std::move(info)), exported_tables(std::move(exported_tables)) {
-	}
+	               idx_t estimated_cardinality, unique_ptr<BoundExportData> exported_tables);
 
 	//! The copy function to use to read the file
 	CopyFunction function;
 	//! The binding info containing the set of options for reading the file
 	unique_ptr<CopyInfo> info;
 	//! The table info for each table that will be exported
-	BoundExportData exported_tables;
+	unique_ptr<BoundExportData> exported_tables;
 
 public:
 	// Source interface

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -242,7 +242,7 @@ public:
 	//! The returned FunctionData object should be constant and should not be changed during execution.
 	table_function_bind_t bind;
 	//! (Optional) Bind replace function
-	//! This function is called before the regular bind function. It allows returning a TableRef will be used to
+	//! This function is called before the regular bind function. It allows returning a TableRef that will be used to
 	//! to generate a logical plan that replaces the LogicalGet of a regularly bound TableFunction. The BindReplace can
 	//! also return a nullptr to indicate a regular bind needs to be performed instead.
 	table_function_bind_replace_t bind_replace;

package/src/duckdb/src/include/duckdb/main/database.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/main/valid_checker.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/main/extension.hpp"
+#include "duckdb/main/capi/extension_api.hpp"
 #include "duckdb/main/extension_install_info.hpp"
 #include "duckdb/main/settings.hpp"
 
@@ -58,6 +59,8 @@ public:
 	DUCKDB_API ValidChecker &GetValidChecker();
 	DUCKDB_API void SetExtensionLoaded(const string &extension_name, ExtensionInstallInfo &install_info);
 
+	DUCKDB_API const duckdb_ext_api_v0 GetExtensionAPIV0();
+
 	idx_t NumberOfThreads();
 
 	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
@@ -91,6 +94,8 @@ private:
 	ValidChecker db_validity;
 	unique_ptr<DatabaseFileSystem> db_file_system;
 	shared_ptr<DatabaseCacheEntry> db_cache_entry;
+
+	duckdb_ext_api_v0 (*create_api_v0)();
 };
 
 //! The database object. This object holds the catalog and all the

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -410,6 +410,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"binary_as_string", "parquet"},
     {"ca_cert_file", "httpfs"},
     {"calendar", "icu"},
+    {"enable_geoparquet_conversion", "parquet"},
     {"enable_server_cert_verification", "httpfs"},
     {"force_download", "httpfs"},
     {"hf_max_per_page", "httpfs"},

package/src/duckdb/src/include/duckdb/main/profiling_info.hpp

@@ -26,38 +26,36 @@ namespace duckdb {
 
 class ProfilingInfo {
 public:
-	// Enabling a metric adds it to this set.
+	//! Enabling a metric adds it to this set.
 	profiler_settings_t settings;
-	// Contains all enabled metrics.
+	//! This set contains the expanded to-be-collected metrics, which can differ from 'settings'.
+	profiler_settings_t expanded_settings;
+	//! Contains all enabled metrics.
 	profiler_metrics_t metrics;
-	// Additional metrics.
+	//! Additional metrics.
 	// FIXME: move to metrics.
 	InsertionOrderPreservingMap<string> extra_info;
 
 public:
 	ProfilingInfo() = default;
-	explicit ProfilingInfo(profiler_settings_t &n_settings, idx_t depth = 0) : settings(n_settings) {
-		if (depth == 0) {
-			settings.insert(MetricsType::QUERY_NAME);
-		} else {
-			settings.insert(MetricsType::OPERATOR_TYPE);
-		}
-		ResetMetrics();
-	}
+	explicit ProfilingInfo(const profiler_settings_t &n_settings, const idx_t depth = 0);
 	ProfilingInfo(ProfilingInfo &) = default;
 	ProfilingInfo &operator=(ProfilingInfo const &) = default;
 
 public:
 	static profiler_settings_t DefaultSettings();
+	static profiler_settings_t DefaultRootSettings();
 	static profiler_settings_t DefaultOperatorSettings();
-	static profiler_settings_t AllSettings();
 
 public:
 	void ResetMetrics();
-	bool Enabled(const MetricsType setting) const;
+	//! Returns true, if the query profiler must collect this metric.
+	static bool Enabled(const profiler_settings_t &settings, const MetricsType metric);
+	//! Expand metrics depending on the collection of other metrics.
+	static void Expand(profiler_settings_t &settings, const MetricsType metric);
 
 public:
-	string GetMetricAsString(MetricsType setting) const;
+	string GetMetricAsString(const MetricsType metric) const;
 	void WriteMetricsToJSON(duckdb_yyjson::yyjson_mut_doc *doc, duckdb_yyjson::yyjson_mut_val *destination);
 
 public:
@@ -68,20 +66,20 @@ public:
 	}
 
 	template <class METRIC_TYPE>
-	void AddToMetric(const MetricsType setting, const Value &value) {
-		D_ASSERT(!metrics[setting].IsNull());
-		if (metrics.find(setting) == metrics.end()) {
-			metrics[setting] = value;
+	void AddToMetric(const MetricsType type, const Value &value) {
+		D_ASSERT(!metrics[type].IsNull());
+		if (metrics.find(type) == metrics.end()) {
+			metrics[type] = value;
 			return;
 		}
-		auto new_value = metrics[setting].GetValue<METRIC_TYPE>() + value.GetValue<METRIC_TYPE>();
-		metrics[setting] = Value::CreateValue(new_value);
+		auto new_value = metrics[type].GetValue<METRIC_TYPE>() + value.GetValue<METRIC_TYPE>();
+		metrics[type] = Value::CreateValue(new_value);
 	}
 
 	template <class METRIC_TYPE>
-	void AddToMetric(const MetricsType setting, const METRIC_TYPE &value) {
+	void AddToMetric(const MetricsType type, const METRIC_TYPE &value) {
 		auto new_value = Value::CreateValue(value);
-		return AddToMetric<METRIC_TYPE>(setting, new_value);
+		return AddToMetric<METRIC_TYPE>(type, new_value);
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/query_profiler.hpp

@@ -64,7 +64,10 @@ class OperatorProfiler {
 
 public:
 	DUCKDB_API explicit OperatorProfiler(ClientContext &context);
+	~OperatorProfiler() {
+	}
 
+public:
 	DUCKDB_API void StartOperator(optional_ptr<const PhysicalOperator> phys_op);
 	DUCKDB_API void EndOperator(optional_ptr<DataChunk> chunk);
 
@@ -72,20 +75,14 @@ public:
 	DUCKDB_API void Flush(const PhysicalOperator &phys_op);
 	DUCKDB_API OperatorInformation &GetOperatorInfo(const PhysicalOperator &phys_op);
 
-	~OperatorProfiler() {
-	}
-
+public:
 	ClientContext &context;
 
-	bool HasOperatorSetting(const MetricsType &metric) const {
-		return operator_settings.find(metric) != operator_settings.end();
-	}
-
 private:
 	//! Whether or not the profiler is enabled
 	bool enabled;
 	//! Sub-settings for the operator profiler
-	profiler_settings_t operator_settings;
+	profiler_settings_t settings;
 
 	//! The timer used to time the execution time of the individual Physical Operators
 	Profiler op;
@@ -113,7 +110,8 @@ public:
 	using TreeMap = reference_map_t<const PhysicalOperator, reference<ProfilingNode>>;
 
 private:
-	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, profiler_settings_t settings, idx_t depth = 0);
+	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, const profiler_settings_t &settings,
+	                                     const idx_t depth = 0);
 	void Render(const ProfilingNode &node, std::ostream &str) const;
 
 public:

package/src/duckdb/src/include/duckdb/main/secret/secret.hpp

@@ -80,6 +80,13 @@ struct SecretType {
 	string default_provider;
 };
 
+enum class SecretSerializationType : uint8_t {
+	//! The secret is serialized with a custom serialization function
+	CUSTOM = 0,
+	//! The secret has been serialized as a KeyValueSecret
+	KEY_VALUE_SECRET = 1
+};
+
 //! Base class from which BaseSecret classes can be made.
 class BaseSecret {
 	friend class SecretManager;
@@ -187,7 +194,7 @@ public:
 
 		for (const auto &entry : ListValue::GetChildren(secret_map_value)) {
 			auto kv_struct = StructValue::GetChildren(entry);
-			result->secret_map[kv_struct[0].ToString()] = kv_struct[1].ToString();
+			result->secret_map[kv_struct[0].ToString()] = kv_struct[1];
 		}
 
 		Value redact_set_value;

package/src/duckdb/src/include/duckdb/main/table_description.hpp

@@ -13,12 +13,26 @@
 namespace duckdb {
 
 struct TableDescription {
+public:
 	//! The schema of the table
 	string schema;
 	//! The table name of the table
 	string table;
 	//! The columns of the table
 	vector<ColumnDefinition> columns;
+
+public:
+	idx_t PhysicalColumnCount() const {
+		idx_t count = 0;
+		for (auto &column : columns) {
+			if (column.Generated()) {
+				continue;
+			}
+			count++;
+		}
+		D_ASSERT(count != 0);
+		return count;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/unnest_rewriter.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/common/pair.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -61,14 +61,14 @@ public:
 
 private:
 	//! Find delim joins that contain an UNNEST
-	void FindCandidates(unique_ptr<LogicalOperator> *op_ptr, vector<unique_ptr<LogicalOperator> *> &candidates);
+	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<reference<unique_ptr<LogicalOperator>>> &candidates);
 	//! Rewrite a delim join that contains an UNNEST
-	bool RewriteCandidate(unique_ptr<LogicalOperator> *candidate);
+	bool RewriteCandidate(unique_ptr<LogicalOperator> &candidate);
 	//! Update the bindings of the RHS sequence of LOGICAL_PROJECTION(s)
-	void UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, unique_ptr<LogicalOperator> *candidate,
+	void UpdateRHSBindings(unique_ptr<LogicalOperator> &plan, unique_ptr<LogicalOperator> &candidate,
 	                       UnnestRewriterPlanUpdater &updater);
 	//! Update the bindings of the BOUND_UNNEST expression of the LOGICAL_UNNEST
-	void UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater, unique_ptr<LogicalOperator> *candidate);
+	void UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater, unique_ptr<LogicalOperator> &candidate);
 
 	//! Store all delim columns of the delim join
 	void GetDelimColumns(LogicalOperator &op);

package/src/duckdb/src/include/duckdb/parser/parsed_data/exported_table_data.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/export_table_data.hpp
+// duckdb/parser/parsed_data/exported_table_data.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -28,16 +28,23 @@ struct ExportedTableData {
 	string file_path;
 	//! Not Null columns, if any
 	vector<string> not_null_columns;
+
+	void Serialize(Serializer &serializer) const;
+	static ExportedTableData Deserialize(Deserializer &deserializer);
 };
 
 struct ExportedTableInfo {
-	ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data_p, vector<string> &not_null_columns_p)
-	    : entry(entry), table_data(std::move(table_data_p)) {
-		table_data.not_null_columns = not_null_columns_p;
-	}
+	ExportedTableInfo(TableCatalogEntry &entry, ExportedTableData table_data_p, vector<string> &not_null_columns_p);
+	ExportedTableInfo(ClientContext &context, ExportedTableData table_data);
 
 	TableCatalogEntry &entry;
 	ExportedTableData table_data;
+
+	void Serialize(Serializer &serializer) const;
+	static ExportedTableInfo Deserialize(Deserializer &deserializer);
+
+private:
+	static TableCatalogEntry &GetEntry(ClientContext &context, const ExportedTableData &table_data);
 };
 
 struct BoundExportData : public ParseInfo {
@@ -49,6 +56,9 @@ public:
 	}
 
 	vector<ExportedTableInfo> data;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -323,6 +323,8 @@ private:
 	//! Transform a range var into a (schema) qualified name
 	QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root);
 
+	//! Transform a Postgres TypeName string into a LogicalType (non-LIST types)
+	LogicalType TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &name);
 	//! Transform a Postgres TypeName string into a LogicalType
 	LogicalType TransformTypeName(duckdb_libpgquery::PGTypeName &name);
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp

@@ -37,6 +37,9 @@ public:
 
 	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
 
+	//! Sets the query component, for error messages
+	void SetQueryComponent(string component = string());
+
 private:
 	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, const idx_t index);
 	unique_ptr<Expression> BindConstant(ParsedExpression &expr);
@@ -46,6 +49,7 @@ private:
 	vector<reference<Binder>> binders;
 	optional_ptr<vector<unique_ptr<ParsedExpression>>> extra_list;
 	SelectBindState &bind_state;
+	string query_component = "ORDER BY";
 };
 
 } // namespace duckdb