duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -20,8 +20,6 @@
 namespace duckdb {
 
 class CastFunctionSet;
-class Deserializer;
-class Serializer;
 struct GetCastFunctionInput;
 struct ExtraValueInfo;
 
@@ -120,7 +118,7 @@ public:
 	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(dtime_t time);
-	DUCKDB_API static Value TIMETZ(dtime_t time);
+	DUCKDB_API static Value TIMETZ(dtime_tz_t time);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
 	//! Create a timestamp Value from a specified date/time combination
@@ -177,7 +175,10 @@ public:
 	template <class T>
 	T GetValue() const;
 	template <class T>
-	static Value CreateValue(T value);
+	static Value CreateValue(T value) {
+		static_assert(AlwaysFalse<T>::value, "No specialization exists for this type");
+		return Value(nullptr);
+	}
 	// Returns the internal value. Unlike GetValue(), this method does not perform casting, and assumes T matches the
 	// type of the value. Only use this if you know what you are doing.
 	template <class T>
@@ -222,10 +223,8 @@ public:
 
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static Value FormatDeserialize(FormatDeserializer &deserializer);
 	//! Deserializes a Value from a blob
-	DUCKDB_API static Value Deserialize(Deserializer &source);
+	DUCKDB_API static Value Deserialize(Deserializer &deserializer);
 
 	//===--------------------------------------------------------------------===//
 	// Comparison Operators
@@ -299,6 +298,7 @@ private:
 		uint64_t hash;
 		date_t date;
 		dtime_t time;
+		dtime_tz_t timetz;
 		timestamp_t timestamp;
 		interval_t interval;
 	} value_; // NOLINT
@@ -394,6 +394,7 @@ struct ListValue {
 struct UnionValue {
 	DUCKDB_API static const Value &GetValue(const Value &value);
 	DUCKDB_API static uint8_t GetTag(const Value &value);
+	DUCKDB_API static const LogicalType &GetType(const Value &value);
 };
 
 //! Return the internal integral value for any type that is stored as an integral value internally

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -35,6 +35,11 @@ struct UnifiedVectorFormat {
 	}
 };
 
+struct RecursiveUnifiedVectorFormat {
+	UnifiedVectorFormat unified;
+	vector<RecursiveUnifiedVectorFormat> children;
+};
+
 class VectorCache;
 class VectorStructBuffer;
 class VectorListBuffer;
@@ -96,14 +101,14 @@ public:
 	DUCKDB_API void Reference(const Value &value);
 	//! Causes this vector to reference the data held by the other vector.
 	//! The type of the "other" vector should match the type of this vector
-	DUCKDB_API void Reference(Vector &other);
+	DUCKDB_API void Reference(const Vector &other);
 	//! Reinterpret the data of the other vector as the type of this vector
 	//! Note that this takes the data of the other vector as-is and places it in this vector
 	//! Without changing the type of this vector
-	DUCKDB_API void Reinterpret(Vector &other);
+	DUCKDB_API void Reinterpret(const Vector &other);
 
 	//! Causes this vector to reference the data held by the other vector, changes the type if required.
-	DUCKDB_API void ReferenceAndSetType(Vector &other);
+	DUCKDB_API void ReferenceAndSetType(const Vector &other);
 
 	//! Resets a vector from a vector cache.
 	//! This turns the vector back into an empty FlatVector with STANDARD_VECTOR_SIZE entries.
@@ -140,6 +145,8 @@ public:
 	//! The most common vector types (flat, constant & dictionary) can be converted to the canonical format "for free"
 	//! ToUnifiedFormat was originally called Orrify, as a tribute to Orri Erling who came up with it
 	DUCKDB_API void ToUnifiedFormat(idx_t count, UnifiedVectorFormat &data);
+	//! Recursively calls UnifiedVectorFormat on a vector and its child vectors (for nested types)
+	static void RecursiveToUnifiedFormat(Vector &input, idx_t count, RecursiveUnifiedVectorFormat &data);
 
 	//! Turn the vector into a sequence vector
 	DUCKDB_API void Sequence(int64_t start, int64_t increment, idx_t count);
@@ -166,13 +173,8 @@ public:
 	//! This functions resizes the vector
 	DUCKDB_API void Resize(idx_t cur_size, idx_t new_size);
 
