Update vendored DuckDB sources to d5895cf

src/duckdb/extension/parquet/parquet_extension.cpp

@@ -1500,16 +1500,16 @@ static void ParquetCopySerialize(Serializer &serializer, const FunctionData &bin
 	ParquetWriteBindData default_value;
 	serializer.WritePropertyWithDefault(109, "compression_level", compression_level);
 	serializer.WritePropertyWithDefault(110, "row_groups_per_file", bind_data.row_groups_per_file,
-	                                    std::move(default_value.row_groups_per_file));
+	                                    default_value.row_groups_per_file);
 	serializer.WritePropertyWithDefault(111, "debug_use_openssl", bind_data.debug_use_openssl,
-	                                    std::move(default_value.debug_use_openssl));
+	                                    default_value.debug_use_openssl);
 	serializer.WritePropertyWithDefault(112, "dictionary_size_limit", bind_data.dictionary_size_limit,
-	                                    std::move(default_value.dictionary_size_limit));
+	                                    default_value.dictionary_size_limit);
 	serializer.WritePropertyWithDefault(113, "bloom_filter_false_positive_ratio",
 	                                    bind_data.bloom_filter_false_positive_ratio,
-	                                    std::move(default_value.bloom_filter_false_positive_ratio));
+	                                    default_value.bloom_filter_false_positive_ratio);
 	serializer.WritePropertyWithDefault(114, "parquet_version", bind_data.parquet_version,
-	                                    std::move(default_value.parquet_version));
+	                                    default_value.parquet_version);
 }
 
 static unique_ptr<FunctionData> ParquetCopyDeserialize(Deserializer &deserializer, CopyFunction &function) {
@@ -1531,15 +1531,15 @@ static unique_ptr<FunctionData> ParquetCopyDeserialize(Deserializer &deserialize
 	D_ASSERT(SerializeCompressionLevel(data->compression_level) == compression_level);
 	ParquetWriteBindData default_value;
 	data->row_groups_per_file = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(
-	    110, "row_groups_per_file", std::move(default_value.row_groups_per_file));
-	data->debug_use_openssl = deserializer.ReadPropertyWithExplicitDefault<bool>(
-	    111, "debug_use_openssl", std::move(default_value.debug_use_openssl));
+	    110, "row_groups_per_file", default_value.row_groups_per_file);
+	data->debug_use_openssl =
+	    deserializer.ReadPropertyWithExplicitDefault<bool>(111, "debug_use_openssl", default_value.debug_use_openssl);
 	data->dictionary_size_limit = deserializer.ReadPropertyWithExplicitDefault<idx_t>(
-	    112, "dictionary_size_limit", std::move(default_value.dictionary_size_limit));
+	    112, "dictionary_size_limit", default_value.dictionary_size_limit);
 	data->bloom_filter_false_positive_ratio = deserializer.ReadPropertyWithExplicitDefault<double>(
-	    113, "bloom_filter_false_positive_ratio", std::move(default_value.bloom_filter_false_positive_ratio));
+	    113, "bloom_filter_false_positive_ratio", default_value.bloom_filter_false_positive_ratio);
 	data->parquet_version =
-	    deserializer.ReadPropertyWithExplicitDefault(114, "parquet_version", std::move(default_value.parquet_version));
+	    deserializer.ReadPropertyWithExplicitDefault(114, "parquet_version", default_value.parquet_version);
 
 	return std::move(data);
 }

src/duckdb/src/common/serializer/serializer.cpp