-	//! Serializes a Vector to a stand-alone binary blob
-	DUCKDB_API void Serialize(idx_t count, Serializer &serializer);
-	//! Deserializes a blob back into a Vector
-	DUCKDB_API void Deserialize(idx_t count, Deserializer &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer, idx_t count);
-	DUCKDB_API void FormatDeserialize(FormatDeserializer &deserializer, idx_t count);
+	DUCKDB_API void Serialize(Serializer &serializer, idx_t count);
+	DUCKDB_API void Deserialize(Deserializer &deserializer, idx_t count);
 
 	// Getters
 	inline VectorType GetVectorType() const {
@@ -445,7 +447,7 @@ struct StructVector {
 	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
 };
 
-enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP };
+enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP, TAG_MISMATCH };
 
 struct UnionVector {
 	// Unions are stored as structs, but the first child is always the "tag"

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -17,28 +17,12 @@
 
 namespace duckdb {
 
-class FormatSerializer;
-class FormatDeserializer;
 class Serializer;
 class Deserializer;
 class Value;
 class TypeCatalogEntry;
 class Vector;
 class ClientContext;
-class FieldWriter;
-
-//! Extra Type Info Type
-enum class ExtraTypeInfoType : uint8_t {
-	INVALID_TYPE_INFO = 0,
-	GENERIC_TYPE_INFO = 1,
-	DECIMAL_TYPE_INFO = 2,
-	STRING_TYPE_INFO = 3,
-	LIST_TYPE_INFO = 4,
-	STRUCT_TYPE_INFO = 5,
-	ENUM_TYPE_INFO = 6,
-	USER_TYPE_INFO = 7,
-	AGGREGATE_STATE_TYPE_INFO = 8
-};
 
 struct string_t;
 
@@ -296,16 +280,8 @@ struct LogicalType {
 		return !(*this == rhs);
 	}
 
-	//! Serializes a LogicalType to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
-
-	DUCKDB_API void SerializeEnumType(Serializer &serializer) const;
-
-	//! Deserializes a blob back into an LogicalType
-	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
-
-	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
-	DUCKDB_API static LogicalType FormatDeserialize(FormatDeserializer &deserializer);
+	DUCKDB_API static LogicalType Deserialize(Deserializer &deserializer);
 
 
 	static bool TypeIsTimestamp(LogicalTypeId id) {
@@ -328,8 +304,6 @@ struct LogicalType {
 
 	DUCKDB_API static LogicalType MaxLogicalType(const LogicalType &left, const LogicalType &right);
 
-	DUCKDB_API static ExtraTypeInfoType GetExtraTypeInfoType(const ExtraTypeInfo &type);
-
 	//! Gets the decimal properties of a numeric type. Fails if the type is not numeric.
 	DUCKDB_API bool GetDecimalProperties(uint8_t &width, uint8_t &scale) const;
 
@@ -388,9 +362,10 @@ public:
 	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
 	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
-	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
 	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
 	DUCKDB_API static LogicalType UNION( child_list_t<LogicalType> members);     // NOLINT
+	DUCKDB_API static LogicalType ENUM(Vector &ordered_data, idx_t size); // NOLINT
+	// DEPRECATED - provided for backwards compatibility
 	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
 	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
@@ -415,21 +390,17 @@ struct ListType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
 };
 
-struct UserType{
+struct UserType {
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 };
 
-struct EnumType{
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+struct EnumType {
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
 	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static void SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry);
-	DUCKDB_API static optional_ptr<TypeCatalogEntry> GetCatalog(const LogicalType &type);
-	DUCKDB_API static string GetSchemaName(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
-	DUCKDB_API static void Serialize(FieldWriter& writer, const ExtraTypeInfo& type_info, bool serialize_internals);
+	DUCKDB_API static string_t GetString(const LogicalType &type, idx_t pos);
 };
 
 struct StructType {
@@ -437,6 +408,7 @@ struct StructType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type, idx_t index);
 	DUCKDB_API static const string &GetChildName(const LogicalType &type, idx_t index);
 	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
+	DUCKDB_API static bool IsUnnamed(const LogicalType &type);
 };
 
 struct MapType {
@@ -480,6 +452,7 @@ bool ApproxEqual(float l, float r);
 bool ApproxEqual(double l, double r);
 
 struct aggregate_state_t {
+	aggregate_state_t() {}
 	aggregate_state_t(string function_name_p, LogicalType return_type_p, vector<LogicalType> bound_argument_types_p) : function_name(std::move(function_name_p)), return_type(std::move(return_type_p)), bound_argument_types(std::move(bound_argument_types_p)) {
 	}
 

package/src/duckdb/src/include/duckdb/common/vector.hpp

@@ -88,14 +88,14 @@ public:
 	}
 
 	typename original::reference back() {
-		if (original::empty()) {
+		if (MemorySafety<SAFE>::enabled && original::empty()) {
 			throw InternalException("'back' called on an empty vector!");
 		}
 		return get<SAFE>(original::size() - 1);
 	}
 
 	typename original::const_reference back() const {
-		if (original::empty()) {
+		if (MemorySafety<SAFE>::enabled && original::empty()) {
 			throw InternalException("'back' called on an empty vector!");
 		}
 		return get<SAFE>(original::size() - 1);

package/src/duckdb/src/include/duckdb/common/vector_operations/aggregate_executor.hpp

@@ -15,9 +15,14 @@
 
 namespace duckdb {
 
+// structs
 struct AggregateInputData;
-
-typedef std::pair<idx_t, idx_t> FrameBounds;
+struct FrameBounds {
+	FrameBounds() : start(0), end(0) {};
+	FrameBounds(idx_t start, idx_t end) : start(start), end(end) {};
+	idx_t start = 0;
+	idx_t end = 0;
+};
 
 class AggregateExecutor {
 private:

package/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/map.hpp"
+#include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
 
@@ -22,120 +23,62 @@ public:
 	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
 	                                FileOpener *opener = nullptr) override;
 
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Read(handle, buffer, nr_bytes, location);
-	};
+	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
+	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
 
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Write(handle, buffer, nr_bytes, location);
-	}
+	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Read(handle, buffer, nr_bytes);
-	}
+	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Write(handle, buffer, nr_bytes);
-	}
+	int64_t GetFileSize(FileHandle &handle) override;
+	time_t GetLastModifiedTime(FileHandle &handle) override;
+	FileType GetFileType(FileHandle &handle) override;
 
-	int64_t GetFileSize(FileHandle &handle) override {
-		return handle.file_system.GetFileSize(handle);
-	}
-	time_t GetLastModifiedTime(FileHandle &handle) override {
-		return handle.file_system.GetLastModifiedTime(handle);
-	}
-	FileType GetFileType(FileHandle &handle) override {
-		return handle.file_system.GetFileType(handle);
-	}
+	void Truncate(FileHandle &handle, int64_t new_size) override;
 
-	void Truncate(FileHandle &handle, int64_t new_size) override {
-		handle.file_system.Truncate(handle, new_size);
-	}
-
-	void FileSync(FileHandle &handle) override {
-		handle.file_system.FileSync(handle);
-	}
+	void FileSync(FileHandle &handle) override;
 
 	// need to look up correct fs for this
-	bool DirectoryExists(const string &directory) override {
-		return FindFileSystem(directory)->DirectoryExists(directory);
-	}
-	void CreateDirectory(const string &directory) override {
-		FindFileSystem(directory)->CreateDirectory(directory);
-	}
+	bool DirectoryExists(const string &directory) override;
+	void CreateDirectory(const string &directory) override;
 
-	void RemoveDirectory(const string &directory) override {
-		FindFileSystem(directory)->RemoveDirectory(directory);
-	}
+	void RemoveDirectory(const string &directory) override;
 
 	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-	               FileOpener *opener = nullptr) override {
-		return FindFileSystem(directory)->ListFiles(directory, callback, opener);
-	}
-
-	void MoveFile(const string &source, const string &target) override {
-		FindFileSystem(source)->MoveFile(source, target);
-	}
-
-	bool FileExists(const string &filename) override {
-		return FindFileSystem(filename)->FileExists(filename);
-	}
-
-	bool IsPipe(const string &filename) override {
-		return FindFileSystem(filename)->IsPipe(filename);
-	}
-	virtual void RemoveFile(const string &filename) override {
-		FindFileSystem(filename)->RemoveFile(filename);
-	}
-
-	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
-		return FindFileSystem(path)->Glob(path, opener);
-	}
-
-	void RegisterSubSystem(unique_ptr<FileSystem> fs) override {
-		sub_systems.push_back(std::move(fs));
-	}
-
-	void UnregisterSubSystem(const string &name) override {
-		for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) {
-			if (sub_system->get()->GetName() == name) {
-				sub_systems.erase(sub_system);
-				return;
-			}
-		}
-		throw InvalidInputException("Could not find filesystem with name %s", name);
-	}
-
-	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override {
-		compressed_fs[compression_type] = std::move(fs);
-	}
-
-	vector<string> ListSubSystems() override {
-		vector<string> names(sub_systems.size());
-		for (idx_t i = 0; i < sub_systems.size(); i++) {
-			names[i] = sub_systems[i]->GetName();
-		}
-		return names;
-	}
-
-	std::string GetName() const override {
-		return "VirtualFileSystem";
-	}
+	               FileOpener *opener = nullptr) override;
+
+	void MoveFile(const string &source, const string &target) override;
+
+	bool FileExists(const string &filename) override;
+
+	bool IsPipe(const string &filename) override;
+	virtual void RemoveFile(const string &filename) override;
+
+	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override;
+
+	void RegisterSubSystem(unique_ptr<FileSystem> fs) override;
+
+	void UnregisterSubSystem(const string &name) override;
+
+	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override;
+
+	vector<string> ListSubSystems() override;
+
+	std::string GetName() const override;
+
+	void SetDisabledFileSystems(const vector<string> &names) override;
+
+	string PathSeparator(const string &path) override;
 
 private:
-	FileSystem *FindFileSystem(const string &path) {
-		for (auto &sub_system : sub_systems) {
-			if (sub_system->CanHandleFile(path)) {
-				return sub_system.get();
-			}
-		}
-		return default_fs.get();
-	}
+	FileSystem &FindFileSystem(const string &path);
+	FileSystem &FindFileSystemInternal(const string &path);
 
 private:
 	vector<unique_ptr<FileSystem>> sub_systems;
 	map<FileCompressionType, unique_ptr<FileSystem>> compressed_fs;
 	const unique_ptr<FileSystem> default_fs;
+	unordered_set<string> disabled_file_systems;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/corr.hpp

@@ -31,10 +31,10 @@ struct CorrOperation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x_input, const B_TYPE &y_input, AggregateBinaryInput &idata) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x_input, y_input, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.dev_pop_x, x_input);
-		STDDevBaseOperation::Execute<B_TYPE, StddevState>(state.dev_pop_y, y_input);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x, idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.dev_pop_x, x);
+		STDDevBaseOperation::Execute<B_TYPE, StddevState>(state.dev_pop_y, y);
 	}
 
 	template <class STATE, class OP>

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic/covar.hpp