@@ -15,7 +15,7 @@ void Serializer::WriteValue(const vector<bool> &vec) {
 
 template <>
 void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
-                                                 const Value &&default_value) {
+                                                 const Value &default_value) {
 	// If current value is default, don't write it
 	if (!options.serialize_default_values && ValueOperations::NotDistinctFrom(value, default_value)) {
 		OnOptionalPropertyBegin(field_id, tag, false);

src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp

@@ -105,7 +105,13 @@ ColumnCountScanner::ColumnCountScanner(shared_ptr<CSVBufferManager> buffer_manag
     : BaseScanner(std::move(buffer_manager), state_machine, std::move(error_handler), true, nullptr, iterator),
       result(states, *state_machine, result_size_p), column_count(1), result_size(result_size_p) {
 	sniffing = true;
-	result.last_position = {0, 0, cur_buffer_handle->actual_size};
+	idx_t actual_size = 0;
+	if (cur_buffer_handle) {
+		actual_size = cur_buffer_handle->actual_size;
+	}
+	result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, actual_size};
+	result.current_buffer_size = actual_size;
+	result.cur_buffer_idx = iterator.pos.buffer_idx;
 }
 
 unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner() {
@@ -124,7 +130,9 @@ unique_ptr<StringValueScanner> ColumnCountScanner::UpgradeToStringValueScanner()
 ColumnCountResult &ColumnCountScanner::ParseChunk() {
 	result.result_position = 0;
 	column_count = 1;
-	result.current_buffer_size = cur_buffer_handle->actual_size;
+	if (cur_buffer_handle) {
+		result.current_buffer_size = cur_buffer_handle->actual_size;
+	}
 	ParseChunkInternal(result);
 	return result;
 }

src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp

@@ -488,11 +488,15 @@ void StringValueResult::Reset() {
 		cur_buffer = buffer_handles[iterator.GetBufferIdx()];
 	}
 	buffer_handles.clear();
+	idx_t actual_size = 0;
 	if (cur_buffer) {
 		buffer_handles[cur_buffer->buffer_idx] = cur_buffer;
+		actual_size = cur_buffer->actual_size;
 	}
 	current_errors.Reset();
 	borked_rows.clear();
+	current_line_position.begin = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, actual_size};
+	current_line_position.end = current_line_position.begin;
 }
 
 void StringValueResult::AddQuotedValue(StringValueResult &result, const idx_t buffer_pos) {
@@ -1524,8 +1528,8 @@ bool StringValueScanner::FirstValueEndsOnQuote(CSVIterator iterator) const {
 	const idx_t to_pos = iterator.GetEndPos();
 	while (iterator.pos.buffer_pos < to_pos) {
 		state_machine->Transition(current_state, buffer_handle_ptr[iterator.pos.buffer_pos++]);
-		if ((current_state.IsState(CSVState::DELIMITER) || current_state.IsState(CSVState::CARRIAGE_RETURN) ||
-		     current_state.IsState(CSVState::RECORD_SEPARATOR))) {
+		if (current_state.IsState(CSVState::DELIMITER) || current_state.IsState(CSVState::CARRIAGE_RETURN) ||
+		    current_state.IsState(CSVState::RECORD_SEPARATOR)) {
 			return buffer_handle_ptr[iterator.pos.buffer_pos - 2] ==
 			       state_machine->dialect_options.state_machine_options.quote.GetValue();
 		}
@@ -1704,6 +1708,9 @@ void StringValueScanner::SetStart() {
 		if (!best_row.is_valid && !quoted_row.is_valid && best_row.start_pos < quoted_row.start_pos) {
 			best_row = quoted_row;
 		}
+		if (quoted_row.is_valid && quoted_row.start_pos < best_row.start_pos) {
+			best_row = quoted_row;
+		}
 	}
 	// 3. We are in an escaped value
 	if (!best_row.is_valid && state_machine->dialect_options.state_machine_options.escape.GetValue() != '\0' &&

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

@@ -194,11 +194,18 @@ void CSVErrorHandler::FillRejectsTable(InternalAppender &errors_appender, const
 				errors_appender.Append(Value());
 				break;
 			case CSVErrorType::TOO_FEW_COLUMNS:
-				D_ASSERT(bind_data.return_names.size() > col_idx + 1);
-				errors_appender.Append(string_t(bind_data.return_names[col_idx + 1]));
+				if (col_idx + 1 < bind_data.return_names.size()) {
+					errors_appender.Append(string_t(bind_data.return_names[col_idx + 1]));
+				} else {
+					errors_appender.Append(Value());
+				}
 				break;
 			default:
-				errors_appender.Append(string_t(bind_data.return_names[col_idx]));
+				if (col_idx < bind_data.return_names.size()) {
+					errors_appender.Append(string_t(bind_data.return_names[col_idx]));
+				} else {
+					errors_appender.Append(Value());
+				}
 			}
 			// 8. Error Type
 			errors_appender.Append(string_t(CSVErrorTypeToEnum(error.type)));

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "4-dev4889"
+#define DUCKDB_PATCH_VERSION "4-dev4923"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 1
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.4-dev4889"
+#define DUCKDB_VERSION "v1.1.4-dev4923"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "5d02d69e5c"
+#define DUCKDB_SOURCE_ID "d0c4cf8a28"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -47,7 +47,6 @@ struct MultiFileReaderColumnDefinition {
 	      identifier(other.identifier) {
 	}
 
-	MultiFileReaderColumnDefinition(MultiFileReaderColumnDefinition &&other) noexcept = default;
 	MultiFileReaderColumnDefinition &operator=(const MultiFileReaderColumnDefinition &other) {
 		if (this != &other) {
 			name = other.name;
@@ -58,7 +57,6 @@ struct MultiFileReaderColumnDefinition {
 		}
 		return *this;
 	}
-	MultiFileReaderColumnDefinition &operator=(MultiFileReaderColumnDefinition &&other) noexcept = default;
 
 public:
 	static vector<MultiFileReaderColumnDefinition> ColumnsFromNamesAndTypes(const vector<string> &names,

src/duckdb/src/include/duckdb/common/serializer/deserializer.hpp

@@ -81,7 +81,7 @@ class Deserializer {
 	}
 
 	template <typename T>
-	inline T ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T &&default_value) {
+	inline T ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T default_value) {
 		if (!OnOptionalPropertyBegin(field_id, tag)) {
 			OnOptionalPropertyEnd(false);
 			return std::forward<T>(default_value);
@@ -104,7 +104,7 @@ class Deserializer {
 	}
 
 	template <typename T>
-	inline void ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T &ret, T &&default_value) {
+	inline void ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T &ret, T default_value) {
 		if (!OnOptionalPropertyBegin(field_id, tag)) {
 			ret = std::forward<T>(default_value);
 			OnOptionalPropertyEnd(false);
@@ -116,7 +116,7 @@ class Deserializer {
 
 	template <typename T>
 	inline void ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, CSVOption<T> &ret,
-	                                            T &&default_value) {
+	                                            T default_value) {
 		if (!OnOptionalPropertyBegin(field_id, tag)) {
 			ret = std::forward<T>(default_value);
 			OnOptionalPropertyEnd(false);

src/duckdb/src/include/duckdb/common/serializer/serializer.hpp

@@ -105,7 +105,7 @@ class Serializer {
 	}
 
 	template <class T>
-	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const T &value, const T &&default_value) {
+	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const T &value, const T &default_value) {
 		// If current value is default, don't write it
 		if (!options.serialize_default_values && (value == default_value)) {
 			OnOptionalPropertyBegin(field_id, tag, false);
@@ -120,7 +120,7 @@ class Serializer {
 	// Specialization for Value (default Value comparison throws when comparing nulls)
 	template <class T>
 	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const CSVOption<T> &value,
-	                              const T &&default_value) {
+	                              const T &default_value) {
 		// If current value is default, don't write it
 		if (!options.serialize_default_values && (value == default_value)) {
 			OnOptionalPropertyBegin(field_id, tag, false);
@@ -383,7 +383,7 @@ void Serializer::WriteValue(const vector<bool> &vec);
 // Specialization for Value (default Value comparison throws when comparing nulls)
 template <>
 void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
-                                                 const Value &&default_value);
+                                                 const Value &default_value);
 
 // List Impl
 template <class FUNC>

src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -419,6 +419,8 @@ class Binder : public enable_shared_from_this<Binder> {
 	const string BindCatalog(string &catalog_name);
 	SchemaCatalogEntry &BindCreateSchema(CreateInfo &info);
 
+	LogicalType BindLogicalTypeInternal(const LogicalType &type, optional_ptr<Catalog> catalog, const string &schema);
+
 	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
 
 	unique_ptr<LogicalOperator> BindCopyDatabaseSchema(Catalog &source_catalog, const string &target_database_name);

src/duckdb/src/main/extension/extension_install.cpp

@@ -90,6 +90,12 @@ string ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, FileSyst
 	extension_directory = fs.ConvertSeparators(extension_directory);
 	// expand ~ in extension directory
 	extension_directory = fs.ExpandPath(extension_directory);
+
+	auto path_components = PathComponents();
+	for (auto &path_ele : path_components) {
+		extension_directory = fs.JoinPath(extension_directory, path_ele);
+	}
+
 	return extension_directory;
 }
 
@@ -117,13 +123,6 @@ string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs)
 	}
 	D_ASSERT(fs.DirectoryExists(extension_directory));
 
-	auto path_components = PathComponents();
-	for (auto &path_ele : path_components) {
-		extension_directory = fs.JoinPath(extension_directory, path_ele);
-		if (!fs.DirectoryExists(extension_directory)) {
-			fs.CreateDirectory(extension_directory);
-		}
-	}
 	return extension_directory;
 }