@@ -5,6 +5,7 @@
 //
 //
 //===----------------------------------------------------------------------===//
+// COVAR_POP(y,x)
 
 #pragma once
 
@@ -29,7 +30,7 @@ struct CovarOperation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
 		// update running mean and d^2
 		const uint64_t n = ++(state.count);
 
@@ -39,6 +40,7 @@ struct CovarOperation {
 		const double dy = (y - state.meany);
 		const double meany = state.meany + dy / n;
 
+		//  Schubert and Gertz SSDBM 2018 (4.3)
 		const double C = state.co_moment + dx * (y - meany);
 
 		state.meanx = meanx;

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 
@@ -197,7 +199,7 @@ struct StringAggFun {
 	static constexpr const char *Name = "string_agg";
 	static constexpr const char *Parameters = "str,arg";
 	static constexpr const char *Description = "Concatenates the column string values with an optional separator.";
-	static constexpr const char *Example = "string_agg(A, '-)";
+	static constexpr const char *Example = "string_agg(A, '-')";
 
 	static AggregateFunctionSet GetFunctions();
 };

package/src/duckdb/src/include/duckdb/core_functions/aggregate/holistic_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/nested_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_count.hpp

@@ -5,6 +5,7 @@
 //
 //
 //===----------------------------------------------------------------------===//
+// REGR_COUNT(y, x)
 
 #pragma once
 

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression/regr_slope.hpp

@@ -25,9 +25,9 @@ struct RegrSlopeOperation {
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
-	static void Operation(STATE &state, const A_TYPE &x, const B_TYPE &y, AggregateBinaryInput &idata) {
-		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, x, y, idata);
-		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, y);
+	static void Operation(STATE &state, const A_TYPE &y, const B_TYPE &x, AggregateBinaryInput &idata) {
+		CovarOperation::Operation<A_TYPE, B_TYPE, CovarState, OP>(state.cov_pop, y, x,idata);
+		STDDevBaseOperation::Execute<A_TYPE, StddevState>(state.var_pop, x);
 	}
 
 	template <class STATE, class OP>

package/src/duckdb/src/include/duckdb/core_functions/aggregate/regression_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 

package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 
@@ -16,7 +18,7 @@ namespace duckdb {
 struct GetBitFun {
 	static constexpr const char *Name = "get_bit";
 	static constexpr const char *Parameters = "bitstring,index";
-	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0.";
+	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0";
 	static constexpr const char *Example = "get_bit('0110010'::BIT, 2)";
 
 	static ScalarFunction GetFunction();
@@ -25,7 +27,7 @@ struct GetBitFun {
 struct SetBitFun {
 	static constexpr const char *Name = "set_bit";
 	static constexpr const char *Parameters = "bitstring,index,new_value";
-	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring.";
+	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring";
 	static constexpr const char *Example = "set_bit('0110010'::BIT, 2, 0)";
 
 	static ScalarFunction GetFunction();
@@ -34,7 +36,7 @@ struct SetBitFun {
 struct BitPositionFun {
 	static constexpr const char *Name = "bit_position";
 	static constexpr const char *Parameters = "substring,bitstring";
-	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it’s not present. The first (leftmost) bit is indexed 1";
+	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it is not present. The first (leftmost) bit is indexed 1";
 	static constexpr const char *Example = "bit_position('010'::BIT, '1110101'::BIT)";
 
 	static ScalarFunction GetFunction();
@@ -43,7 +45,7 @@ struct BitPositionFun {
 struct BitStringFun {
 	static constexpr const char *Name = "bitstring";
 	static constexpr const char *Parameters = "bitstring,length";
-	static constexpr const char *Description = "Pads the bitstring until the specified length.";
+	static constexpr const char *Description = "Pads the bitstring until the specified length";
 	static constexpr const char *Example = "bitstring('1010'::BIT, 7)";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp

@@ -5,7 +5,9 @@
 //
 //
 //===----------------------------------------------------------------------===//
-// This file is generated by scripts/generate_functions.py
+// This file is automatically generated by scripts/generate_functions.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
 
 #pragma once
 
@@ -16,7 +18,7 @@ namespace duckdb {
 struct DecodeFun {
 	static constexpr const char *Name = "decode";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8.";
+	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8";
 	static constexpr const char *Example = "decode('\\xC3\\xBC'::BLOB)";
 
 	static ScalarFunction GetFunction();
@@ -25,7 +27,7 @@ struct DecodeFun {
 struct EncodeFun {
 	static constexpr const char *Name = "encode";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding.";
+	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding";
 	static constexpr const char *Example = "encode('my_string_with_ü')";
 
 	static ScalarFunction GetFunction();
@@ -34,7 +36,7 @@ struct EncodeFun {
 struct FromBase64Fun {
 	static constexpr const char *Name = "from_base64";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert a base64 encoded string to a character string.";
+	static constexpr const char *Description = "Convert a base64 encoded string to a character string";
 	static constexpr const char *Example = "from_base64('QQ==')";
 
 	static ScalarFunction GetFunction();
@@ -43,7 +45,7 @@ struct FromBase64Fun {
 struct ToBase64Fun {
 	static constexpr const char *Name = "to_base64";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert a blob to a base64 encoded string.";
+	static constexpr const char *Description = "Convert a blob to a base64 encoded string";
 	static constexpr const char *Example = "base64('A'::blob)";
 
 	static ScalarFunction GetFunction();